debug

Co-authored-by: Mark Tolmacs <mark@lazycat.hu>

.github/workflows/cancel.yml

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

.github/workflows/locales-coverage.yml

@@ -40,7 +40,7 @@ jobs:
           echo ::set-output name=body::$body
 
       - name: Update description with coverage
-        uses: kt3k/update-pr-description@v1.0.1
+        uses: kt3k/update-pr-description@1b35a6dcd84d81aa0bc1889610efdcde7f37b0c0 # v1.0.1
         with:
           pr_body: ${{ steps.getCommentBody.outputs.body }}
           pr_title: "chore: Update translations from Crowdin"

.github/workflows/publish-docker.yml

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

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

@@ -11,6 +11,6 @@ jobs:
   semantic:
     runs-on: ubuntu-latest
     steps:
-      - uses: amannn/action-semantic-pull-request@v5
+      - uses: amannn/action-semantic-pull-request@e32d7e603df1aa1ba07e981f2a23455dee596825 # v5
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/size-limit.yml

@@ -20,7 +20,7 @@ jobs:
         working-directory: packages/excalidraw
         env:
           CI: true
-      - uses: andresz1/size-limit-action@v1
+      - uses: andresz1/size-limit-action@e7493a72a44b113341c0cf6186ab49c17c4b65c1 # v1
         with:
           github_token: ${{ secrets.GITHUB_TOKEN }}
           build_script: build:esm

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

@@ -21,6 +21,6 @@ jobs:
         run: yarn test:coverage
       - name: "Report Coverage"
         if: always() # Also generate the report if tests are failing
-        uses: davelosert/vitest-coverage-report-action@v2
+        uses: davelosert/vitest-coverage-report-action@2500dafcee7dd64f85ab689c0b83798a8359770e # v2
         with:
           github-token: ${{ secrets.GITHUB_TOKEN }}

.playwright-mcp/page-2026-06-26T08-26-20-195Z.yml

@@ -0,0 +1,124 @@
+- generic [ref=e1]:
+  - banner:
+    - heading "Excalidraw" [level=1] [ref=e2]
+  - generic [active] [ref=e5]:
+    - generic:
+      - generic:
+        - generic:
+          - button [ref=e9] [cursor=pointer]:
+            - img [ref=e10]
+          - region "Shapes":
+            - generic [ref=e16]:
+              - generic:
+                - generic:
+                  - text: To move canvas, hold
+                  - generic: Scroll wheel
+                  - text: or
+                  - generic: Space
+                  - text: while dragging, or use the hand tool
+              - heading "Shapes" [level=2] [ref=e17]
+              - generic [ref=e18]:
+                - generic "Keep selected tool active after drawing — Q" [ref=e19] [cursor=pointer]:
+                  - checkbox "Keep selected tool active after drawing"
+                  - img [ref=e21]
+                - generic "Hand (panning tool) — H or null" [ref=e29] [cursor=pointer]:
+                  - radio "Hand (panning tool)"
+                  - img [ref=e31]
+                - generic "Selection — V or 1" [ref=e38] [cursor=pointer]:
+                  - radio "Selection" [checked]
+                  - generic [ref=e39]:
+                    - img [ref=e40]
+                    - generic [ref=e45]: "1"
+                - generic "Rectangle — R or 2" [ref=e46] [cursor=pointer]:
+                  - radio "Rectangle"
+                  - generic [ref=e47]:
+                    - img [ref=e48]
+                    - generic [ref=e52]: "2"
+                - generic "Diamond — D or 3" [ref=e53] [cursor=pointer]:
+                  - radio "Diamond"
+                  - generic [ref=e54]:
+                    - img [ref=e55]
+                    - generic [ref=e59]: "3"
+                - generic "Ellipse — O or 4" [ref=e60] [cursor=pointer]:
+                  - radio "Ellipse"
+                  - generic [ref=e61]:
+                    - img [ref=e62]
+                    - generic [ref=e66]: "4"
+                - generic "Arrow — A or 5" [ref=e67] [cursor=pointer]:
+                  - radio "Arrow"
+                  - generic [ref=e68]:
+                    - img [ref=e69]
+                    - generic [ref=e74]: "5"
+                - generic "Line — L or 6" [ref=e75] [cursor=pointer]:
+                  - radio "Line"
+                  - generic [ref=e76]:
+                    - img [ref=e77]
+                    - generic [ref=e78]: "6"
+                - generic "Draw — P or 7" [ref=e79] [cursor=pointer]:
+                  - radio "Draw"
+                  - generic [ref=e80]:
+                    - img [ref=e81]
+                    - generic [ref=e85]: "7"
+                - generic "Text — T or 8" [ref=e86] [cursor=pointer]:
+                  - radio "Text"
+                  - generic [ref=e87]:
+                    - img [ref=e88]
+                    - generic [ref=e93]: "8"
+                - generic "Insert image — 9" [ref=e94] [cursor=pointer]:
+                  - radio "Insert image"
+                  - generic [ref=e95]:
+                    - img [ref=e96]
+                    - generic [ref=e101]: "9"
+                - generic "Eraser — E or 0" [ref=e102] [cursor=pointer]:
+                  - radio "Eraser"
+                  - generic [ref=e103]:
+                    - img [ref=e104]
+                    - generic [ref=e109]: "0"
+                - button "More tools" [ref=e112] [cursor=pointer]:
+                  - img [ref=e113]
+          - generic:
+            - generic [ref=e119]:
+              - link "Excalidraw+" [ref=e120] [cursor=pointer]:
+                - /url: https://plus.excalidraw.com/plus?utm_source=excalidraw&utm_medium=app&utm_content=guestBanner#excalidraw-redirect
+              - button "Live collaboration..." [ref=e121] [cursor=pointer]:
+                - img [ref=e122]
+            - generic "Library" [ref=e124]:
+              - checkbox "Library"
+              - img [ref=e127] [cursor=pointer]
+      - contentinfo:
+        - region "Canvas actions" [ref=e132]:
+          - heading "Canvas actions" [level=2] [ref=e133]
+          - generic [ref=e135]:
+            - button "Zoom out" [ref=e136] [cursor=pointer]:
+              - img [ref=e138]
+            - button "Reset zoom" [ref=e140] [cursor=pointer]: 100%
+            - button "Zoom in" [ref=e141] [cursor=pointer]:
+              - img [ref=e143]
+          - generic [ref=e145]:
+            - button "Undo" [disabled] [ref=e148]:
+              - img [ref=e150]
+            - button "Redo" [disabled] [ref=e154]:
+              - img [ref=e156]
+        - generic [ref=e158]:
+          - generic [ref=e159]:
+            - button "lock scroll" [ref=e160] [cursor=pointer]
+            - generic [ref=e161]:
+              - text: overscroll
+              - spinbutton "overscroll" [ref=e162]: "0.2"
+            - generic [ref=e163]:
+              - text: zoom factor
+              - spinbutton "zoom factor" [ref=e164]: "0.2"
+            - generic [ref=e165]:
+              - checkbox "lock zoom" [ref=e166]
+              - text: lock zoom
+            - generic [ref=e167]:
+              - checkbox "animate" [ref=e168]
+              - text: animate
+          - link "Blog post on end-to-end encryption in Excalidraw" [ref=e169] [cursor=pointer]:
+            - /url: https://plus.excalidraw.com/blog/end-to-end-encryption
+            - img [ref=e171]
+        - button "Help" [ref=e174] [cursor=pointer]:
+          - img [ref=e175]
+    - generic:
+      - img
+    - generic [ref=e180]: Drawing canvas

.playwright-mcp/page-2026-06-26T08-26-34-790Z.yml

@@ -0,0 +1,126 @@
+- generic [ref=e1]:
+  - banner:
+    - heading "Excalidraw" [level=1] [ref=e2]
+  - generic [ref=e5]:
+    - generic:
+      - generic:
+        - generic:
+          - generic:
+            - img
+            - img
+        - generic:
+          - text: Your drawings are saved in your browser's storage.
+          - text: Browser storage can be cleared unexpectedly.
+          - text: Save your work to a file regularly to avoid losing it.
+        - generic:
+          - button "Open Ctrl+O" [ref=e181] [cursor=pointer]:
+            - img [ref=e183]
+            - generic [ref=e185]: Open
+            - generic [ref=e186]: Ctrl+O
+          - button "Help ?" [ref=e187] [cursor=pointer]:
+            - img [ref=e189]
+            - generic [ref=e194]: Help
+            - generic [ref=e195]: "?"
+          - button "Live collaboration..." [ref=e196] [cursor=pointer]:
+            - img [ref=e198]
+            - generic [ref=e205]: Live collaboration...
+          - link "Sign up" [ref=e206] [cursor=pointer]:
+            - /url: https://plus.excalidraw.com/plus?utm_source=excalidraw&utm_medium=app&utm_content=welcomeScreenGuest
+            - img [ref=e208]
+            - generic [ref=e214]: Sign up
+      - generic:
+        - generic:
+          - button [ref=e9] [cursor=pointer]:
+            - img [ref=e10]
+          - region "Shapes":
+            - generic [ref=e16]:
+              - generic:
+                - generic:
+                  - text: To move canvas, hold
+                  - generic: Scroll wheel
+                  - text: or
+                  - generic: Space
+                  - text: while dragging, or use the hand tool
+              - heading "Shapes" [level=2] [ref=e17]
+              - generic [ref=e18]:
+                - generic "Keep selected tool active after drawing — Q" [ref=e19] [cursor=pointer]:
+                  - checkbox "Keep selected tool active after drawing"
+                  - img [ref=e21]
+                - generic "Hand (panning tool) — H or null" [ref=e29] [cursor=pointer]:
+                  - radio "Hand (panning tool)"
+                  - img [ref=e31]
+                - generic "Selection" [ref=e215] [cursor=pointer]:
+                  - radio "Selection" [checked]
+                  - img [ref=e217]
+                - generic "Rectangle — R or 2" [ref=e46] [cursor=pointer]:
+                  - radio "Rectangle"
+                  - img [ref=e48]
+                - generic "Diamond — D or 3" [ref=e53] [cursor=pointer]:
+                  - radio "Diamond"
+                  - img [ref=e55]
+                - generic "Ellipse — O or 4" [ref=e60] [cursor=pointer]:
+                  - radio "Ellipse"
+                  - img [ref=e62]
+                - generic "Arrow — A or 5" [ref=e67] [cursor=pointer]:
+                  - radio "Arrow"
+                  - img [ref=e69]
+                - generic "Line — L or 6" [ref=e75] [cursor=pointer]:
+                  - radio "Line"
+                  - img [ref=e77]
+                - generic "Draw — P or 7" [ref=e79] [cursor=pointer]:
+                  - radio "Draw"
+                  - img [ref=e81]
+                - generic "Text — T or 8" [ref=e86] [cursor=pointer]:
+                  - radio "Text"
+                  - img [ref=e88]
+                - generic "Insert image — 9" [ref=e94] [cursor=pointer]:
+                  - radio "Insert image"
+                  - img [ref=e96]
+                - generic "Eraser — E or 0" [ref=e102] [cursor=pointer]:
+                  - radio "Eraser"
+                  - img [ref=e104]
+                - button "More tools" [ref=e112] [cursor=pointer]:
+                  - img [ref=e113]
+          - generic:
+            - button "Live collaboration..." [ref=e121] [cursor=pointer]:
+              - img [ref=e122]
+            - generic "Library" [ref=e124]:
+              - checkbox "Library"
+              - img [ref=e127] [cursor=pointer]
+      - contentinfo:
+        - region "Canvas actions" [ref=e132]:
+          - heading "Canvas actions" [level=2] [ref=e133]
+          - generic [ref=e135]:
+            - button "Zoom out" [ref=e136] [cursor=pointer]:
+              - img [ref=e138]
+            - button "Reset zoom" [disabled] [ref=e140]: 100%
+            - button "Zoom in" [ref=e141] [cursor=pointer]:
+              - img [ref=e143]
+          - generic [ref=e145]:
+            - button "Undo" [disabled] [ref=e148]:
+              - img [ref=e150]
+            - button "Redo" [disabled] [ref=e154]:
+              - img [ref=e156]
+        - generic [ref=e158]:
+          - generic [ref=e159]:
+            - button "disable scroll lock" [active] [ref=e222] [cursor=pointer]
+            - generic [ref=e161]:
+              - text: overscroll
+              - spinbutton "overscroll" [ref=e162]: "0.2"
+            - generic [ref=e163]:
+              - text: zoom factor
+              - spinbutton "zoom factor" [ref=e164]: "0.2"
+            - generic [ref=e165]:
+              - checkbox "lock zoom" [ref=e166]
+              - text: lock zoom
+            - generic [ref=e167]:
+              - checkbox "animate" [ref=e168]
+              - text: animate
+          - link "Blog post on end-to-end encryption in Excalidraw" [ref=e169] [cursor=pointer]:
+            - /url: https://plus.excalidraw.com/blog/end-to-end-encryption
+            - img [ref=e171]
+        - button "Help" [ref=e174] [cursor=pointer]:
+          - img [ref=e175]
+    - generic:
+      - img
+    - generic [ref=e180]: Drawing canvas

README.md

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

examples/with-nextjs/src/excalidrawWrapper.tsx

@@ -4,8 +4,20 @@ import { Excalidraw } from "@excalidraw/excalidraw";
 
 import "@excalidraw/excalidraw/index.css";
 
+import type { ScrollConstraints } from "@excalidraw/excalidraw/types";
+
 import App from "../../with-script-in-browser/components/ExampleApp";
 
+const scrollConstraints: ScrollConstraints = {
+  x: 0,
+  y: 0,
+  width: 850,
+  height: 400,
+  lockZoom: true,
+  overscrollAllowance: 0,
+  viewportZoomFactor: 1,
+};
+
 const ExcalidrawWrapper: React.FC = () => {
   return (
     <>
@@ -14,7 +26,7 @@ const ExcalidrawWrapper: React.FC = () => {
         useCustom={(api: any, args?: any[]) => {}}
         excalidrawLib={excalidrawLib}
       >
-        <Excalidraw />
+        <Excalidraw scrollConstraints={scrollConstraints} />
       </App>
     </>
   );

examples/with-script-in-browser/components/ExampleApp.tsx

@@ -178,7 +178,8 @@ export default function ExampleApp({
     const newElement = cloneElement(
       Excalidraw,
       {
-        excalidrawAPI: (api: ExcalidrawImperativeAPI) => setExcalidrawAPI(api),
+        onExcalidrawAPI: (api: ExcalidrawImperativeAPI | null) =>
+          setExcalidrawAPI(api),
         initialData: initialStatePromiseRef.current.promise,
         onChange: (
           elements: NonDeletedExcalidrawElement[],
@@ -820,6 +821,48 @@ export default function ExampleApp({
             />
             Export with embed scene
           </label>
+          <button
+            type="button"
+            onClick={() => {
+              if (!excalidrawAPI) {
+                return;
+              }
+
+              const elements = excalidrawAPI.getSceneElements();
+              excalidrawAPI.scrollToContent(elements[0], {
+                animate: true,
+                fitToViewport: true,
+                viewportZoomFactor: 0.9,
+                scrollLock: {
+                  lockZoom: true,
+                  overscrollAllowance: 0,
+                },
+              });
+            }}
+          >
+            Fit and lock first element
+          </button>
+          <button
+            type="button"
+            onClick={() => {
+              if (!excalidrawAPI) {
+                return;
+              }
+
+              const elements = excalidrawAPI.getSceneElements();
+              excalidrawAPI.scrollToContent(elements[1], {
+                animate: true,
+                fitToViewport: true,
+                viewportZoomFactor: 0.9,
+                scrollLock: {
+                  lockZoom: true,
+                  overscrollAllowance: 0,
+                },
+              });
+            }}
+          >
+            Fit and lock second element
+          </button>
           <button
             onClick={async () => {
               if (!excalidrawAPI) {

excalidraw-app/App.tsx

@@ -1015,7 +1015,10 @@ const ExcalidrawWrapper = () => {
             </OverwriteConfirmDialog.Action>
           )}
         </OverwriteConfirmDialog>
-        <AppFooter onChange={() => excalidrawAPI?.refresh()} />
+        <AppFooter
+          excalidrawAPI={excalidrawAPI}
+          onChange={() => excalidrawAPI?.refresh()}
+        />
         {excalidrawAPI && <AIComponents excalidrawAPI={excalidrawAPI} />}
 
         <TTDDialogTrigger />

excalidraw-app/components/AppFooter.tsx

@@ -1,13 +1,178 @@
 import { Footer } from "@excalidraw/excalidraw/index";
-import React from "react";
+import {
+  getCommonBounds,
+  getSelectedElements,
+  getVisibleSceneBounds,
+} from "@excalidraw/element";
+import React, { useCallback, useState } from "react";
+
+import type {
+  ExcalidrawImperativeAPI,
+  ScrollConstraints,
+} from "@excalidraw/excalidraw/types";
 
 import { isExcalidrawPlusSignedUser } from "../app_constants";
 
 import { DebugFooter, isVisualDebuggerEnabled } from "./DebugCanvas";
 import { EncryptedIcon } from "./EncryptedIcon";
 
+type ScrollConstraintOptions = Pick<
+  ScrollConstraints,
+  "lockZoom" | "overscrollAllowance" | "viewportZoomFactor"
+>;
+
+const ScrollConstraintsDebugFooter = ({
+  excalidrawAPI,
+}: {
+  excalidrawAPI: ExcalidrawImperativeAPI | null;
+}) => {
+  const [activeLock, setActiveLock] = useState<ScrollConstraints | null>(null);
+  const [options, setOptions] = useState<ScrollConstraintOptions>({
+    lockZoom: false,
+    overscrollAllowance: 0.2,
+    viewportZoomFactor: 0.2,
+  });
+
+  const setLock = useCallback(
+    (nextLock: ScrollConstraints) => {
+      excalidrawAPI?.setScrollConstraints(nextLock);
+      setActiveLock(nextLock);
+    },
+    [excalidrawAPI],
+  );
+
+  const toggleScrollLock = useCallback(() => {
+    if (!excalidrawAPI) {
+      return;
+    }
+
+    if (activeLock) {
+      excalidrawAPI.setScrollConstraints(null);
+      setActiveLock(null);
+      return;
+    }
+
+    const selectedElements = getSelectedElements(
+      excalidrawAPI.getSceneElements(),
+      excalidrawAPI.getAppState(),
+      {
+        includeBoundTextElement: true,
+        includeElementsInFrames: true,
+      },
+    );
+    const [x1, y1, x2, y2] = selectedElements.length
+      ? getCommonBounds(
+          selectedElements,
+          excalidrawAPI.getSceneElementsMapIncludingDeleted(),
+        )
+      : getVisibleSceneBounds(excalidrawAPI.getAppState());
+
+    setLock({
+      x: x1,
+      y: y1,
+      width: x2 - x1,
+      height: y2 - y1,
+      ...options,
+    });
+  }, [activeLock, excalidrawAPI, options, setLock]);
+
+  const updateOptions = useCallback(
+    (nextOptions: ScrollConstraintOptions) => {
+      setOptions(nextOptions);
+
+      if (activeLock) {
+        setLock({ ...activeLock, ...nextOptions });
+      }
+    },
+    [activeLock, setLock],
+  );
+
+  const updateNumberOption = useCallback(
+    (option: "overscrollAllowance" | "viewportZoomFactor", value: string) => {
+      updateOptions({
+        ...options,
+        [option]: value === "" ? undefined : Number(value),
+      });
+    },
+    [options, updateOptions],
+  );
+
+  const updateBooleanOption = useCallback(
+    (option: "lockZoom", value: boolean) => {
+      updateOptions({
+        ...options,
+        [option]: value,
+      });
+    },
+    [options, updateOptions],
+  );
+
+  return (
+    <div
+      style={{
+        display: "flex",
+        gap: ".45rem",
+        alignItems: "center",
+        padding: "0 .35rem",
+        fontSize: 12,
+      }}
+    >
+      <button
+        className="ToolIcon_type_button"
+        type="button"
+        onClick={toggleScrollLock}
+      >
+        {activeLock ? "disable scroll lock" : "lock scroll"}
+      </button>
+      <label style={{ display: "flex", gap: ".25rem", alignItems: "center" }}>
+        overscroll
+        <input
+          type="number"
+          min={0}
+          max={1}
+          step={0.05}
+          value={options.overscrollAllowance ?? ""}
+          onChange={(event) =>
+            updateNumberOption("overscrollAllowance", event.target.value)
+          }
+          style={{ width: 56 }}
+        />
+      </label>
+      <label style={{ display: "flex", gap: ".25rem", alignItems: "center" }}>
+        zoom factor
+        <input
+          type="number"
+          min={0.1}
+          step={0.1}
+          value={options.viewportZoomFactor ?? ""}
+          onChange={(event) =>
+            updateNumberOption("viewportZoomFactor", event.target.value)
+          }
+          style={{ width: 56 }}
+        />
+      </label>
+      <label style={{ display: "flex", gap: ".2rem", alignItems: "center" }}>
+        <input
+          type="checkbox"
+          checked={!!options.lockZoom}
+          onChange={(event) =>
+            updateBooleanOption("lockZoom", event.target.checked)
+          }
+        />
+        lock zoom
+      </label>
+    </div>
+  );
+};
+
 export const AppFooter = React.memo(
-  ({ onChange }: { onChange: () => void }) => {
+  ({
+    excalidrawAPI,
+    onChange,
+  }: {
+    excalidrawAPI: ExcalidrawImperativeAPI | null;
+    onChange: () => void;
+  }) => {
     return (
       <Footer>
         <div
@@ -17,6 +182,7 @@ export const AppFooter = React.memo(
             alignItems: "center",
           }}
         >
+          <ScrollConstraintsDebugFooter excalidrawAPI={excalidrawAPI} />
           {isVisualDebuggerEnabled() && <DebugFooter onChange={onChange} />}
           {!isExcalidrawPlusSignedUser && <EncryptedIcon />}
         </div>

packages/element/src/bounds.ts

@@ -680,8 +680,9 @@ export const getMinMaxXYFromCurvePathOps = (
   return [minX, minY, maxX, maxY];
 };
 
-export const getBoundsFromPoints = (
+export const getBoundsFromPoints = <P extends GlobalPoint | LocalPoint>(
-  points: ExcalidrawFreeDrawElement["points"],
+  points: readonly P[],
+  padding: number = 0,
 ): Bounds => {
   let minX = Infinity;
   let minY = Infinity;
@@ -695,7 +696,7 @@ export const getBoundsFromPoints = (
     maxY = Math.max(maxY, y);
   }
 
-  return [minX, minY, maxX, maxY];
+  return [minX - padding, minY - padding, maxX + padding, maxY + padding];
 };
 
 const getFreeDrawElementAbsoluteCoords = (
@@ -1261,6 +1262,17 @@ 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,
@@ -1275,13 +1287,21 @@ export const doBoundsIntersect = (
   return minX1 < maxX2 && maxX1 > minX2 && minY1 < maxY2 && maxY1 > minY2;
 };
 
+export const boundsContainBounds = (outerBounds: Bounds, innerBounds: Bounds) =>
+  [
+    pointFrom<GlobalPoint>(innerBounds[0], innerBounds[1]),
+    pointFrom<GlobalPoint>(innerBounds[0], innerBounds[3]),
+    pointFrom<GlobalPoint>(innerBounds[2], innerBounds[1]),
+    pointFrom<GlobalPoint>(innerBounds[2], innerBounds[3]),
+  ].every((point) => pointInsideBoundsInclusive(point, outerBounds));
+
 export const elementCenterPoint = (
   element: ExcalidrawElement,
   elementsMap: ElementsMap,
   xOffset: number = 0,
   yOffset: number = 0,
 ) => {
-  if (isLinearElement(element)) {
+  if (isLinearElement(element) || isFreeDrawElement(element)) {
     const [x1, y1, x2, y2] = getElementAbsoluteCoords(element, elementsMap);
     const [x, y] = pointFrom<GlobalPoint>((x1 + x2) / 2, (y1 + y2) / 2);
 

packages/element/src/collision.ts

@@ -154,14 +154,11 @@ export const hitElementItself = ({
 
   // Hit test against the extended, rotated bounding box of the element first
   const bounds = getElementBounds(element, elementsMap, true);
-  const hitBounds = isPointWithinBounds(
+  const hitBounds = isPointInRotatedBounds(
-    pointFrom(bounds[0] - threshold, bounds[1] - threshold),
+    point,
-    pointRotateRads(
+    bounds,
-      point,
+    element.angle,
-      getCenterForBounds(bounds),
+    threshold,
-      -element.angle as Radians,
-    ),
-    pointFrom(bounds[2] + threshold, bounds[3] + threshold),
   );
 
   // PERF: Bail out early if the point is not even in the
@@ -192,18 +189,32 @@ export const hitElementItself = ({
   return result;
 };
 
+const isPointInRotatedBounds = (
+  point: GlobalPoint,
+  bounds: Bounds,
+  angle: Radians,
+  tolerance = 0,
+) => {
+  const adjustedPoint =
+    angle === 0
+      ? point
+      : pointRotateRads(point, getCenterForBounds(bounds), -angle as Radians);
+
+  return isPointWithinBounds(
+    pointFrom(bounds[0] - tolerance, bounds[1] - tolerance),
+    adjustedPoint,
+    pointFrom(bounds[2] + tolerance, bounds[3] + tolerance),
+  );
+};
+
 export const hitElementBoundingBox = (
   point: GlobalPoint,
   element: ExcalidrawElement,
   elementsMap: ElementsMap,
   tolerance = 0,
 ) => {
-  let [x1, y1, x2, y2] = getElementBounds(element, elementsMap);
+  const bounds = getElementBounds(element, elementsMap, true);
-  x1 -= tolerance;
+  return isPointInRotatedBounds(point, bounds, element.angle, tolerance);
-  y1 -= tolerance;
-  x2 += tolerance;
-  y2 += tolerance;
-  return isPointWithinBounds(pointFrom(x1, y1), point, pointFrom(x2, y2));
 };
 
 export const hitElementBoundingBoxOnly = (
@@ -465,7 +476,12 @@ export const intersectElementWithLineSegment = (
     case "line":
     case "freedraw":
     case "arrow":
-      return intersectLinearOrFreeDrawWithLineSegment(element, line, onlyFirst);
+      return intersectLinearOrFreeDrawWithLineSegment(
+        element,
+        line,
+        elementsMap,
+        onlyFirst,
+      );
   }
 };
 
@@ -532,11 +548,15 @@ 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);
+  const [lines, curves] = deconstructLinearOrFreeDrawElement(
+    element,
+    elementsMap,
+  );
   const intersections: GlobalPoint[] = [];
 
   for (const l of lines) {
@@ -564,7 +584,9 @@ const intersectLinearOrFreeDrawWithLineSegment = (
       continue;
     }
 
-    const hits = curveIntersectLineSegment(c, segment);
+    const hits = curveIntersectLineSegment(c, segment, {
+      iterLimit: 10,
+    });
 
     if (hits.length > 0) {
       intersections.push(...hits);

packages/element/src/distance.ts

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

packages/element/src/frame.ts

@@ -1,7 +1,6 @@
 import { arrayToMap } from "@excalidraw/common";
 import { isPointWithinBounds, pointFrom } from "@excalidraw/math";
 import { doLineSegmentsIntersect } from "@excalidraw/utils/bbox";
-import { elementsOverlappingBBox } from "@excalidraw/utils/withinBounds";
 
 import type {
   AppClassProperties,
@@ -18,6 +17,8 @@ import {
   getElementLineSegments,
   getCommonBounds,
   getElementAbsoluteCoords,
+  doBoundsIntersect,
+  getElementBounds,
 } from "./bounds";
 import { mutateElement } from "./mutateElement";
 import { getBoundTextElement, getContainerElement } from "./textElement";
@@ -920,16 +921,17 @@ export const getFrameLikeTitle = (element: ExcalidrawFrameLikeElement) => {
 export const getElementsOverlappingFrame = (
   elements: readonly ExcalidrawElement[],
   frame: ExcalidrawFrameLikeElement,
+  elementsMap: ElementsMap,
 ) => {
-  return (
+  return elements.filter(
-    elementsOverlappingBBox({
+    (el) =>
-      elements,
+      // exclude elements which are overlapping, but are in a different frame,
-      bounds: frame,
-      type: "overlap",
-    })
-      // removes elements who are overlapping, but are in a different frame,
       // and thus invisible in target frame
-      .filter((el) => !el.frameId || el.frameId === frame.id)
+      (!el.frameId || el.frameId === frame.id) &&
+      doBoundsIntersect(
+        getElementBounds(el, elementsMap),
+        getElementBounds(frame, elementsMap),
+      ),
   );
 };
 

packages/element/src/linearElementEditor.ts

@@ -476,16 +476,22 @@ export class LinearElementEditor {
       });
     }
 
-    invariant(
+    if (
-      lastClickedPoint > -1 &&
+      lastClickedPoint < 0 ||
-        selectedPointsIndices.includes(lastClickedPoint) &&
+      !selectedPointsIndices.includes(lastClickedPoint) ||
-        element.points[lastClickedPoint],
+      !element.points[lastClickedPoint]
-      `There must be a valid lastClickedPoint in order to drag it. selectedPointsIndices(${JSON.stringify(
+    ) {
-        selectedPointsIndices,
+      console.error(
-      )}) points(0..${
+        `There must be a valid lastClickedPoint in order to drag it. selectedPointsIndices(${JSON.stringify(
-        element.points.length - 1
+          selectedPointsIndices,
-      }) lastClickedPoint(${lastClickedPoint})`,
+        )}) points(0..${
-    );
+          element.points.length - 1
+        }) lastClickedPoint(${lastClickedPoint})`,
+      );
+
+      // Fall back to the actual last point as a last resort.
+      lastClickedPoint = element.points.length - 1;
+    }
 
     // point that's being dragged (out of all selected points)
     const draggingPoint = element.points[lastClickedPoint];
@@ -794,6 +800,7 @@ export class LinearElementEditor {
           element.points[index + 1],
           index,
           appState.zoom,
+          elementsMap,
         )
       ) {
         midpoints.push(null);
@@ -803,6 +810,7 @@ export class LinearElementEditor {
       const segmentMidPoint = LinearElementEditor.getSegmentMidPoint(
         element,
         index + 1,
+        elementsMap,
       );
       midpoints.push(segmentMidPoint);
       index++;
@@ -890,6 +898,7 @@ export class LinearElementEditor {
     endPoint: P,
     index: number,
     zoom: Zoom,
+    elementsMap: ElementsMap,
   ) {
     if (isElbowArrow(element)) {
       if (index >= 0 && index < element.points.length) {
@@ -904,7 +913,10 @@ export class LinearElementEditor {
 
     let distance = pointDistance(startPoint, endPoint);
     if (element.points.length > 2 && element.roundness) {
-      const [lines, curves] = deconstructLinearOrFreeDrawElement(element);
+      const [lines, curves] = deconstructLinearOrFreeDrawElement(
+        element,
+        elementsMap,
+      );
 
       invariant(
         lines.length === 0 && curves.length > 0,
@@ -924,6 +936,7 @@ export class LinearElementEditor {
   static getSegmentMidPoint(
     element: NonDeleted<ExcalidrawLinearElement>,
     index: number,
+    elementsMap: ElementsMap,
   ): GlobalPoint {
     if (isElbowArrow(element)) {
       invariant(
@@ -936,7 +949,10 @@ export class LinearElementEditor {
       return pointFrom<GlobalPoint>(element.x + p[0], element.y + p[1]);
     }
 
-    const [lines, curves] = deconstructLinearOrFreeDrawElement(element);
+    const [lines, curves] = deconstructLinearOrFreeDrawElement(
+      element,
+      elementsMap,
+    );
 
     invariant(
       (lines.length === 0 && curves.length > 0) ||
@@ -1851,6 +1867,7 @@ export class LinearElementEditor {
       const midSegmentMidpoint = LinearElementEditor.getSegmentMidPoint(
         element,
         index + 1,
+        elementsMap,
       );
 
       x = midSegmentMidpoint[0] - boundTextElement.width / 2;
@@ -2400,7 +2417,7 @@ const pointDraggingUpdates = (
     ? nextArrow.points[0]
     : endBindable
     ? updateBoundPoint(
-        element,
+        nextArrow,
         "endBinding",
         nextArrow.endBinding,
         endBindable,
@@ -2431,7 +2448,7 @@ const pointDraggingUpdates = (
       ? endLocalPoint
       : startBindable
       ? updateBoundPoint(
-          element,
+          nextArrow,
           "startBinding",
           nextArrow.startBinding,
           startBindable,

packages/element/src/selection.ts

@@ -1,15 +1,32 @@
-import { arrayToMap, isShallowEqual } from "@excalidraw/common";
+import { arrayToMap, isShallowEqual, type Bounds } from "@excalidraw/common";
+import {
+  lineSegment,
+  pointFrom,
+  pointRotateRads,
+  type GlobalPoint,
+} from "@excalidraw/math";
 
 import type {
   AppState,
+  BoxSelectionMode,
   InteractiveCanvasAppState,
 } from "@excalidraw/excalidraw/types";
 
-import { getElementAbsoluteCoords, getElementBounds } from "./bounds";
+import {
+  boundsContainBounds,
+  doBoundsIntersect,
+  elementCenterPoint,
+  getElementAbsoluteCoords,
+  getElementBounds,
+  pointInsideBounds,
+} from "./bounds";
+import { intersectElementWithLineSegment } from "./collision";
 import { isElementInViewport } from "./sizeHelpers";
 import {
+  isArrowElement,
   isBoundToContainer,
   isFrameLikeElement,
+  isFreeDrawElement,
   isLinearElement,
   isTextElement,
 } from "./typeChecks";
@@ -17,19 +34,38 @@ import {
   elementOverlapsWithFrame,
   getContainingFrame,
   getFrameChildren,
+  isElementIntersectingFrame,
 } from "./frame";
 
 import { LinearElementEditor } from "./linearElementEditor";
 import { selectGroupsForSelectedElements } from "./groups";
+import { getBoundTextElement } from "./textElement";
 
 import type {
   ElementsMap,
   ElementsMapOrArray,
   ExcalidrawElement,
+  ExcalidrawFrameLikeElement,
   NonDeleted,
   NonDeletedExcalidrawElement,
 } from "./types";
 
+const shouldIgnoreElementFromSelection = (
+  element: NonDeletedExcalidrawElement,
+) => element.locked || isBoundToContainer(element);
+
+const excludeElementsFromFrames = <T extends ExcalidrawElement>(
+  selectedElements: readonly T[],
+  framesInSelection: Set<ExcalidrawFrameLikeElement["id"]>,
+) => {
+  return selectedElements.filter((element) => {
+    if (element.frameId && framesInSelection.has(element.frameId)) {
+      return false;
+    }
+    return true;
+  });
+};
+
 /**
  * Frames and their containing elements are not to be selected at the same time.
  * Given an array of selected elements, if there are frames and their containing elements
@@ -49,55 +85,243 @@ export const excludeElementsInFramesFromSelection = <
     }
   });
 
-  return selectedElements.filter((element) => {
+  return excludeElementsFromFrames(selectedElements, framesInSelection);
-    if (element.frameId && framesInSelection.has(element.frameId)) {
-      return false;
-    }
-    return true;
-  });
 };
 
 export const getElementsWithinSelection = (
   elements: readonly NonDeletedExcalidrawElement[],
   selection: NonDeletedExcalidrawElement,
   elementsMap: ElementsMap,
+  // TODO remove (this flag is effectively unused AFAIK)
   excludeElementsInFrames: boolean = true,
-) => {
+  boxSelectionMode: BoxSelectionMode = "contain",
-  const [selectionX1, selectionY1, selectionX2, selectionY2] =
+): NonDeletedExcalidrawElement[] => {
+  const [selectionStartX, selectionStartY, selectionEndX, selectionEndY] =
     getElementAbsoluteCoords(selection, elementsMap);
+  const selectionX1 = Math.min(selectionStartX, selectionEndX);
+  const selectionY1 = Math.min(selectionStartY, selectionEndY);
+  const selectionX2 = Math.max(selectionStartX, selectionEndX);
+  const selectionY2 = Math.max(selectionStartY, selectionEndY);
+  const selectionBounds = [
+    selectionX1,
+    selectionY1,
+    selectionX2,
+    selectionY2,
+  ] as Bounds;
+  const selectionEdges = [
+    lineSegment<GlobalPoint>(
+      pointFrom(selectionX1, selectionY1),
+      pointFrom(selectionX2, selectionY1),
+    ),
+    lineSegment<GlobalPoint>(
+      pointFrom(selectionX2, selectionY1),
+      pointFrom(selectionX2, selectionY2),
+    ),
+    lineSegment<GlobalPoint>(
+      pointFrom(selectionX2, selectionY2),
+      pointFrom(selectionX1, selectionY2),
+    ),
+    lineSegment<GlobalPoint>(
+      pointFrom(selectionX1, selectionY2),
+      pointFrom(selectionX1, selectionY1),
+    ),
+  ];
 
-  let elementsInSelection = elements.filter((element) => {
+  const framesInSelection = excludeElementsInFrames
-    let [elementX1, elementY1, elementX2, elementY2] = getElementBounds(
+    ? new Set<NonDeletedExcalidrawElement["id"]>()
-      element,
+    : null;
-      elementsMap,
+  let elementsInSelection: NonDeletedExcalidrawElement[] = [];
-    );
 
-    const containingFrame = getContainingFrame(element, elementsMap);
+  for (const element of elements) {
-    if (containingFrame) {
+    if (shouldIgnoreElementFromSelection(element)) {
-      const [fx1, fy1, fx2, fy2] = getElementBounds(
+      continue;
-        containingFrame,
-        elementsMap,
-      );
-
-      elementX1 = Math.max(fx1, elementX1);
-      elementY1 = Math.max(fy1, elementY1);
-      elementX2 = Math.min(fx2, elementX2);
-      elementY2 = Math.min(fy2, elementY2);
     }
 
-    return (
+    const strokeWidth = element.strokeWidth;
-      element.locked === false &&
+    let labelAABB: Bounds | null = null;
-      element.type !== "selection" &&
+    let elementAABB = getElementBounds(element, elementsMap);
-      !isBoundToContainer(element) &&
-      selectionX1 <= elementX1 &&
-      selectionY1 <= elementY1 &&
-      selectionX2 >= elementX2 &&
-      selectionY2 >= elementY2
-    );
-  });
 
-  elementsInSelection = excludeElementsInFrames
+    elementAABB = [
-    ? excludeElementsInFramesFromSelection(elementsInSelection)
+      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 &&
+      isElementIntersectingFrame(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);
+      } else {
+        elementsInSelection.push(element);
+        continue;
+      }
+    }
+
+    // 2. Handle the case where the label is overlapped by the selection box
+    if (
+      boxSelectionMode === "overlap" &&
+      labelAABB &&
+      doBoundsIntersect(selectionBounds, labelAABB)
+    ) {
+      elementsInSelection.push(element);
+      continue;
+    }
+
+    // 3. Handle the case where the selection is not wrapping the element, but
+    //    it does intersect the element's outline (non-AABB).
+    if (
+      boxSelectionMode === "overlap" &&
+      doBoundsIntersect(selectionBounds, elementAABB)
+    ) {
+      let hasIntersection = false;
+
+      // Preliminary check potential intersection imprecision
+      if (isLinearElement(element) || isFreeDrawElement(element)) {
+        const center = elementCenterPoint(element, elementsMap);
+        hasIntersection = element.points.some((point) => {
+          const rotatedPoint = pointRotateRads(
+            pointFrom<GlobalPoint>(element.x + point[0], element.y + point[1]),
+            center,
+            element.angle,
+          );
+
+          return pointInsideBounds(rotatedPoint, selectionBounds);
+        });
+      } else {
+        const nonRotatedElementBounds = getElementBounds(
+          element,
+          elementsMap,
+          true,
+        );
+        const center = elementCenterPoint(element, elementsMap);
+        hasIntersection = [
+          pointRotateRads(
+            pointFrom<GlobalPoint>(
+              (nonRotatedElementBounds[0] + nonRotatedElementBounds[2]) / 2,
+              nonRotatedElementBounds[1],
+            ),
+            center,
+            element.angle,
+          ),
+          pointRotateRads(
+            pointFrom<GlobalPoint>(
+              nonRotatedElementBounds[2],
+              (nonRotatedElementBounds[1] + nonRotatedElementBounds[3]) / 2,
+            ),
+            center,
+            element.angle,
+          ),
+          pointRotateRads(
+            pointFrom<GlobalPoint>(
+              (nonRotatedElementBounds[0] + nonRotatedElementBounds[2]) / 2,
+              nonRotatedElementBounds[3],
+            ),
+            center,
+            element.angle,
+          ),
+          pointRotateRads(
+            pointFrom<GlobalPoint>(
+              nonRotatedElementBounds[0],
+              (nonRotatedElementBounds[1] + nonRotatedElementBounds[3]) / 2,
+            ),
+            center,
+            element.angle,
+          ),
+        ].some((point) => {
+          return pointInsideBounds(
+            pointRotateRads(point, center, element.angle),
+            selectionBounds,
+          );
+        });
+      }
+
+      if (!hasIntersection) {
+        hasIntersection = selectionEdges.some(
+          (selectionEdge) =>
+            intersectElementWithLineSegment(
+              element,
+              elementsMap,
+              selectionEdge,
+              strokeWidth / 2,
+              true, // Stop at first hit for better performance
+            ).length > 0,
+        );
+      }
+
+      if (hasIntersection) {
+        if (framesInSelection && isFrameLikeElement(element)) {
+          framesInSelection.add(element.id);
+        }
+
+        elementsInSelection.push(element);
+        continue;
+      }
+    }
+
+    // 4. We don't need to handle when the selection is inside the element
+    //    as it is separately handled in App.
+  }
+
+  elementsInSelection = framesInSelection
+    ? excludeElementsFromFrames(elementsInSelection, framesInSelection)
     : elementsInSelection;
 
   elementsInSelection = elementsInSelection.filter((element) => {

packages/element/src/shape.ts

@@ -57,8 +57,8 @@ import { headingForPointIsHorizontal } from "./heading";
 
 import { canChangeRoundness } from "./comparisons";
 import {
+  elementCenterPoint,
   getArrowheadPoints,
-  getCenterForBounds,
   getDiamondPoints,
   getElementAbsoluteCoords,
 } from "./bounds";
@@ -583,7 +583,11 @@ const getArrowheadShapes = (
 
 export const generateLinearCollisionShape = (
   element: ExcalidrawLinearElement | ExcalidrawFreeDrawElement,
-) => {
+  elementsMap: ElementsMap,
+): {
+  op: string;
+  data: number[];
+}[] => {
   const generator = new RoughGenerator();
   const options: Options = {
     seed: element.seed,
@@ -592,20 +596,7 @@ export const generateLinearCollisionShape = (
     roughness: 0,
     preserveVertices: true,
   };
-  const center = getCenterForBounds(
+  const center = elementCenterPoint(element, elementsMap);
-    // Need a non-rotated center point
-    element.points.reduce(
-      (acc, point) => {
-        return [
-          Math.min(element.x + point[0], acc[0]),
-          Math.min(element.y + point[1], acc[1]),
-          Math.max(element.x + point[0], acc[2]),
-          Math.max(element.y + point[1], acc[3]),
-        ];
-      },
-      [Infinity, Infinity, -Infinity, -Infinity],
-    ),
-  );
 
   switch (element.type) {
     case "line":

packages/element/src/textElement.ts

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

packages/element/src/utils.ts

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

packages/element/tests/collision.test.tsx

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

packages/excalidraw/actions/actionCanvas.tsx

@@ -40,6 +40,7 @@ import {
   ZoomResetIcon,
 } from "../components/icons";
 import { setCursor } from "../cursor";
+import { constrainScrollState } from "../scene/scrollConstraints";
 
 import { t } from "../i18n";
 import { getNormalizedZoom } from "../scene";
@@ -51,6 +52,8 @@ import { register } from "./register";
 
 import type { AppState, Offsets } from "../types";
 
+const canUseZoomActions = (appState: AppState) => !appState.scrollConstraints;
+
 export const actionChangeViewBackgroundColor = register<Partial<AppState>>({
   name: "changeViewBackgroundColor",
   label: "labels.canvasBackground",
@@ -139,7 +142,7 @@ export const actionZoomIn = register({
   trackEvent: { category: "canvas" },
   perform: (_elements, appState, _, app) => {
     return {
-      appState: {
+      appState: constrainScrollState({
         ...appState,
         ...getStateForZoom(
           {
@@ -150,7 +153,7 @@ export const actionZoomIn = register({
           appState,
         ),
         userToFollow: null,
-      },
+      }),
       captureUpdate: CaptureUpdateAction.EVENTUALLY,
     };
   },
@@ -180,7 +183,7 @@ export const actionZoomOut = register({
   trackEvent: { category: "canvas" },
   perform: (_elements, appState, _, app) => {
     return {
-      appState: {
+      appState: constrainScrollState({
         ...appState,
         ...getStateForZoom(
           {
@@ -191,7 +194,7 @@ export const actionZoomOut = register({
           appState,
         ),
         userToFollow: null,
-      },
+      }),
       captureUpdate: CaptureUpdateAction.EVENTUALLY,
     };
   },
@@ -243,6 +246,7 @@ export const actionResetZoom = register({
         className="reset-zoom-button zoom-button"
         title={t("buttons.resetZoom")}
         aria-label={t("buttons.resetZoom")}
+        disabled={!canUseZoomActions(appState)}
         onClick={() => {
           updateData(null);
         }}
@@ -251,6 +255,7 @@ export const actionResetZoom = register({
       </ToolButton>
     </Tooltip>
   ),
+  predicate: (_elements, appState) => canUseZoomActions(appState),
   keyTest: (event) =>
     (event.code === CODES.ZERO || event.code === CODES.NUM_ZERO) &&
     (event[KEYS.CTRL_OR_CMD] || event.shiftKey),
@@ -274,7 +279,7 @@ const zoomValueToFitBoundsOnViewport = (
   return Math.min(adjustedZoomValue, 1);
 };
 
-export const zoomToFitBounds = ({
+export function resolveViewportForBounds({
   bounds,
   appState,
   canvasOffsets,
@@ -292,7 +297,7 @@ export const zoomToFitBounds = ({
   viewportZoomFactor?: number;
   minZoom?: number;
   maxZoom?: number;
-}) => {
+}) {
   viewportZoomFactor = clamp(viewportZoomFactor, MIN_ZOOM, MAX_ZOOM);
 
   const [x1, y1, x2, y2] = bounds;
@@ -345,12 +350,58 @@ export const zoomToFitBounds = ({
     zoom: { value: newZoomValue },
   });
 
+  return {
+    bounds,
+    scrollX: centerScroll.scrollX,
+    scrollY: centerScroll.scrollY,
+    zoom: { value: newZoomValue },
+    viewportZoomFactor,
+    viewportDimensions: {
+      width: appState.width,
+      height: appState.height,
+    },
+    effectiveViewportDimensions: {
+      width: effectiveCanvasWidth,
+      height: effectiveCanvasHeight,
+    },
+  };
+}
+
+export const zoomToFitBounds = ({
+  bounds,
+  appState,
+  canvasOffsets,
+  fitToViewport = false,
+  viewportZoomFactor = 1,
+  minZoom = -Infinity,
+  maxZoom = Infinity,
+}: {
+  bounds: SceneBounds;
+  canvasOffsets?: Offsets;
+  appState: Readonly<AppState>;
+  /** whether to fit content to viewport (beyond >100%) */
+  fitToViewport: boolean;
+  /** zoom content to cover X of the viewport, when fitToViewport=true */
+  viewportZoomFactor?: number;
+  minZoom?: number;
+  maxZoom?: number;
+}) => {
+  const resolvedViewport = resolveViewportForBounds({
+    bounds,
+    appState,
+    canvasOffsets,
+    fitToViewport,
+    viewportZoomFactor,
+    minZoom,
+    maxZoom,
+  });
+
   return {
     appState: {
       ...appState,
-      scrollX: centerScroll.scrollX,
+      scrollX: resolvedViewport.scrollX,
-      scrollY: centerScroll.scrollY,
+      scrollY: resolvedViewport.scrollY,
-      zoom: { value: newZoomValue },
+      zoom: resolvedViewport.zoom,
     },
     captureUpdate: CaptureUpdateAction.EVENTUALLY,
   };
@@ -408,6 +459,7 @@ export const actionZoomToFitSelectionInViewport = register({
       canvasOffsets: app.getEditorUIOffsets(),
     });
   },
+  predicate: (_elements, appState) => canUseZoomActions(appState),
   // NOTE shift-2 should have been assigned actionZoomToFitSelection.
   // TBD on how proceed
   keyTest: (event) =>
@@ -434,6 +486,7 @@ export const actionZoomToFitSelection = register({
       canvasOffsets: app.getEditorUIOffsets(),
     });
   },
+  predicate: (_elements, appState) => canUseZoomActions(appState),
   // NOTE this action should use shift-2 per figma, alas
   keyTest: (event) =>
     event.code === CODES.THREE &&
@@ -458,6 +511,7 @@ export const actionZoomToFit = register({
       fitToViewport: false,
       canvasOffsets: app.getEditorUIOffsets(),
     }),
+  predicate: (_elements, appState) => canUseZoomActions(appState),
   keyTest: (event) =>
     event.code === CODES.ONE &&
     event.shiftKey &&

packages/excalidraw/actions/actionDeselect.ts

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

packages/excalidraw/actions/actionFinalize.tsx

@@ -348,9 +348,7 @@ export const actionFinalize = register<FormData>({
     };
   },
   keyTest: (event, appState) =>
-    (event.key === KEYS.ESCAPE &&
+    (event.key === KEYS.ESCAPE && appState.selectedLinearElement?.isEditing) ||
-      (appState.selectedLinearElement?.isEditing ||
-        (!appState.newElement && appState.multiElement === null))) ||
     ((event.key === KEYS.ESCAPE || event.key === KEYS.ENTER) &&
       appState.multiElement !== null),
   PanelComponent: ({ appState, updateData, data }) => (

packages/excalidraw/actions/actionGroup.tsx

@@ -49,9 +49,18 @@ import { register } from "./register";
 
 import type { AppClassProperties, AppState } from "../types";
 
-const allElementsInSameGroup = (elements: readonly ExcalidrawElement[]) => {
+const allElementsInSameGroup = (
+  elements: readonly ExcalidrawElement[],
+  editingGroupId: AppState["editingGroupId"],
+) => {
   if (elements.length >= 2) {
-    const groupIds = elements[0].groupIds;
+    const editingGroupIndex = editingGroupId
+      ? elements[0].groupIds.indexOf(editingGroupId)
+      : -1;
+    const groupIds =
+      editingGroupIndex > -1
+        ? elements[0].groupIds.slice(0, editingGroupIndex)
+        : elements[0].groupIds;
     for (const groupId of groupIds) {
       if (
         elements.reduce(
@@ -78,7 +87,7 @@ const enableActionGroup = (
 
   return (
     selectedElements.length >= 2 &&
-    !allElementsInSameGroup(selectedElements) &&
+    !allElementsInSameGroup(selectedElements, appState.editingGroupId) &&
     !frameAndChildrenSelectedTogether(selectedElements)
   );
 };

packages/excalidraw/actions/actionToggleSearchMenu.ts

@@ -53,8 +53,5 @@ export const actionToggleSearchMenu = register({
     };
   },
   checked: (appState: AppState) => appState.gridModeEnabled,
-  predicate: (element, appState, props) => {
-    return props.gridModeEnabled === undefined;
-  },
   keyTest: (event) => event[KEYS.CTRL_OR_CMD] && event.key === KEYS.F,
 });

packages/excalidraw/actions/index.ts

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

packages/excalidraw/actions/manager.tsx

@@ -95,6 +95,13 @@ export class ActionManager {
           (action.name in canvasActions
             ? canvasActions[action.name as keyof typeof canvasActions]
             : true) &&
+          (!action.predicate ||
+            action.predicate(
+              this.getElementsIncludingDeleted(),
+              this.getAppState(),
+              this.app.props,
+              this.app,
+            )) &&
           action.keyTest &&
           action.keyTest(
             event,

packages/excalidraw/actions/types.ts

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

packages/excalidraw/appState.ts

@@ -122,12 +122,14 @@ export const getDefaultAppState = (): Omit<
     objectsSnapModeEnabled: false,
     userToFollow: null,
     followedBy: new Set(),
+    scrollConstraints: null,
     isCropping: false,
     croppingElementId: null,
     searchMatches: null,
     lockedMultiSelections: {},
     activeLockedId: null,
     bindMode: "orbit",
+    boxSelectionMode: "contain",
   };
 };
 
@@ -193,6 +195,7 @@ const APP_STATE_STORAGE_CONF = (<
   gridModeEnabled: { browser: true, export: true, server: true },
   height: { browser: false, export: false, server: false },
   isBindingEnabled: { browser: true, export: false, server: false },
+  boxSelectionMode: { browser: true, export: false, server: false },
   bindingPreference: { browser: true, export: false, server: false },
   isMidpointSnappingEnabled: { browser: true, export: false, server: false },
   defaultSidebarDockedPreference: {
@@ -248,6 +251,7 @@ const APP_STATE_STORAGE_CONF = (<
   objectsSnapModeEnabled: { browser: true, export: false, server: false },
   userToFollow: { browser: false, export: false, server: false },
   followedBy: { browser: false, export: false, server: false },
+  scrollConstraints: { browser: true, export: false, server: false },
   isCropping: { browser: false, export: false, server: false },
   croppingElementId: { browser: false, export: false, server: false },
   searchMatches: { browser: false, export: false, server: false },

packages/excalidraw/components/App.tsx

@@ -27,6 +27,7 @@ import {
   KEYS,
   APP_NAME,
   CURSOR_TYPE,
+  DEFAULT_TRANSFORM_HANDLE_SPACING,
   DEFAULT_MAX_IMAGE_WIDTH_OR_HEIGHT,
   DEFAULT_VERTICAL_ALIGN,
   DRAGGING_THRESHOLD,
@@ -325,7 +326,10 @@ import {
   actionToggleCropEditor,
 } from "../actions";
 import { actionWrapTextInContainer } from "../actions/actionBoundText";
-import { actionToggleHandTool, zoomToFit } from "../actions/actionCanvas";
+import {
+  actionToggleHandTool,
+  resolveViewportForBounds,
+} from "../actions/actionCanvas";
 import { actionPaste } from "../actions/actionClipboard";
 import { actionCopyElementLink } from "../actions/actionElementLink";
 import { actionUnlockAllElements } from "../actions/actionElementLock";
@@ -369,7 +373,7 @@ import {
   hasBackground,
   isSomeElementSelected,
 } from "../scene";
-import { getStateForZoom } from "../scene/zoom";
+import { getConstrainedZoomAnchor, getStateForZoom } from "../scene/zoom";
 import {
   dataURLToString,
   generateIdFromFile,
@@ -425,6 +429,12 @@ import { isMaybeMermaidDefinition } from "../mermaid";
 
 import { LassoTrail } from "../lasso";
 
+import {
+  constrainScrollState,
+  calculateConstrainedScrollCenter,
+  areCanvasTranslatesClose,
+  getScrollConstraintsForBounds,
+} from "../scene/scrollConstraints";
 import { EraserTrail } from "../eraser";
 
 import { getShortcutKey } from "../shortcut";
@@ -487,6 +497,9 @@ import type {
   CollaboratorPointer,
   ToolType,
   OnUserFollowedPayload,
+  ScrollConstraints,
+  AnimateTranslateCanvasValues,
+  ScrollToContentOptions,
   UnsubscribeCallback,
   EmbedsValidationStatus,
   ElementsPendingErasure,
@@ -539,6 +552,7 @@ const ExcalidrawAppStateContext = React.createContext<AppState>({
   height: 0,
   offsetLeft: 0,
   offsetTop: 0,
+  scrollConstraints: null,
 });
 ExcalidrawAppStateContext.displayName = "ExcalidrawAppStateContext";
 
@@ -593,6 +607,20 @@ let isDraggingScrollBar: boolean = false;
 let currentScrollBars: ScrollBars = { horizontal: null, vertical: null };
 let touchTimeout = 0;
 let invalidateContextMenu = false;
+let scrollConstraintsAnimationTimeout: ReturnType<typeof setTimeout> | null =
+  null;
+
+const areScrollConstraintsEqual = (
+  left: ScrollConstraints | null | undefined,
+  right: ScrollConstraints | null | undefined,
+) => {
+  return left === right || (!!left && !!right && isShallowEqual(left, right));
+};
+
+const SET_SCROLL_CONSTRAINTS_CONTROLLED_WARNING =
+  "Excalidraw: `setScrollConstraints()` is ignored when the `scrollConstraints` prop is controlled.";
+const SCROLL_TO_CONTENT_SCROLL_LOCK_CONTROLLED_WARNING =
+  "Excalidraw: `scrollToContent()` with `scrollLock` is ignored when the `scrollConstraints` prop is controlled.";
 
 /**
  * Map of youtube embed video states
@@ -780,6 +808,8 @@ class App extends React.Component<AppProps, AppState> {
       onUserFollow: (cb) => this.onUserFollowEmitter.on(cb),
       onStateChange: this.onStateChange,
       onEvent: this.onEvent,
+      app: this,
+      setScrollConstraints: this.setScrollConstraints,
     };
     return api;
   }
@@ -794,6 +824,7 @@ class App extends React.Component<AppProps, AppState> {
       objectsSnapModeEnabled = false,
       theme = defaultAppState.theme,
       name = `${t("labels.untitled")}-${getDateTime()}`,
+      scrollConstraints,
     } = props;
 
     this.state = {
@@ -809,6 +840,7 @@ class App extends React.Component<AppProps, AppState> {
       name,
       width: window.innerWidth,
       height: window.innerHeight,
+      scrollConstraints: scrollConstraints ?? null,
     };
 
     this.refreshEditorInterface();
@@ -2524,6 +2556,7 @@ class App extends React.Component<AppProps, AppState> {
     const magicFrameChildren = getElementsOverlappingFrame(
       this.scene.getNonDeletedElements(),
       magicFrame,
+      this.scene.getNonDeletedElementsMap(),
     ).filter((el) => !isMagicFrameElement(el));
 
     if (!magicFrameChildren.length) {
@@ -2943,7 +2976,13 @@ class App extends React.Component<AppProps, AppState> {
       toast: this.state.toast,
     };
 
-    if (initialData?.scrollToContent) {
+    if (this.props.scrollConstraints) {
+      restoredAppState = {
+        ...restoredAppState,
+        scrollConstraints: this.props.scrollConstraints,
+        ...calculateConstrainedScrollCenter(this.state, restoredAppState),
+      };
+    } else if (initialData?.scrollToContent) {
       restoredAppState = {
         ...restoredAppState,
         ...calculateScrollCenter(restoredElements, {
@@ -2952,10 +2991,18 @@ class App extends React.Component<AppProps, AppState> {
           height: this.state.height,
           offsetTop: this.state.offsetTop,
           offsetLeft: this.state.offsetLeft,
+          scrollConstraints: this.state.scrollConstraints,
         }),
       };
     }
 
+    if (initialData?.scrollX != null) {
+      restoredAppState.scrollX = initialData.scrollX;
+    }
+    if (initialData?.scrollY != null) {
+      restoredAppState.scrollY = initialData.scrollY;
+    }
+
     this.resetStore();
     this.resetHistory();
     this.syncActionResult({
@@ -3206,7 +3253,11 @@ class App extends React.Component<AppProps, AppState> {
       .forEach((element) => ShapeCache.delete(element));
     this.refreshEditorInterface();
     this.updateDOMRect();
-    this.setState({});
+    if (this.state.scrollConstraints) {
+      this.setState((state) => constrainScrollState(state));
+    } else {
+      this.setState({});
+    }
   });
 
   /** generally invoked only if fullscreen was invoked programmatically */
@@ -3456,6 +3507,15 @@ class App extends React.Component<AppProps, AppState> {
       this.setState({ viewModeEnabled: !!this.props.viewModeEnabled });
     }
 
+    if (
+      !areScrollConstraintsEqual(
+        prevProps.scrollConstraints,
+        this.props.scrollConstraints,
+      )
+    ) {
+      this.syncScrollConstraints(this.props.scrollConstraints ?? null);
+    }
+
     if (prevState.viewModeEnabled !== this.state.viewModeEnabled) {
       this.addEventListeners();
       this.deselectElements();
@@ -3516,6 +3576,33 @@ class App extends React.Component<AppProps, AppState> {
       this.props.onChange?.(elements, this.state, this.files);
       this.onChangeEmitter.trigger(elements, this.state, this.files);
     }
+
+    if (this.state.scrollConstraints?.animateOnNextUpdate) {
+      const newState = constrainScrollState(this.state, "rigid");
+      const fromValues = {
+        scrollX: this.state.scrollX,
+        scrollY: this.state.scrollY,
+        zoom: this.state.zoom.value,
+      };
+      const toValues = {
+        scrollX: newState.scrollX,
+        scrollY: newState.scrollY,
+        zoom: newState.zoom.value,
+      };
+
+      if (areCanvasTranslatesClose(fromValues, toValues)) {
+        return;
+      }
+
+      if (scrollConstraintsAnimationTimeout) {
+        clearTimeout(scrollConstraintsAnimationTimeout);
+      }
+
+      scrollConstraintsAnimationTimeout = setTimeout(() => {
+        this.cancelInProgressAnimation?.();
+        this.animateToConstrainedArea(fromValues, toValues);
+      }, 200);
+    }
   }
 
   private renderInteractiveSceneCallback = ({
@@ -4283,8 +4370,8 @@ class App extends React.Component<AppProps, AppState> {
      */
     value: number,
   ) => {
-    this.setState({
+    this.setState(
-      ...getStateForZoom(
+      getStateForZoom(
         {
           viewportX: this.state.width / 2 + this.state.offsetLeft,
           viewportY: this.state.height / 2 + this.state.offsetTop,
@@ -4292,11 +4379,13 @@ class App extends React.Component<AppProps, AppState> {
         },
         this.state,
       ),
-    });
+    );
   };
 
   private cancelInProgressAnimation: (() => void) | null = null;
 
+  private scrollToContentRequestId = 0;
+
   scrollToContent = (
     /**
      * target to scroll to
@@ -4308,30 +4397,13 @@ class App extends React.Component<AppProps, AppState> {
       | string
       | ExcalidrawElement
       | readonly ExcalidrawElement[] = this.scene.getNonDeletedElements(),
-    opts?: (
+    opts?: ScrollToContentOptions,
-      | {
-          fitToContent?: boolean;
-          fitToViewport?: never;
-          viewportZoomFactor?: number;
-          animate?: boolean;
-          duration?: number;
-        }
-      | {
-          fitToContent?: never;
-          fitToViewport?: boolean;
-          /** when fitToViewport=true, how much screen should the content cover,
-           * between 0.1 (10%) and 1 (100%)
-           */
-          viewportZoomFactor?: number;
-          animate?: boolean;
-          duration?: number;
-        }
-    ) & {
-      minZoom?: number;
-      maxZoom?: number;
-      canvasOffsets?: Offsets;
-    },
   ) => {
+    if (opts?.scrollLock && this.props.scrollConstraints !== undefined) {
+      console.warn(SCROLL_TO_CONTENT_SCROLL_LOCK_CONTROLLED_WARNING);
+      opts = { ...opts, scrollLock: undefined };
+    }
+
     if (typeof target === "string") {
       let id: string | null;
       if (isElementLink(target)) {
@@ -4343,10 +4415,29 @@ class App extends React.Component<AppProps, AppState> {
         const elements = this.scene.getElementsFromId(id);
 
         if (elements?.length) {
-          this.scrollToContent(elements, {
+          if (opts?.fitToViewport) {
-            fitToContent: opts?.fitToContent ?? true,
+            this.scrollToContent(elements, {
-            animate: opts?.animate ?? true,
+              fitToViewport: true,
-          });
+              viewportZoomFactor: opts.viewportZoomFactor,
+              animate: opts.animate ?? true,
+              duration: opts.duration,
+              scrollLock: opts.scrollLock,
+              minZoom: opts.minZoom,
+              maxZoom: opts.maxZoom,
+              canvasOffsets: opts.canvasOffsets,
+            });
+          } else {
+            this.scrollToContent(elements, {
+              fitToContent: opts?.fitToContent ?? true,
+              viewportZoomFactor: opts?.viewportZoomFactor,
+              animate: opts?.animate ?? true,
+              duration: opts?.duration,
+              scrollLock: opts?.scrollLock,
+              minZoom: opts?.minZoom,
+              maxZoom: opts?.maxZoom,
+              canvasOffsets: opts?.canvasOffsets,
+            });
+          }
         } else if (isElementLink(target)) {
           this.setState({
             toast: {
@@ -4361,27 +4452,45 @@ class App extends React.Component<AppProps, AppState> {
     }
 
     this.cancelInProgressAnimation?.();
+    this.scrollToContentRequestId += 1;
+    this.debounceConstrainScrollState.cancel();
+
+    if (scrollConstraintsAnimationTimeout) {
+      clearTimeout(scrollConstraintsAnimationTimeout);
+      scrollConstraintsAnimationTimeout = null;
+    }
+
+    if (opts?.scrollLock != null && this.state.scrollConstraints) {
+      // Clear the previous lock before starting the next locked transition so
+      // stale constraint enforcement cannot snap us back mid-flight.
+      this.setState({ scrollConstraints: null });
+    }
 
     // convert provided target into ExcalidrawElement[] if necessary
     const targetElements = Array.isArray(target) ? target : [target];
 
+    if (!targetElements.length) {
+      return;
+    }
+
     let zoom = this.state.zoom;
     let scrollX = this.state.scrollX;
     let scrollY = this.state.scrollY;
+    const targetBounds = getCommonBounds(targetElements);
 
     if (opts?.fitToContent || opts?.fitToViewport) {
-      const { appState } = zoomToFit({
+      const resolvedViewport = resolveViewportForBounds({
+        bounds: targetBounds,
         canvasOffsets: opts.canvasOffsets,
-        targetElements,
         appState: this.state,
         fitToViewport: !!opts?.fitToViewport,
         viewportZoomFactor: opts?.viewportZoomFactor,
         minZoom: opts?.minZoom,
         maxZoom: opts?.maxZoom,
       });
-      zoom = appState.zoom;
+      zoom = resolvedViewport.zoom;
-      scrollX = appState.scrollX;
+      scrollX = resolvedViewport.scrollX;
-      scrollY = appState.scrollY;
+      scrollY = resolvedViewport.scrollY;
     } else {
       // compute only the viewport location, without any zoom adjustment
       const scroll = calculateScrollCenter(targetElements, this.state);
@@ -4389,51 +4498,72 @@ class App extends React.Component<AppProps, AppState> {
       scrollY = scroll.scrollY;
     }
 
+    const scrollConstraints = opts?.scrollLock
+      ? getScrollConstraintsForBounds({
+          bounds: targetBounds,
+          zoom,
+          viewportDimensions: {
+            width: this.state.width,
+            height: this.state.height,
+          },
+          scrollLock: opts.scrollLock,
+        })
+      : null;
+    const requestId = this.scrollToContentRequestId;
+
+    const installScrollConstraints = () => {
+      if (!scrollConstraints || requestId !== this.scrollToContentRequestId) {
+        return;
+      }
+
+      this.setState({
+        scrollConstraints,
+      });
+    };
+
     // when animating, we use RequestAnimationFrame to prevent the animation
     // from slowing down other processes
     if (opts?.animate) {
-      const origScrollX = this.state.scrollX;
+      const fromValues = {
-      const origScrollY = this.state.scrollY;
+        scrollX: this.state.scrollX,
-      const origZoom = this.state.zoom.value;
+        scrollY: this.state.scrollY,
+        zoom: this.state.zoom.value,
+      };
 
-      const cancel = easeToValuesRAF({
+      const toValues = { scrollX, scrollY, zoom: zoom.value };
-        fromValues: {
+
-          scrollX: origScrollX,
+      this.animateTranslateCanvas({
-          scrollY: origScrollY,
+        fromValues,
-          zoom: origZoom,
+        toValues,
-        },
+        duration: opts?.duration ?? 500,
-        toValues: { scrollX, scrollY, zoom: zoom.value },
-        interpolateValue: (from, to, progress, key) => {
-          // for zoom, use different easing
-          if (key === "zoom") {
-            return from * Math.pow(to / from, easeOut(progress));
-          }
-          // handle using default
-          return undefined;
-        },
-        onStep: ({ scrollX, scrollY, zoom }) => {
-          this.setState({
-            scrollX,
-            scrollY,
-            zoom: { value: zoom },
-          });
-        },
         onStart: () => {
           this.setState({ shouldCacheIgnoreZoom: true });
         },
         onEnd: () => {
-          this.setState({ shouldCacheIgnoreZoom: false });
+          if (requestId !== this.scrollToContentRequestId) {
+            return;
+          }
+
+          this.setState(
+            { shouldCacheIgnoreZoom: false },
+            installScrollConstraints,
+          );
         },
         onCancel: () => {
+          if (requestId !== this.scrollToContentRequestId) {
+            return;
+          }
+
           this.setState({ shouldCacheIgnoreZoom: false });
         },
-        duration: opts?.duration ?? 500,
       });
-
+    } else if (scrollConstraints) {
-      this.cancelInProgressAnimation = () => {
+      this.setState({
-        cancel();
+        scrollX,
-        this.cancelInProgressAnimation = null;
+        scrollY,
-      };
+        zoom,
+        scrollConstraints,
+      });
     } else {
       this.setState({ scrollX, scrollY, zoom });
     }
@@ -4447,11 +4577,165 @@ class App extends React.Component<AppProps, AppState> {
 
   /** use when changing scrollX/scrollY/zoom based on user interaction */
   private translateCanvas: React.Component<any, AppState>["setState"] = (
-    state,
+    stateUpdate,
   ) => {
     this.cancelInProgressAnimation?.();
     this.maybeUnfollowRemoteUser();
-    this.setState(state);
+
+    if (scrollConstraintsAnimationTimeout) {
+      clearTimeout(scrollConstraintsAnimationTimeout);
+    }
+
+    const partialNewState =
+      typeof stateUpdate === "function"
+        ? (
+            stateUpdate as (
+              prevState: Readonly<AppState>,
+              props: Readonly<AppProps>,
+            ) => AppState
+          )(this.state, this.props)
+        : stateUpdate;
+
+    const newState: AppState = {
+      ...this.state,
+      ...partialNewState,
+      ...(this.state.scrollConstraints && {
+        // manually reset if setState in onCancel wasn't committed yet
+        shouldCacheIgnoreZoom: false,
+      }),
+    };
+
+    // RULE: cannot go below the minimum zoom level if zoom lock is enabled
+    const constrainedState =
+      newState.scrollConstraints && newState.scrollConstraints.lockZoom
+        ? constrainScrollState(newState, "elastic")
+        : newState;
+    if (constrainedState.zoom.value > newState.zoom.value) {
+      newState.zoom = constrainedState.zoom;
+      newState.scrollX = constrainedState.scrollX;
+      newState.scrollY = constrainedState.scrollY;
+
+      this.debounceConstrainScrollState(newState);
+      return;
+    }
+
+    this.setState(newState);
+    if (this.state.scrollConstraints) {
+      if (newState.zoom.value < this.state.zoom.value) {
+        // zoom-out: debounce to allow centering on user's cursor position before constraining
+        this.debounceConstrainScrollState(newState);
+      } else {
+        // zoom-in or pan: valid range only expands on zoom-in, constrain immediately
+        this.setState(constrainScrollState(newState));
+      }
+    }
+  };
+
+  private debounceConstrainScrollState = debounce((state: AppState) => {
+    const newState = constrainScrollState(state, "rigid");
+
+    const fromValues = {
+      scrollX: this.state.scrollX,
+      scrollY: this.state.scrollY,
+      zoom: this.state.zoom.value,
+    };
+    const toValues = {
+      scrollX: newState.scrollX,
+      scrollY: newState.scrollY,
+      zoom: newState.zoom.value,
+    };
+
+    if (areCanvasTranslatesClose(fromValues, toValues)) {
+      return;
+    }
+
+    this.cancelInProgressAnimation?.();
+    this.animateToConstrainedArea(fromValues, toValues);
+  }, 200);
+
+  private animateToConstrainedArea = (
+    fromValues: AnimateTranslateCanvasValues,
+    toValues: AnimateTranslateCanvasValues,
+  ) => {
+    const cleanUp = () => {
+      this.setState((state) => ({
+        shouldCacheIgnoreZoom: false,
+        scrollConstraints: {
+          ...state.scrollConstraints!,
+          animateOnNextUpdate: false,
+        },
+      }));
+    };
+
+    this.animateTranslateCanvas({
+      fromValues,
+      toValues,
+      duration: 200,
+      onStart: () => {
+        this.setState((state) => {
+          return {
+            shouldCacheIgnoreZoom: true,
+            scrollConstraints: {
+              ...state.scrollConstraints!,
+              animateOnNextUpdate: false,
+            },
+          };
+        });
+      },
+      onEnd: cleanUp,
+      onCancel: cleanUp,
+    });
+  };
+
+  private animateTranslateCanvas = ({
+    fromValues,
+    toValues,
+    duration,
+    onStart,
+    onEnd,
+    onCancel,
+  }: {
+    fromValues: AnimateTranslateCanvasValues;
+    toValues: AnimateTranslateCanvasValues;
+    duration: number;
+    onStart: () => void;
+    onEnd: () => void;
+    onCancel: () => void;
+  }) => {
+    const cancel = easeToValuesRAF({
+      fromValues,
+      toValues,
+      interpolateValue: (from, to, progress, key) => {
+        // for zoom, use different easing
+        if (key === "zoom") {
+          return from * Math.pow(to / from, easeOut(progress));
+        }
+        // handle using default
+        return undefined;
+      },
+      onStep: ({ scrollX, scrollY, zoom }) => {
+        this.setState({
+          scrollX,
+          scrollY,
+          zoom: { value: zoom },
+        });
+      },
+      onStart,
+      onEnd: () => {
+        this.cancelInProgressAnimation = null;
+        onEnd();
+      },
+      onCancel: () => {
+        this.cancelInProgressAnimation = null;
+        onCancel();
+      },
+      duration,
+    });
+
+    this.cancelInProgressAnimation = () => {
+      cancel();
+      this.cancelInProgressAnimation = null;
+    };
   };
 
   setToast = (toast: AppState["toast"]) => {
@@ -5632,16 +5916,22 @@ class App extends React.Component<AppProps, AppState> {
 
     const initialScale = gesture.initialScale;
     if (initialScale) {
-      this.setState((state) => ({
+      this.setState((state) =>
-        ...getStateForZoom(
+        constrainScrollState(
           {
-            viewportX: this.lastViewportPosition.x,
+            ...state,
-            viewportY: this.lastViewportPosition.y,
+            ...getStateForZoom(
-            nextZoom: getNormalizedZoom(initialScale * event.scale),
+              {
+                viewportX: this.lastViewportPosition.x,
+                viewportY: this.lastViewportPosition.y,
+                nextZoom: getNormalizedZoom(initialScale * event.scale),
+              },
+              state,
+            ),
           },
-          state,
+          "loose",
         ),
-      }));
+      );
     }
   });
 
@@ -5725,13 +6015,13 @@ class App extends React.Component<AppProps, AppState> {
         const isDeleted = !nextOriginalText.trim();
         updateElement(nextOriginalText, isDeleted);
 
-        // select the created text element only if submitting via keyboard
+        // keyboard-submit keeps focus on the edited object. For bound text, keep
-        // (when submitting via click it should act as signal to deselect)
+        // the container selected even if the text becomes empty and is deleted.
-        if (!isDeleted && viaKeyboard) {
+        const elementIdToSelect = viaKeyboard
-          const elementIdToSelect = element.containerId
+          ? element.containerId || (!isDeleted ? element.id : null)
-            ? element.containerId
+          : null;
-            : element.id;
 
+        if (elementIdToSelect) {
           // needed to ensure state is updated before "finalize" action
           // that's invoked on keyboard-submit as well
           // TODO either move this into finalize as well, or handle all state
@@ -6995,27 +7285,23 @@ class App extends React.Component<AppProps, AppState> {
           },
           { informMutation: false, isDragging: false },
         );
+        const newLastIdx = multiElement.points.length - 1;
         this.setState({
           selectedLinearElement: {
             ...selectedLinearElement,
-            selectedPointsIndices:
+            selectedPointsIndices: selectedLinearElement.selectedPointsIndices
-              selectedLinearElement.selectedPointsIndices?.includes(
+              ? [
-                multiElement.points.length,
+                  ...new Set(
-              )
+                    selectedLinearElement.selectedPointsIndices.map((idx) =>
-                ? [
+                      Math.min(idx, newLastIdx),
-                    ...selectedLinearElement.selectedPointsIndices.filter(
-                      (idx) =>
-                        idx !== multiElement.points.length &&
-                        idx !== multiElement.points.length - 1,
                     ),
-                    multiElement.points.length - 1,
+                  ),
-                  ]
+                ]
-                : selectedLinearElement.selectedPointsIndices,
+              : selectedLinearElement.selectedPointsIndices,
-            lastCommittedPoint:
+            lastCommittedPoint: multiElement.points[newLastIdx],
-              multiElement.points[multiElement.points.length - 1],
             initialState: {
               ...selectedLinearElement.initialState,
-              lastClickedPoint: multiElement.points.length - 1,
+              lastClickedPoint: newLastIdx,
             },
           },
         });
@@ -7243,6 +7529,14 @@ class App extends React.Component<AppProps, AppState> {
           this.interactiveCanvas,
           isTextElement(hitElement) ? CURSOR_TYPE.TEXT : CURSOR_TYPE.CROSSHAIR,
         );
+      } else if (
+        !event[KEYS.CTRL_OR_CMD] &&
+        this.isHittingCommonBoundingBoxOfSelectedElements(
+          scenePointer,
+          selectedElements,
+        )
+      ) {
+        setCursor(this.interactiveCanvas, CURSOR_TYPE.MOVE);
       } else if (this.state.viewModeEnabled) {
         setCursor(this.interactiveCanvas, CURSOR_TYPE.GRAB);
       } else if (this.state.openDialog?.name === "elementLinkSelector") {
@@ -7734,17 +8028,24 @@ class App extends React.Component<AppProps, AppState> {
       const hitSelectedElement =
         pointerDownState.hit.element &&
         this.isASelectedElement(pointerDownState.hit.element);
+      const shouldForceLassoReselect =
+        event.altKey &&
+        event[KEYS.CTRL_OR_CMD] &&
+        !pointerDownState.resize.handleType;
+      const shouldStartLassoSelection =
+        shouldForceLassoReselect ||
+        (!pointerDownState.hit.hasHitCommonBoundingBoxOfSelectedElements &&
+          !pointerDownState.resize.handleType &&
+          !hitSelectedElement);
 
-      if (
+      if (shouldStartLassoSelection) {
-        !pointerDownState.hit.hasHitCommonBoundingBoxOfSelectedElements &&
+        if (!this.lassoTrail.hasCurrentTrail) {
-        !pointerDownState.resize.handleType &&
+          this.lassoTrail.startPath(
-        !hitSelectedElement
+            pointerDownState.origin.x,
-      ) {
+            pointerDownState.origin.y,
-        this.lassoTrail.startPath(
+            event.shiftKey,
-          pointerDownState.origin.x,
+          );
-          pointerDownState.origin.y,
+        }
-          event.shiftKey,
-        );
 
         // block dragging after lasso selection on PCs until the next pointer down
         // (on mobile or tablet, we want to allow user to drag immediately)
@@ -8733,12 +9034,14 @@ class App extends React.Component<AppProps, AppState> {
       DEFAULT_COLLISION_THRESHOLD / this.state.zoom.value,
       1,
     );
+    const boundsPadding =
+      (DEFAULT_TRANSFORM_HANDLE_SPACING * 2) / this.state.zoom.value;
     const [x1, y1, x2, y2] = getCommonBounds(selectedElements);
     return (
-      point.x > x1 - threshold &&
+      point.x > x1 - boundsPadding - threshold &&
-      point.x < x2 + threshold &&
+      point.x < x2 + boundsPadding + threshold &&
-      point.y > y1 - threshold &&
+      point.y > y1 - boundsPadding - threshold &&
-      point.y < y2 + threshold
+      point.y < y2 + boundsPadding + threshold
     );
   }
 
@@ -10271,6 +10574,7 @@ class App extends React.Component<AppProps, AppState> {
                 this.state.selectionElement,
                 this.scene.getNonDeletedElementsMap(),
                 false,
+                this.state.boxSelectionMode,
               )
             : [];
 
@@ -12604,17 +12908,21 @@ class App extends React.Component<AppProps, AppState> {
           // reduced amplification for small deltas (small movements on a trackpad)
           Math.min(1, absDelta / 20);
 
-        this.translateCanvas((state) => ({
+        this.translateCanvas((state) => {
-          ...getStateForZoom(
+          const nextZoom = getNormalizedZoom(newZoom);
+          const anchor = getConstrainedZoomAnchor(
             {
               viewportX: this.lastViewportPosition.x,
               viewportY: this.lastViewportPosition.y,
-              nextZoom: getNormalizedZoom(newZoom),
+              nextZoom,
             },
             state,
-          ),
+          );
-          shouldCacheIgnoreZoom: true,
+          return {
-        }));
+            ...getStateForZoom({ ...anchor, nextZoom }, state),
+            shouldCacheIgnoreZoom: true,
+          };
+        });
         this.resetShouldCacheIgnoreZoomDebounced();
         return;
       }
@@ -12772,6 +13080,71 @@ class App extends React.Component<AppProps, AppState> {
     await setLanguage(currentLang);
     this.setAppState({});
   }
+
+  /**
+   * Sets the scroll constraints of the application state.
+   *
+   * @param scrollConstraints - The new scroll constraints.
+   */
+  public setScrollConstraints = (
+    scrollConstraints: ScrollConstraints | null,
+  ) => {
+    if (this.props.scrollConstraints !== undefined) {
+      console.warn(SET_SCROLL_CONSTRAINTS_CONTROLLED_WARNING);
+      return;
+    }
+
+    this.syncScrollConstraints(scrollConstraints);
+  };
+
+  private syncScrollConstraints = (
+    scrollConstraints: ScrollConstraints | null,
+  ) => {
+    this.debounceConstrainScrollState.cancel();
+
+    if (scrollConstraintsAnimationTimeout) {
+      clearTimeout(scrollConstraintsAnimationTimeout);
+      scrollConstraintsAnimationTimeout = null;
+    }
+
+    this.cancelInProgressAnimation?.();
+
+    if (scrollConstraints) {
+      this.setState(
+        {
+          scrollConstraints,
+          shouldCacheIgnoreZoom: false,
+        },
+        () => {
+          const newState = constrainScrollState(
+            {
+              ...this.state,
+              scrollConstraints,
+            },
+            "rigid",
+          );
+
+          this.animateToConstrainedArea(
+            {
+              scrollX: this.state.scrollX,
+              scrollY: this.state.scrollY,
+              zoom: this.state.zoom.value,
+            },
+            {
+              scrollX: newState.scrollX,
+              scrollY: newState.scrollY,
+              zoom: newState.zoom.value,
+            },
+          );
+        },
+      );
+    } else {
+      this.setState({
+        scrollConstraints: null,
+        shouldCacheIgnoreZoom: false,
+      });
+    }
+  };
 }
 
 // -----------------------------------------------------------------------------

packages/excalidraw/components/FontPicker/FontPickerList.tsx

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

packages/excalidraw/components/RadioGroup.scss

@@ -26,13 +26,16 @@
     background: var(--RadioGroup-background);
     border: 1px solid var(--RadioGroup-border);
 
+    gap: 2px;
+
     &__choice {
       position: relative;
       display: flex;
       align-items: center;
       justify-content: center;
-      width: 32px;
+      min-width: 20px;
       height: 24px;
+      padding: 0 0.375rem;
 
       color: var(--RadioGroup-choice-color-off);
       background: var(--RadioGroup-choice-background-off);

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

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

packages/excalidraw/components/dropdownMenu/DropdownMenu.scss

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

packages/excalidraw/components/dropdownMenu/DropdownMenuItemContentRadio.tsx

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

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

@@ -39,7 +39,13 @@ import DropdownMenuItemCheckbox from "../dropdownMenu/DropdownMenuItemCheckbox";
 import DropdownMenuItemContentRadio from "../dropdownMenu/DropdownMenuItemContentRadio";
 import DropdownMenuItemLink from "../dropdownMenu/DropdownMenuItemLink";
 import DropdownMenuSub from "../dropdownMenu/DropdownMenuSub";
-import { GithubIcon, DiscordIcon, XBrandIcon, settingsIcon } from "../icons";
+import {
+  GithubIcon,
+  DiscordIcon,
+  XBrandIcon,
+  settingsIcon,
+  emptyIcon,
+} from "../icons";
 import {
   boltIcon,
   DeviceDesktopIcon,
@@ -427,6 +433,39 @@ const PreferencesToggleToolLockItem = () => {
   );
 };
 
+const PreferencesBoxSelectionModeItem = () => {
+  const { t } = useI18n();
+  const appState = useUIAppState();
+  const setAppState = useExcalidrawSetAppState();
+
+  return (
+    <DropdownMenuItemContentRadio<"contain" | "overlap">
+      name="boxSelectionMode"
+      icon={emptyIcon}
+      value={appState.boxSelectionMode}
+      onChange={(value) => {
+        setAppState({
+          boxSelectionMode: value,
+        });
+      }}
+      choices={[
+        {
+          value: "contain",
+          label: t("labels.boxSelectionContain"),
+          ariaLabel: t("labels.boxSelectionContain"),
+        },
+        {
+          value: "overlap",
+          label: t("labels.boxSelectionOverlap"),
+          ariaLabel: t("labels.boxSelectionOverlap"),
+        },
+      ]}
+    >
+      {t("labels.boxSelectionMode")}
+    </DropdownMenuItemContentRadio>
+  );
+};
+
 const PreferencesToggleSnapModeItem = () => {
   const { t } = useI18n();
   const actionManager = useExcalidrawActionManager();
@@ -568,6 +607,7 @@ export const Preferences = ({
       <DropdownMenuSub.Content className="excalidraw-main-menu-preferences-submenu">
         {children || (
           <>
+            <PreferencesBoxSelectionModeItem />
             <PreferencesToggleToolLockItem />
             <PreferencesToggleSnapModeItem />
             <PreferencesToggleGridModeItem />
@@ -585,6 +625,7 @@ export const Preferences = ({
 };
 
 Preferences.ToggleToolLock = PreferencesToggleToolLockItem;
+Preferences.BoxSelectionMode = PreferencesBoxSelectionModeItem;
 Preferences.ToggleSnapMode = PreferencesToggleSnapModeItem;
 Preferences.ToggleArrowBinding = PreferencesToggleArrowBindingItem;
 Preferences.ToggleMidpointSnapping = PreferencesToggleMidpointSnappingItem;

packages/excalidraw/data/index.ts

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

packages/excalidraw/data/restore.ts

@@ -251,7 +251,9 @@ const repairBinding = <T extends ExcalidrawArrowElement>(
       };
     }
 
-    console.error(`could not repair binding for element`);
+    console.error(
+      `Could not repair binding for element "${boundElement?.id}" out of (${elementsMap?.size}) elements`,
+    );
   } catch (error) {
     console.error("Error repairing binding:", error);
   }
@@ -934,6 +936,12 @@ export const restoreAppState = (
         : defaultValue;
   }
 
+  const boxSelectionMode =
+    appState.boxSelectionMode ?? localAppState?.boxSelectionMode;
+  if (boxSelectionMode !== undefined) {
+    nextAppState.boxSelectionMode = boxSelectionMode;
+  }
+
   return {
     ...nextAppState,
     cursorButton: localAppState?.cursorButton || "up",

packages/excalidraw/index.tsx

@@ -98,6 +98,7 @@ const ExcalidrawBase = (props: ExcalidrawProps) => {
     aiEnabled,
     showDeprecatedFonts,
     renderScrollbars,
+    scrollConstraints,
   } = props;
 
   const canvasActions = props.UIOptions?.canvasActions;
@@ -208,6 +209,7 @@ const ExcalidrawBase = (props: ExcalidrawProps) => {
           aiEnabled={aiEnabled !== false}
           showDeprecatedFonts={showDeprecatedFonts}
           renderScrollbars={renderScrollbars}
+          scrollConstraints={scrollConstraints}
         >
           {children}
         </App>
@@ -382,6 +384,8 @@ export { DiagramToCodePlugin } from "./components/DiagramToCodePlugin/DiagramToC
 export { getDataURL } from "./data/blob";
 export { isElementLink } from "@excalidraw/element";
 
+export { Fonts } from "./fonts/Fonts";
+
 export { setCustomTextMetricsProvider } from "@excalidraw/element";
 
 export { CommandPalette } from "./components/CommandPalette/CommandPalette";

packages/excalidraw/locales/en.json

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

packages/excalidraw/package.json

@@ -88,7 +88,7 @@
     "@excalidraw/element": "0.18.0",
     "@excalidraw/laser-pointer": "1.3.1",
     "@excalidraw/math": "0.18.0",
-    "@excalidraw/mermaid-to-excalidraw": "2.1.1",
+    "@excalidraw/mermaid-to-excalidraw": "2.2.2",
     "@excalidraw/random-username": "1.1.0",
     "browser-fs-access": "0.38.0",
     "canvas-roundrect-polyfill": "0.0.1",

packages/excalidraw/renderer/interactiveScene.ts

@@ -1156,6 +1156,7 @@ const renderLinearPointHandles = (
           points[idx],
           idx,
           appState.zoom,
+          elementsMap,
         )
       ) {
         renderSingleLinearPoint(

packages/excalidraw/scene/export.ts

@@ -157,7 +157,11 @@ const prepareElementsForRender = ({
   let nextElements: readonly ExcalidrawElement[];
 
   if (exportingFrame) {
-    nextElements = getElementsOverlappingFrame(elements, exportingFrame);
+    nextElements = getElementsOverlappingFrame(
+      elements,
+      exportingFrame,
+      arrayToMap(elements),
+    );
   } else if (frameRendering.enabled && frameRendering.name) {
     nextElements = addFrameLabelsAsTextElements(elements, {
       exportWithDarkMode,

packages/excalidraw/scene/scrollConstraints.ts

@@ -0,0 +1,590 @@
+import { MAX_ZOOM } from "@excalidraw/common";
+
+import { isShallowEqual } from "@excalidraw/common";
+
+import { clamp } from "@excalidraw/math";
+
+import { getNormalizedZoom } from "./normalize";
+
+import type {
+  AnimateTranslateCanvasValues,
+  AppState,
+  ScrollConstraints,
+  ScrollToContentLockOptions,
+} from "../types";
+
+// Constants for viewport zoom factor and overscroll allowance
+const MIN_VIEWPORT_ZOOM_FACTOR = 0.1;
+const MAX_VIEWPORT_ZOOM_FACTOR = MAX_ZOOM;
+const DEFAULT_VIEWPORT_ZOOM_FACTOR = 0.2;
+const DEFAULT_OVERSCROLL_ALLOWANCE = 0.2;
+
+// Memoization variable to cache constraints for performance optimization
+let memoizedValues: {
+  previousState: Pick<
+    AppState,
+    "zoom" | "width" | "height" | "scrollConstraints"
+  >;
+  constraints: ReturnType<typeof calculateConstraints>;
+  allowOverscroll: boolean;
+} | null = null;
+
+type CanvasTranslate = Pick<AppState, "scrollX" | "scrollY" | "zoom">;
+
+export const getScrollConstraintsForBounds = ({
+  bounds,
+  zoom,
+  viewportDimensions,
+  scrollLock,
+}: {
+  bounds: readonly [number, number, number, number];
+  zoom: AppState["zoom"];
+  viewportDimensions: Pick<AppState, "width" | "height">;
+  scrollLock?: boolean | ScrollToContentLockOptions;
+}): ScrollConstraints => {
+  const [x1, y1, x2, y2] = bounds;
+  const width = x2 - x1;
+  const height = y2 - y1;
+  const baseZoom = Math.min(
+    viewportDimensions.width / width,
+    viewportDimensions.height / height,
+  );
+  const lockOptions =
+    scrollLock && typeof scrollLock === "object" ? scrollLock : undefined;
+  const viewportZoomFactor =
+    lockOptions?.viewportZoomFactor ?? zoom.value / baseZoom;
+
+  return {
+    x: x1,
+    y: y1,
+    width,
+    height,
+    animateOnNextUpdate: false,
+    lockZoom: !!lockOptions?.lockZoom,
+    overscrollAllowance: lockOptions?.overscrollAllowance,
+    viewportZoomFactor,
+  };
+};
+
+/**
+ * Calculates the zoom levels necessary to fit the constrained scrollable area within the viewport on the X and Y axes.
+ *
+ * The function considers the dimensions of the scrollable area, the dimensions of the viewport, the viewport zoom factor,
+ * and whether the zoom should be locked. It then calculates the necessary zoom levels for the X and Y axes separately.
+ * If the zoom should be locked, it calculates the maximum zoom level that fits the scrollable area within the viewport,
+ * factoring in the viewport zoom factor. If the zoom should not be locked, the maximum zoom level is set to null.
+ *
+ * @param scrollConstraints - The constraints of the scrollable area including width, height, and position.
+ * @param width - The width of the viewport.
+ * @param height - The height of the viewport.
+ * @returns An object containing the calculated zoom levels for the X and Y axes, and the initial zoom level.
+ */
+const calculateZoomLevel = (
+  scrollConstraints: ScrollConstraints,
+  width: AppState["width"],
+  height: AppState["height"],
+) => {
+  const viewportZoomFactor = scrollConstraints.viewportZoomFactor
+    ? clamp(
+        scrollConstraints.viewportZoomFactor,
+        MIN_VIEWPORT_ZOOM_FACTOR,
+        MAX_VIEWPORT_ZOOM_FACTOR,
+      )
+    : DEFAULT_VIEWPORT_ZOOM_FACTOR;
+
+  const scrollableWidth = scrollConstraints.width;
+  const scrollableHeight = scrollConstraints.height;
+  const zoomLevelX = width / scrollableWidth;
+  const zoomLevelY = height / scrollableHeight;
+  const initialZoomLevel = getNormalizedZoom(
+    Math.min(zoomLevelX, zoomLevelY) * viewportZoomFactor,
+  );
+  return { zoomLevelX, zoomLevelY, initialZoomLevel };
+};
+
+/**
+ * Calculates the effective zoom level based on the scroll constraints and current zoom.
+ *
+ * @param params - Object containing scrollConstraints, width, height, and zoom.
+ * @returns An object with the effective zoom level, initial zoom level, and zoom levels for X and Y axes.
+ */
+const calculateZoom = ({
+  scrollConstraints,
+  width,
+  height,
+  zoom,
+}: {
+  scrollConstraints: ScrollConstraints;
+  width: AppState["width"];
+  height: AppState["height"];
+  zoom: AppState["zoom"];
+}) => {
+  const { zoomLevelX, zoomLevelY, initialZoomLevel } = calculateZoomLevel(
+    scrollConstraints,
+    width,
+    height,
+  );
+  const effectiveZoom = scrollConstraints.lockZoom
+    ? Math.max(initialZoomLevel, zoom.value)
+    : zoom.value;
+  return {
+    effectiveZoom: getNormalizedZoom(effectiveZoom),
+    initialZoomLevel,
+    zoomLevelX,
+    zoomLevelY,
+  };
+};
+
+/**
+ * Calculates the scroll bounds (min and max scroll values) based on the scroll constraints and zoom level.
+ *
+ * @param params - Object containing scrollConstraints, width, height, effectiveZoom, zoomLevelX, zoomLevelY, and allowOverscroll.
+ * @returns An object with min and max scroll values for X and Y axes.
+ */
+const calculateScrollBounds = ({
+  scrollConstraints,
+  width,
+  height,
+  effectiveZoom,
+  zoomLevelX,
+  zoomLevelY,
+  allowOverscroll,
+}: {
+  scrollConstraints: ScrollConstraints;
+  width: AppState["width"];
+  height: AppState["height"];
+  effectiveZoom: number;
+  zoomLevelX: number;
+  zoomLevelY: number;
+  allowOverscroll: boolean;
+}) => {
+  const overscrollAllowance =
+    scrollConstraints.overscrollAllowance ?? DEFAULT_OVERSCROLL_ALLOWANCE;
+  const validatedOverscroll = clamp(overscrollAllowance, 0, 1);
+
+  const calculateCenter = (zoom: number) => {
+    const centerX =
+      scrollConstraints.x + (scrollConstraints.width - width / zoom) / -2;
+    const centerY =
+      scrollConstraints.y + (scrollConstraints.height - height / zoom) / -2;
+    return { centerX, centerY };
+  };
+
+  const { centerX, centerY } = calculateCenter(effectiveZoom);
+
+  const overscrollValue = Math.min(
+    validatedOverscroll * scrollConstraints.width,
+    validatedOverscroll * scrollConstraints.height,
+  );
+
+  const fitsX = effectiveZoom <= zoomLevelX;
+  const fitsY = effectiveZoom <= zoomLevelY;
+
+  const getScrollRange = (
+    axis: "x" | "y",
+    fits: boolean,
+    constraint: ScrollConstraints,
+    viewportSize: number,
+    zoom: number,
+    overscroll: number,
+  ) => {
+    const { pos, size } =
+      axis === "x"
+        ? { pos: constraint.x, size: constraint.width }
+        : { pos: constraint.y, size: constraint.height };
+    const center = axis === "x" ? centerX : centerY;
+    if (allowOverscroll) {
+      return fits
+        ? { min: center - overscroll, max: center + overscroll }
+        : {
+            min: pos - size + viewportSize / zoom - overscroll,
+            max: pos + overscroll,
+          };
+    }
+    return fits
+      ? { min: center, max: center }
+      : { min: pos - size + viewportSize / zoom, max: pos };
+  };
+
+  const xRange = getScrollRange(
+    "x",
+    fitsX,
+    scrollConstraints,
+    width,
+    effectiveZoom,
+    overscrollValue,
+  );
+  const yRange = getScrollRange(
+    "y",
+    fitsY,
+    scrollConstraints,
+    height,
+    effectiveZoom,
+    overscrollValue,
+  );
+
+  return {
+    minScrollX: xRange.min,
+    maxScrollX: xRange.max,
+    minScrollY: yRange.min,
+    maxScrollY: yRange.max,
+  };
+};
+
+/**
+ * Calculates the scroll constraints including min and max scroll values and the effective zoom level.
+ *
+ * @param params - Object containing scrollConstraints, width, height, zoom, and allowOverscroll.
+ * @returns An object with min and max scroll values, effective zoom, and initial zoom level.
+ */
+const calculateConstraints = ({
+  scrollConstraints,
+  width,
+  height,
+  zoom,
+  allowOverscroll,
+}: {
+  scrollConstraints: ScrollConstraints;
+  width: AppState["width"];
+  height: AppState["height"];
+  zoom: AppState["zoom"];
+  allowOverscroll: boolean;
+}) => {
+  const { effectiveZoom, initialZoomLevel, zoomLevelX, zoomLevelY } =
+    calculateZoom({ scrollConstraints, width, height, zoom });
+  const scrollBounds = calculateScrollBounds({
+    scrollConstraints,
+    width,
+    height,
+    effectiveZoom,
+    zoomLevelX,
+    zoomLevelY,
+    allowOverscroll,
+  });
+
+  return {
+    ...scrollBounds,
+    effectiveZoom: { value: effectiveZoom },
+    initialZoomLevel,
+  };
+};
+
+/**
+ * Constrains the scroll values within the provided min and max bounds.
+ *
+ * @param params - Object containing scrollX, scrollY, minScrollX, maxScrollX, minScrollY, maxScrollY, and constrainedZoom.
+ * @returns An object with constrained scrollX, scrollY, and zoom.
+ */
+const constrainScrollValues = ({
+  scrollX,
+  scrollY,
+  minScrollX,
+  maxScrollX,
+  minScrollY,
+  maxScrollY,
+  constrainedZoom,
+}: {
+  scrollX: number;
+  scrollY: number;
+  minScrollX: number;
+  maxScrollX: number;
+  minScrollY: number;
+  maxScrollY: number;
+  constrainedZoom: AppState["zoom"];
+}): CanvasTranslate => {
+  const constrainedScrollX = clamp(scrollX, minScrollX, maxScrollX);
+  const constrainedScrollY = clamp(scrollY, minScrollY, maxScrollY);
+  return {
+    scrollX: constrainedScrollX,
+    scrollY: constrainedScrollY,
+    zoom: constrainedZoom,
+  };
+};
+
+/**
+ * Inverts the scroll constraints to align with the state scrollX and scrollY values, which are inverted.
+ * This is a temporary fix and should be removed once issue #5965 is resolved.
+ *
+ * @param originalScrollConstraints - The original scroll constraints.
+ * @returns The aligned scroll constraints with inverted x and y coordinates.
+ */
+const alignScrollConstraints = (
+  originalScrollConstraints: ScrollConstraints,
+): ScrollConstraints => {
+  return {
+    ...originalScrollConstraints,
+    x: originalScrollConstraints.x * -1,
+    y: originalScrollConstraints.y * -1,
+  };
+};
+
+/**
+ * Determines whether the current viewport is outside the constrained area.
+ *
+ * @param state - The application state.
+ * @returns True if the viewport is outside the constrained area, false otherwise.
+ */
+const isViewportOutsideOfConstrainedArea = (state: AppState): boolean => {
+  if (!state.scrollConstraints) {
+    return false;
+  }
+
+  const {
+    scrollX,
+    scrollY,
+    width,
+    height,
+    scrollConstraints: inverseScrollConstraints,
+    zoom,
+  } = state;
+
+  const scrollConstraints = alignScrollConstraints(inverseScrollConstraints);
+
+  const adjustedWidth = width / zoom.value;
+  const adjustedHeight = height / zoom.value;
+
+  return (
+    scrollX > scrollConstraints.x ||
+    scrollX - adjustedWidth < scrollConstraints.x - scrollConstraints.width ||
+    scrollY > scrollConstraints.y ||
+    scrollY - adjustedHeight < scrollConstraints.y - scrollConstraints.height
+  );
+};
+
+/**
+ * Calculates the scroll center coordinates and the optimal zoom level to fit the constrained scrollable area within the viewport.
+ *
+ * @param state - The application state.
+ * @param scroll - Object containing current scrollX and scrollY.
+ * @returns An object with the calculated scrollX, scrollY, and zoom.
+ */
+export const calculateConstrainedScrollCenter = (
+  state: AppState,
+  { scrollX, scrollY }: Pick<AppState, "scrollX" | "scrollY">,
+): CanvasTranslate => {
+  const { width, height, scrollConstraints } = state;
+  if (!scrollConstraints) {
+    return { scrollX, scrollY, zoom: state.zoom };
+  }
+
+  const adjustedConstraints = alignScrollConstraints(scrollConstraints);
+  const zoomLevels = calculateZoomLevel(adjustedConstraints, width, height);
+  const initialZoom = { value: zoomLevels.initialZoomLevel };
+  const constraints = calculateConstraints({
+    scrollConstraints: adjustedConstraints,
+    width,
+    height,
+    zoom: initialZoom,
+    allowOverscroll: false,
+  });
+
+  return {
+    scrollX: constraints.minScrollX,
+    scrollY: constraints.minScrollY,
+    zoom: constraints.effectiveZoom,
+  };
+};
+
+/**
+ * Encodes scroll constraints into a compact string.
+ *
+ * @param constraints - The scroll constraints to encode.
+ * @returns A compact encoded string representing the scroll constraints.
+ */
+export const encodeConstraints = (constraints: ScrollConstraints): string => {
+  const payload = {
+    x: constraints.x,
+    y: constraints.y,
+    w: constraints.width,
+    h: constraints.height,
+    a: !!constraints.animateOnNextUpdate,
+    l: !!constraints.lockZoom,
+    v: constraints.viewportZoomFactor ?? 1,
+    oa: constraints.overscrollAllowance ?? DEFAULT_OVERSCROLL_ALLOWANCE,
+  };
+  const serialized = JSON.stringify(payload);
+  return encodeURIComponent(window.btoa(serialized).replace(/=+/, ""));
+};
+
+/**
+ * Decodes a compact string back into scroll constraints.
+ *
+ * @param encoded - The encoded string representing the scroll constraints.
+ * @returns The decoded scroll constraints object.
+ */
+export const decodeConstraints = (encoded: string): ScrollConstraints => {
+  try {
+    const decodedStr = window.atob(decodeURIComponent(encoded));
+    const parsed = JSON.parse(decodedStr) as {
+      x: number;
+      y: number;
+      w: number;
+      h: number;
+      a: boolean;
+      l: boolean;
+      v: number;
+      oa: number;
+    };
+    return {
+      x: parsed.x || 0,
+      y: parsed.y || 0,
+      width: parsed.w || 0,
+      height: parsed.h || 0,
+      lockZoom: parsed.l || false,
+      viewportZoomFactor: parsed.v || 1,
+      animateOnNextUpdate: parsed.a || false,
+      overscrollAllowance: parsed.oa || DEFAULT_OVERSCROLL_ALLOWANCE,
+    };
+  } catch (error) {
+    return {
+      x: 0,
+      y: 0,
+      width: 0,
+      height: 0,
+      animateOnNextUpdate: false,
+      lockZoom: false,
+      viewportZoomFactor: 1,
+      overscrollAllowance: DEFAULT_OVERSCROLL_ALLOWANCE,
+    };
+  }
+};
+
+type Options = { allowOverscroll: boolean; disableAnimation: boolean };
+const DEFAULT_OPTION: Options = {
+  allowOverscroll: true,
+  disableAnimation: false,
+};
+
+/**
+ * Constrains the AppState scroll values within the defined scroll constraints.
+ *
+ * constraintMode can be "elastic", "rigid", or "loose":
+ * - "elastic": snaps to constraints but allows overscroll
+ * - "rigid": snaps to constraints without overscroll
+ * - "loose": allows overscroll and disables animation/snapping to constraints
+ *
+ * @param state - The original AppState.
+ * @param options - Options for allowing overscroll and disabling animation.
+ * @returns A new AppState object with constrained scroll values.
+ */
+export const constrainScrollState = (
+  state: AppState,
+  constraintMode: "elastic" | "rigid" | "loose" = "elastic",
+): AppState => {
+  if (!state.scrollConstraints) {
+    return state;
+  }
+  const {
+    scrollX,
+    scrollY,
+    width,
+    height,
+    scrollConstraints: inverseScrollConstraints,
+    zoom,
+  } = state;
+
+  let allowOverscroll: boolean;
+  let disableAnimation: boolean;
+
+  switch (constraintMode) {
+    case "elastic":
+      ({ allowOverscroll, disableAnimation } = DEFAULT_OPTION);
+      break;
+    case "rigid":
+      allowOverscroll = false;
+      disableAnimation = false;
+      break;
+    case "loose":
+      allowOverscroll = true;
+      disableAnimation = true;
+      break;
+    default:
+      ({ allowOverscroll, disableAnimation } = DEFAULT_OPTION);
+      break;
+  }
+
+  const scrollConstraints = alignScrollConstraints(inverseScrollConstraints);
+
+  const canUseMemoizedValues =
+    memoizedValues &&
+    memoizedValues.previousState.scrollConstraints &&
+    memoizedValues.allowOverscroll === allowOverscroll &&
+    isShallowEqual(
+      state.scrollConstraints,
+      memoizedValues.previousState.scrollConstraints,
+    ) &&
+    isShallowEqual(
+      { zoom: zoom.value, width, height },
+      {
+        zoom: memoizedValues.previousState.zoom.value,
+        width: memoizedValues.previousState.width,
+        height: memoizedValues.previousState.height,
+      },
+    );
+
+  const constraints = canUseMemoizedValues
+    ? memoizedValues!.constraints
+    : calculateConstraints({
+        scrollConstraints,
+        width,
+        height,
+        zoom,
+        allowOverscroll,
+      });
+
+  if (!canUseMemoizedValues) {
+    memoizedValues = {
+      previousState: {
+        zoom: state.zoom,
+        width: state.width,
+        height: state.height,
+        scrollConstraints: state.scrollConstraints,
+      },
+      constraints,
+      allowOverscroll,
+    };
+  }
+
+  const constrainedValues =
+    zoom.value >= constraints.effectiveZoom.value
+      ? constrainScrollValues({
+          scrollX,
+          scrollY,
+          minScrollX: constraints.minScrollX,
+          maxScrollX: constraints.maxScrollX,
+          minScrollY: constraints.minScrollY,
+          maxScrollY: constraints.maxScrollY,
+          constrainedZoom: constraints.effectiveZoom,
+        })
+      : calculateConstrainedScrollCenter(state, { scrollX, scrollY });
+
+  return {
+    ...state,
+    scrollConstraints: {
+      ...state.scrollConstraints,
+      animateOnNextUpdate: disableAnimation
+        ? false
+        : isViewportOutsideOfConstrainedArea(state),
+    },
+    ...constrainedValues,
+  };
+};
+
+/**
+ * Checks if two canvas translate values are close within a threshold.
+ *
+ * @param from - First set of canvas translate values.
+ * @param to - Second set of canvas translate values.
+ * @returns True if the values are close, false otherwise.
+ */
+export const areCanvasTranslatesClose = (
+  from: AnimateTranslateCanvasValues,
+  to: AnimateTranslateCanvasValues,
+): boolean => {
+  const threshold = 0.1;
+  return (
+    Math.abs(from.scrollX - to.scrollX) < threshold &&
+    Math.abs(from.scrollY - to.scrollY) < threshold &&
+    Math.abs(from.zoom - to.zoom) < threshold
+  );
+};

packages/excalidraw/scene/zoom.ts

@@ -1,5 +1,67 @@
+import { constrainScrollState } from "./scrollConstraints";
+
 import type { AppState, NormalizedZoomValue } from "../types";
 
+/**
+ * When zooming out with scroll constraints active, the cursor-anchored zoom may
+ * produce a scroll position outside the valid bounds, causing a snap-back.
+ *
+ * This function adjusts the effective zoom anchor point so the resulting scroll
+ * stays within bounds — silently, without any snap. When no adjustment is needed
+ * (zoom-in, no constraints, or already within bounds) it returns the original
+ * viewport position unchanged.
+ */
+export const getConstrainedZoomAnchor = (
+  {
+    viewportX,
+    viewportY,
+    nextZoom,
+  }: { viewportX: number; viewportY: number; nextZoom: NormalizedZoomValue },
+  state: AppState,
+): { viewportX: number; viewportY: number } => {
+  if (!state.scrollConstraints || nextZoom >= state.zoom.value) {
+    return { viewportX, viewportY };
+  }
+
+  const appLayerX = viewportX - state.offsetLeft;
+  const appLayerY = viewportY - state.offsetTop;
+  const factor = 1 / nextZoom - 1 / state.zoom.value;
+
+  const newScrollX = state.scrollX + appLayerX * factor;
+  const newScrollY = state.scrollY + appLayerY * factor;
+
+  const constrained = constrainScrollState(
+    {
+      ...state,
+      scrollX: newScrollX,
+      scrollY: newScrollY,
+      zoom: { value: nextZoom },
+    },
+    "rigid",
+  );
+
+  if (
+    constrained.scrollX === newScrollX &&
+    constrained.scrollY === newScrollY
+  ) {
+    return { viewportX, viewportY };
+  }
+
+  const adjustedAppLayerX =
+    constrained.scrollX !== newScrollX
+      ? (constrained.scrollX - state.scrollX) / factor
+      : appLayerX;
+  const adjustedAppLayerY =
+    constrained.scrollY !== newScrollY
+      ? (constrained.scrollY - state.scrollY) / factor
+      : appLayerY;
+
+  return {
+    viewportX: adjustedAppLayerX + state.offsetLeft,
+    viewportY: adjustedAppLayerY + state.offsetTop,
+  };
+};
+
 export const getStateForZoom = (
   {
     viewportX,

packages/excalidraw/tests/__snapshots__/contextmenu.test.tsx.snap

@@ -13,6 +13,7 @@ exports[`contextMenu element > right-clicking on a group should select whole gro
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": {
     "items": [
@@ -960,6 +961,7 @@ exports[`contextMenu element > right-clicking on a group should select whole gro
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -1086,6 +1088,7 @@ exports[`contextMenu element > selecting 'Add to library' in context menu adds e
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -1156,6 +1159,7 @@ exports[`contextMenu element > selecting 'Add to library' in context menu adds e
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": true,
@@ -1300,6 +1304,7 @@ exports[`contextMenu element > selecting 'Bring forward' in context menu brings
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -1370,6 +1375,7 @@ exports[`contextMenu element > selecting 'Bring forward' in context menu brings
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -1631,6 +1637,7 @@ exports[`contextMenu element > selecting 'Bring to front' in context menu brings
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -1701,6 +1708,7 @@ exports[`contextMenu element > selecting 'Bring to front' in context menu brings
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -1962,6 +1970,7 @@ exports[`contextMenu element > selecting 'Copy styles' in context menu copies st
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -2032,6 +2041,7 @@ exports[`contextMenu element > selecting 'Copy styles' in context menu copies st
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": true,
@@ -2176,6 +2186,7 @@ exports[`contextMenu element > selecting 'Delete' in context menu deletes elemen
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -2246,6 +2257,7 @@ exports[`contextMenu element > selecting 'Delete' in context menu deletes elemen
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -2417,6 +2429,7 @@ exports[`contextMenu element > selecting 'Duplicate' in context menu duplicates
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -2487,6 +2500,7 @@ exports[`contextMenu element > selecting 'Duplicate' in context menu duplicates
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -2715,6 +2729,7 @@ exports[`contextMenu element > selecting 'Group selection' in context menu group
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -2787,6 +2802,7 @@ exports[`contextMenu element > selecting 'Group selection' in context menu group
     "id3": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -3087,6 +3103,7 @@ exports[`contextMenu element > selecting 'Paste styles' in context menu pastes s
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -3157,6 +3174,7 @@ exports[`contextMenu element > selecting 'Paste styles' in context menu pastes s
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -3580,6 +3598,7 @@ exports[`contextMenu element > selecting 'Send backward' in context menu sends e
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -3650,6 +3669,7 @@ exports[`contextMenu element > selecting 'Send backward' in context menu sends e
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -3903,6 +3923,7 @@ exports[`contextMenu element > selecting 'Send to back' in context menu sends el
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -3973,6 +3994,7 @@ exports[`contextMenu element > selecting 'Send to back' in context menu sends el
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -4226,6 +4248,7 @@ exports[`contextMenu element > selecting 'Ungroup selection' in context menu ung
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -4298,6 +4321,7 @@ exports[`contextMenu element > selecting 'Ungroup selection' in context menu ung
     "id3": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -4358,7 +4382,7 @@ exports[`contextMenu element > selecting 'Ungroup selection' in context menu ung
   "type": "rectangle",
   "updated": 1,
   "version": 5,
-  "versionNonce": 760410951,
+  "versionNonce": 1006504105,
   "width": 20,
   "x": -10,
   "y": 0,
@@ -4383,14 +4407,14 @@ exports[`contextMenu element > selecting 'Ungroup selection' in context menu ung
   "opacity": 100,
   "roughness": 1,
   "roundness": null,
-  "seed": 238820263,
+  "seed": 400692809,
   "strokeColor": "#1e1e1e",
   "strokeStyle": "solid",
   "strokeWidth": 2,
   "type": "rectangle",
   "updated": 1,
   "version": 5,
-  "versionNonce": 1006504105,
+  "versionNonce": 289600103,
   "width": 20,
   "x": 20,
   "y": 30,
@@ -4637,6 +4661,7 @@ exports[`contextMenu element > shows 'Group selection' in context menu for multi
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": {
     "items": [
@@ -5583,6 +5608,7 @@ exports[`contextMenu element > shows 'Group selection' in context menu for multi
     "id0": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -5854,6 +5880,7 @@ exports[`contextMenu element > shows 'Ungroup selection' in context menu for gro
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": {
     "items": [
@@ -6800,6 +6827,7 @@ exports[`contextMenu element > shows 'Ungroup selection' in context menu for gro
     "id0": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -6864,7 +6892,7 @@ exports[`contextMenu element > shows 'Ungroup selection' in context menu for gro
   "type": "rectangle",
   "updated": 1,
   "version": 4,
-  "versionNonce": 747212839,
+  "versionNonce": 1723083209,
   "width": 10,
   "x": -10,
   "y": 0,
@@ -6891,14 +6919,14 @@ exports[`contextMenu element > shows 'Ungroup selection' in context menu for gro
   "opacity": 100,
   "roughness": 1,
   "roundness": null,
-  "seed": 238820263,
+  "seed": 400692809,
   "strokeColor": "#1e1e1e",
   "strokeStyle": "solid",
   "strokeWidth": 2,
   "type": "rectangle",
   "updated": 1,
   "version": 4,
-  "versionNonce": 1723083209,
+  "versionNonce": 760410951,
   "width": 10,
   "x": 12,
   "y": 0,
@@ -7122,6 +7150,7 @@ exports[`contextMenu element > shows context menu for canvas > [end of test] app
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": {
     "items": [
@@ -7758,6 +7787,7 @@ exports[`contextMenu element > shows context menu for canvas > [end of test] app
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -7811,6 +7841,7 @@ exports[`contextMenu element > shows context menu for element > [end of test] ap
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": {
     "items": [
@@ -8755,6 +8786,7 @@ exports[`contextMenu element > shows context menu for element > [end of test] ap
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": true,
@@ -8802,6 +8834,7 @@ exports[`contextMenu element > shows context menu for element > [end of test] ap
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": {
     "items": [
@@ -9749,6 +9782,7 @@ exports[`contextMenu element > shows context menu for element > [end of test] ap
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,

packages/excalidraw/tests/__snapshots__/regressionTests.test.tsx.snap

@@ -13,6 +13,7 @@ exports[`given element A and group of elements B and given both are selected whe
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -87,6 +88,7 @@ exports[`given element A and group of elements B and given both are selected whe
     "id6": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -439,6 +441,7 @@ exports[`given element A and group of elements B and given both are selected whe
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -513,6 +516,7 @@ exports[`given element A and group of elements B and given both are selected whe
     "id6": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -855,6 +859,7 @@ exports[`regression tests > Cmd/Ctrl-click exclusively select element under poin
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -925,6 +930,7 @@ exports[`regression tests > Cmd/Ctrl-click exclusively select element under poin
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -1421,6 +1427,7 @@ exports[`regression tests > Drags selected element when hitting only bounding bo
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -1491,6 +1498,7 @@ exports[`regression tests > Drags selected element when hitting only bounding bo
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -1628,6 +1636,7 @@ exports[`regression tests > adjusts z order when grouping > [end of test] appSta
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -1700,6 +1709,7 @@ exports[`regression tests > adjusts z order when grouping > [end of test] appSta
     "id0": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -2012,6 +2022,7 @@ exports[`regression tests > alt-drag duplicates an element > [end of test] appSt
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -2084,6 +2095,7 @@ exports[`regression tests > alt-drag duplicates an element > [end of test] appSt
     "id0": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -2257,6 +2269,7 @@ exports[`regression tests > arrow keys > [end of test] appState 1`] = `
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -2327,6 +2340,7 @@ exports[`regression tests > arrow keys > [end of test] appState 1`] = `
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -2437,6 +2451,7 @@ exports[`regression tests > can drag element that covers another element, while
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -2509,6 +2524,7 @@ exports[`regression tests > can drag element that covers another element, while
     "id6": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -2762,6 +2778,7 @@ exports[`regression tests > change the properties of a shape > [end of test] app
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -2832,6 +2849,7 @@ exports[`regression tests > change the properties of a shape > [end of test] app
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -3017,6 +3035,7 @@ exports[`regression tests > click on an element and drag it > [dragged] appState
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -3089,6 +3108,7 @@ exports[`regression tests > click on an element and drag it > [dragged] appState
     "id0": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -3258,6 +3278,7 @@ exports[`regression tests > click on an element and drag it > [end of test] appS
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -3330,6 +3351,7 @@ exports[`regression tests > click on an element and drag it > [end of test] appS
     "id0": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -3494,6 +3516,7 @@ exports[`regression tests > click to select a shape > [end of test] appState 1`]
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -3566,6 +3589,7 @@ exports[`regression tests > click to select a shape > [end of test] appState 1`]
     "id3": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -3752,6 +3776,7 @@ exports[`regression tests > click-drag to select a group > [end of test] appStat
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -3824,6 +3849,7 @@ exports[`regression tests > click-drag to select a group > [end of test] appStat
     "id6": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -4066,6 +4092,7 @@ exports[`regression tests > deleting last but one element in editing group shoul
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -4136,6 +4163,7 @@ exports[`regression tests > deleting last but one element in editing group shoul
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -4502,6 +4530,7 @@ exports[`regression tests > deselects group of selected elements on pointer down
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -4575,6 +4604,7 @@ exports[`regression tests > deselects group of selected elements on pointer down
     "id3": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -4785,6 +4815,7 @@ exports[`regression tests > deselects group of selected elements on pointer up w
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -4858,6 +4889,7 @@ exports[`regression tests > deselects group of selected elements on pointer up w
     "id3": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -5061,6 +5093,7 @@ exports[`regression tests > deselects selected element on pointer down when poin
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -5133,6 +5166,7 @@ exports[`regression tests > deselects selected element on pointer down when poin
     "id0": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -5269,6 +5303,7 @@ exports[`regression tests > deselects selected element, on pointer up, when clic
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -5341,6 +5376,7 @@ exports[`regression tests > deselects selected element, on pointer up, when clic
     "id0": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -5469,6 +5505,7 @@ exports[`regression tests > double click to edit a group > [end of test] appStat
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -5539,6 +5576,7 @@ exports[`regression tests > double click to edit a group > [end of test] appStat
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -5862,6 +5900,7 @@ exports[`regression tests > drags selected elements from point inside common bou
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -5935,6 +5974,7 @@ exports[`regression tests > drags selected elements from point inside common bou
     "id3": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -6159,6 +6199,7 @@ exports[`regression tests > draw every type of shape > [end of test] appState 1`
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -6229,6 +6270,7 @@ exports[`regression tests > draw every type of shape > [end of test] appState 1`
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -6947,6 +6989,7 @@ exports[`regression tests > given a group of selected elements with an element t
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -7020,6 +7063,7 @@ exports[`regression tests > given a group of selected elements with an element t
     "id6": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -7281,6 +7325,7 @@ exports[`regression tests > given a selected element A and a not selected elemen
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -7353,6 +7398,7 @@ exports[`regression tests > given a selected element A and a not selected elemen
     "id0": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -7560,6 +7606,7 @@ exports[`regression tests > given selected element A with lower z-index than uns
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -7632,6 +7679,7 @@ exports[`regression tests > given selected element A with lower z-index than uns
     "id0": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -7795,6 +7843,7 @@ exports[`regression tests > given selected element A with lower z-index than uns
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -7867,6 +7916,7 @@ exports[`regression tests > given selected element A with lower z-index than uns
     "id0": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -8035,6 +8085,7 @@ exports[`regression tests > key 2 selects rectangle tool > [end of test] appStat
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -8105,6 +8156,7 @@ exports[`regression tests > key 2 selects rectangle tool > [end of test] appStat
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -8215,6 +8267,7 @@ exports[`regression tests > key 3 selects diamond tool > [end of test] appState
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -8285,6 +8338,7 @@ exports[`regression tests > key 3 selects diamond tool > [end of test] appState
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -8395,6 +8449,7 @@ exports[`regression tests > key 4 selects ellipse tool > [end of test] appState
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -8465,6 +8520,7 @@ exports[`regression tests > key 4 selects ellipse tool > [end of test] appState
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -8575,6 +8631,7 @@ exports[`regression tests > key 5 selects arrow tool > [end of test] appState 1`
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -8645,6 +8702,7 @@ exports[`regression tests > key 5 selects arrow tool > [end of test] appState 1`
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -8807,6 +8865,7 @@ exports[`regression tests > key 6 selects line tool > [end of test] appState 1`]
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -8877,6 +8936,7 @@ exports[`regression tests > key 6 selects line tool > [end of test] appState 1`]
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -9037,6 +9097,7 @@ exports[`regression tests > key 7 selects freedraw tool > [end of test] appState
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -9107,6 +9168,7 @@ exports[`regression tests > key 7 selects freedraw tool > [end of test] appState
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -9229,6 +9291,7 @@ exports[`regression tests > key a selects arrow tool > [end of test] appState 1`
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -9299,6 +9362,7 @@ exports[`regression tests > key a selects arrow tool > [end of test] appState 1`
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -9461,6 +9525,7 @@ exports[`regression tests > key d selects diamond tool > [end of test] appState
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -9531,6 +9596,7 @@ exports[`regression tests > key d selects diamond tool > [end of test] appState
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -9641,6 +9707,7 @@ exports[`regression tests > key l selects line tool > [end of test] appState 1`]
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -9711,6 +9778,7 @@ exports[`regression tests > key l selects line tool > [end of test] appState 1`]
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -9871,6 +9939,7 @@ exports[`regression tests > key o selects ellipse tool > [end of test] appState
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -9941,6 +10010,7 @@ exports[`regression tests > key o selects ellipse tool > [end of test] appState
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -10051,6 +10121,7 @@ exports[`regression tests > key p selects freedraw tool > [end of test] appState
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -10121,6 +10192,7 @@ exports[`regression tests > key p selects freedraw tool > [end of test] appState
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -10243,6 +10315,7 @@ exports[`regression tests > key r selects rectangle tool > [end of test] appStat
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -10313,6 +10386,7 @@ exports[`regression tests > key r selects rectangle tool > [end of test] appStat
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -10423,6 +10497,7 @@ exports[`regression tests > make a group and duplicate it > [end of test] appSta
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -10497,6 +10572,7 @@ exports[`regression tests > make a group and duplicate it > [end of test] appSta
     "id6": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -10954,6 +11030,7 @@ exports[`regression tests > noop interaction after undo shouldn't create history
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -11026,6 +11103,7 @@ exports[`regression tests > noop interaction after undo shouldn't create history
     "id0": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -11234,6 +11312,7 @@ exports[`regression tests > pinch-to-zoom works > [end of test] appState 1`] = `
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -11304,6 +11383,7 @@ exports[`regression tests > pinch-to-zoom works > [end of test] appState 1`] = `
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": "-6.25000",
   "scrollY": 0,
   "scrolledOutside": false,
@@ -11357,6 +11437,7 @@ exports[`regression tests > shift click on selected element should deselect it o
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -11429,6 +11510,7 @@ exports[`regression tests > shift click on selected element should deselect it o
     "id0": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -11557,6 +11639,7 @@ exports[`regression tests > shift-click to multiselect, then drag > [end of test
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -11630,6 +11713,7 @@ exports[`regression tests > shift-click to multiselect, then drag > [end of test
     "id3": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -11876,6 +11960,7 @@ exports[`regression tests > should group elements and ungroup them > [end of tes
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -11950,6 +12035,7 @@ exports[`regression tests > should group elements and ungroup them > [end of tes
     "id6": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -12305,6 +12391,7 @@ exports[`regression tests > single-clicking on a subgroup of a selected group sh
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -12380,6 +12467,7 @@ exports[`regression tests > single-clicking on a subgroup of a selected group sh
     "id3": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -12945,6 +13033,7 @@ exports[`regression tests > spacebar + drag scrolls the canvas > [end of test] a
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -13018,6 +13107,7 @@ exports[`regression tests > spacebar + drag scrolls the canvas > [end of test] a
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 60,
   "scrollY": 60,
   "scrolledOutside": false,
@@ -13071,6 +13161,7 @@ exports[`regression tests > supports nested groups > [end of test] appState 1`]
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -13143,6 +13234,7 @@ exports[`regression tests > supports nested groups > [end of test] appState 1`]
     "id0": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -13702,6 +13794,7 @@ exports[`regression tests > switches from group of selected elements to another
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -13775,6 +13868,7 @@ exports[`regression tests > switches from group of selected elements to another
     "id6": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -14041,6 +14135,7 @@ exports[`regression tests > switches selected element on pointer down > [end of
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -14113,6 +14208,7 @@ exports[`regression tests > switches selected element on pointer down > [end of
     "id3": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -14305,6 +14401,7 @@ exports[`regression tests > two-finger scroll works > [end of test] appState 1`]
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -14375,6 +14472,7 @@ exports[`regression tests > two-finger scroll works > [end of test] appState 1`]
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 20,
   "scrollY": "-18.53553",
   "scrolledOutside": false,
@@ -14428,6 +14526,7 @@ exports[`regression tests > undo/redo drawing an element > [end of test] appStat
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -14498,6 +14597,7 @@ exports[`regression tests > undo/redo drawing an element > [end of test] appStat
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -14792,6 +14892,7 @@ exports[`regression tests > updates fontSize & fontFamily appState > [end of tes
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -14862,6 +14963,7 @@ exports[`regression tests > updates fontSize & fontFamily appState > [end of tes
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -14915,6 +15017,7 @@ exports[`regression tests > zoom hotkeys > [end of test] appState 1`] = `
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -14988,6 +15091,7 @@ exports[`regression tests > zoom hotkeys > [end of test] appState 1`] = `
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,

packages/excalidraw/tests/history.test.tsx

@@ -314,7 +314,7 @@ describe("history", () => {
         expect.objectContaining({ id: rect2.id, isDeleted: true }),
       ]);
 
-      mouse.downAt(0, 0);
+      mouse.downAt(-10, -10);
       mouse.moveTo(25, 25);
       mouse.moveTo(50, 50);
       mouse.upAt(50, 50);
@@ -2971,6 +2971,82 @@ describe("history", () => {
       expect(h.state.editingGroupId).toBeNull();
     });
 
+    // TODO mark with "noncritical" tag once we migrate to vitest 4
+    it.skip("should support undo and redo when escape unwinds nested group editing", async () => {
+      const rectA = API.createElement({
+        type: "rectangle",
+        groupIds: ["inner", "outer"],
+        x: 0,
+      });
+      const rectB = API.createElement({
+        type: "rectangle",
+        groupIds: ["outer"],
+        x: 100,
+      });
+      const rectC = API.createElement({
+        type: "rectangle",
+        groupIds: ["inner", "outer"],
+        x: 200,
+      });
+
+      API.setElements([rectA, rectB, rectC]);
+      mouse.select(rectA);
+      mouse.doubleClickOn(rectA);
+      mouse.doubleClickOn(rectA);
+
+      assertSelectedElements([rectA]);
+      expect(h.state.editingGroupId).toBe("inner");
+      expect(API.getUndoStack().length).toBe(3);
+      expect(API.getRedoStack().length).toBe(0);
+
+      Keyboard.keyPress(KEYS.ESCAPE);
+      assertSelectedElements([rectA, rectC]);
+      expect(h.state.editingGroupId).toBe("outer");
+      expect(API.getUndoStack().length).toBe(4);
+      expect(API.getRedoStack().length).toBe(0);
+
+      Keyboard.keyPress(KEYS.ESCAPE);
+      assertSelectedElements([rectA, rectB, rectC]);
+      expect(h.state.editingGroupId).toBeNull();
+      expect(h.state.selectedGroupIds).toEqual({ outer: true });
+      expect(API.getUndoStack().length).toBe(5);
+      expect(API.getRedoStack().length).toBe(0);
+
+      Keyboard.keyPress(KEYS.ESCAPE);
+      expect(API.getSelectedElements()).toEqual([]);
+      expect(h.state.editingGroupId).toBeNull();
+      expect(h.state.selectedGroupIds).toEqual({});
+      expect(API.getUndoStack().length).toBe(6);
+      expect(API.getRedoStack().length).toBe(0);
+
+      Keyboard.undo();
+      assertSelectedElements([rectA, rectB, rectC]);
+      expect(h.state.editingGroupId).toBeNull();
+      expect(h.state.selectedGroupIds).toEqual({ outer: true });
+
+      Keyboard.undo();
+      assertSelectedElements([rectA, rectC]);
+      expect(h.state.editingGroupId).toBe("outer");
+
+      Keyboard.undo();
+      assertSelectedElements([rectA]);
+      expect(h.state.editingGroupId).toBe("inner");
+
+      Keyboard.redo();
+      assertSelectedElements([rectA, rectC]);
+      expect(h.state.editingGroupId).toBe("outer");
+
+      Keyboard.redo();
+      assertSelectedElements([rectA, rectB, rectC]);
+      expect(h.state.editingGroupId).toBeNull();
+      expect(h.state.selectedGroupIds).toEqual({ outer: true });
+
+      Keyboard.redo();
+      expect(API.getSelectedElements()).toEqual([]);
+      expect(h.state.editingGroupId).toBeNull();
+      expect(h.state.selectedGroupIds).toEqual({});
+    });
+
     it("should iterate through the history when selected or editing linear element was remotely deleted", async () => {
       // create three point arrow
       UI.clickTool("arrow");

packages/excalidraw/tests/regressionTests.test.tsx

@@ -468,7 +468,7 @@ describe("regression tests", () => {
     mouse.reset();
     mouse.down();
     mouse.move(-1000, -1000);
-    mouse.restorePosition(...end);
+    mouse.restorePosition(end[0] + 3, end[1] + 3);
     mouse.up();
 
     expect(h.elements.length).toBe(3);
@@ -519,7 +519,7 @@ describe("regression tests", () => {
     mouse.reset();
     mouse.down();
     mouse.move(-1000, -1000);
-    mouse.restorePosition(...end);
+    mouse.restorePosition(end[0] + 3, end[1] + 3);
     mouse.up();
 
     for (const element of h.elements) {
@@ -537,7 +537,7 @@ describe("regression tests", () => {
     mouse.moveTo(-10, -10); // the NW resizing handle is at [0, 0], so moving further
     mouse.down();
     mouse.move(-1000, -1000);
-    mouse.restorePosition(...end);
+    mouse.restorePosition(end[0] + 3, end[1] + 3);
     mouse.up();
 
     Keyboard.withModifierKeys({ ctrl: true, shift: true }, () => {

packages/excalidraw/tests/scrollConstraints.test.tsx

@@ -0,0 +1,135 @@
+import React from "react";
+import { vi } from "vitest";
+
+import { resolvablePromise } from "@excalidraw/common";
+
+import { Excalidraw } from "../index";
+
+import { API } from "./helpers/api";
+import { act, render, waitFor } from "./test-utils";
+
+import type { ExcalidrawImperativeAPI, ScrollConstraints } from "../types";
+
+const FIRST_SCROLL_CONSTRAINTS: ScrollConstraints = {
+  x: 0,
+  y: 0,
+  width: 400,
+  height: 300,
+  lockZoom: true,
+  overscrollAllowance: 0,
+  viewportZoomFactor: 1,
+  animateOnNextUpdate: false,
+};
+
+const SECOND_SCROLL_CONSTRAINTS: ScrollConstraints = {
+  x: 100,
+  y: 200,
+  width: 500,
+  height: 350,
+  lockZoom: false,
+  overscrollAllowance: 0.2,
+  viewportZoomFactor: 0.8,
+  animateOnNextUpdate: false,
+};
+
+describe("scrollConstraints", () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("syncs prop updates after mount", async () => {
+    const { rerender } = await render(<Excalidraw />);
+
+    expect(window.h.state.scrollConstraints).toBe(null);
+
+    rerender(<Excalidraw scrollConstraints={FIRST_SCROLL_CONSTRAINTS} />);
+
+    await waitFor(() => {
+      expect(window.h.state.scrollConstraints).toEqual(
+        FIRST_SCROLL_CONSTRAINTS,
+      );
+    });
+
+    rerender(<Excalidraw scrollConstraints={SECOND_SCROLL_CONSTRAINTS} />);
+
+    await waitFor(() => {
+      expect(window.h.state.scrollConstraints).toEqual(
+        SECOND_SCROLL_CONSTRAINTS,
+      );
+    });
+
+    rerender(<Excalidraw />);
+
+    await waitFor(() => {
+      expect(window.h.state.scrollConstraints).toBe(null);
+    });
+  });
+
+  it("ignores setScrollConstraints() when the prop is controlled", async () => {
+    const excalidrawAPIPromise = resolvablePromise<ExcalidrawImperativeAPI>();
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+
+    await render(
+      <Excalidraw
+        scrollConstraints={FIRST_SCROLL_CONSTRAINTS}
+        onExcalidrawAPI={(api) => {
+          if (api) {
+            excalidrawAPIPromise.resolve(api);
+          }
+        }}
+      />,
+    );
+
+    const excalidrawAPI = await excalidrawAPIPromise;
+
+    act(() => {
+      excalidrawAPI.setScrollConstraints(SECOND_SCROLL_CONSTRAINTS);
+    });
+
+    expect(warn).toHaveBeenCalledWith(
+      "Excalidraw: `setScrollConstraints()` is ignored when the `scrollConstraints` prop is controlled. Update the prop value instead.",
+    );
+    expect(window.h.state.scrollConstraints).toEqual(FIRST_SCROLL_CONSTRAINTS);
+  });
+
+  it("ignores scrollToContent() scrollLock when the prop is controlled", async () => {
+    const excalidrawAPIPromise = resolvablePromise<ExcalidrawImperativeAPI>();
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+
+    await render(
+      <Excalidraw
+        scrollConstraints={FIRST_SCROLL_CONSTRAINTS}
+        onExcalidrawAPI={(api) => {
+          if (api) {
+            excalidrawAPIPromise.resolve(api);
+          }
+        }}
+      />,
+    );
+
+    const excalidrawAPI = await excalidrawAPIPromise;
+    const rectangle = API.createElement({
+      x: 1000,
+      y: 1000,
+      width: 100,
+      height: 100,
+    });
+    API.setElements([rectangle]);
+
+    act(() => {
+      excalidrawAPI.scrollToContent(rectangle, {
+        animate: false,
+        fitToViewport: true,
+        scrollLock: {
+          lockZoom: true,
+          overscrollAllowance: 0,
+        },
+      });
+    });
+
+    expect(warn).toHaveBeenCalledWith(
+      "Excalidraw: `scrollToContent()` with `scrollLock` is ignored when the `scrollConstraints` prop is controlled. Update the prop value instead.",
+    );
+    expect(window.h.state.scrollConstraints).toEqual(FIRST_SCROLL_CONSTRAINTS);
+  });
+});

packages/excalidraw/tests/selection.test.tsx

@@ -1,7 +1,9 @@
 import React from "react";
 import { vi } from "vitest";
 
-import { KEYS, reseed } from "@excalidraw/common";
+import { KEYS, ROUNDNESS, reseed } from "@excalidraw/common";
+import { getElementBounds, getElementLineSegments } from "@excalidraw/element";
+import { pointFrom, pointRotateRads, type LocalPoint } from "@excalidraw/math";
 
 import { SHAPES } from "../components/shapes";
 
@@ -12,6 +14,7 @@ import * as StaticScene from "../renderer/staticScene";
 import { API } from "./helpers/api";
 import { Keyboard, Pointer, UI } from "./helpers/ui";
 import {
+  act,
   render,
   fireEvent,
   mockBoundingClientRect,
@@ -39,6 +42,19 @@ const { h } = window;
 
 const mouse = new Pointer("mouse");
 
+const getOutlineBounds = (element: ReturnType<typeof API.createElement>) => {
+  const sceneElement = API.getElement(element);
+  const elementsMap = h.scene.getNonDeletedElementsMap();
+  const points = getElementLineSegments(sceneElement, elementsMap).flat();
+
+  return [
+    Math.min(...points.map((point) => point[0])),
+    Math.min(...points.map((point) => point[1])),
+    Math.max(...points.map((point) => point[0])),
+    Math.max(...points.map((point) => point[1])),
+  ] as const;
+};
+
 describe("box-selection", () => {
   beforeEach(async () => {
     await render(<Excalidraw />);
@@ -108,6 +124,497 @@ describe("box-selection", () => {
 
     assertSelectedElements([]);
   });
+
+  it("should not select an element when the selection box only partially overlaps it", () => {
+    const rect1 = API.createElement({
+      type: "rectangle",
+      x: 0,
+      y: 0,
+      width: 50,
+      height: 50,
+      backgroundColor: "red",
+      fillStyle: "solid",
+    });
+
+    API.setElements([rect1]);
+
+    mouse.downAt(25, -20);
+    mouse.move(-1000, -1000);
+    mouse.moveTo(75, 70);
+    mouse.up();
+
+    assertSelectedElements([]);
+  });
+});
+
+describe("lasso reselection", () => {
+  beforeEach(async () => {
+    await render(<Excalidraw />);
+  });
+
+  it("should allow ctrl+alt lasso reselection when starting inside the active common bounds", () => {
+    const rectA = API.createElement({
+      type: "rectangle",
+      x: 0,
+      y: 0,
+      width: 100,
+      height: 100,
+      backgroundColor: "red",
+      fillStyle: "solid",
+    });
+    const rectB = API.createElement({
+      type: "rectangle",
+      x: 220,
+      y: 0,
+      width: 100,
+      height: 100,
+      backgroundColor: "blue",
+      fillStyle: "solid",
+    });
+
+    API.setElements([rectA, rectB]);
+    mouse.select([rectA, rectB]);
+    act(() => {
+      h.app.setActiveTool({ type: "lasso" });
+    });
+
+    Keyboard.withModifierKeys({ ctrl: true, alt: true }, () => {
+      mouse.downAt(110, 50);
+      mouse.moveTo(50, -20);
+
+      expect(h.app.lassoTrail.hasCurrentTrail).toBe(true);
+
+      mouse.moveTo(-20, 50);
+      mouse.moveTo(50, 120);
+      mouse.moveTo(110, 50);
+      mouse.up();
+    });
+
+    assertSelectedElements([rectA.id]);
+  });
+});
+
+describe("box-selection overlap mode", () => {
+  const boxSelect = (
+    startX: number,
+    startY: number,
+    endX: number,
+    endY: number,
+  ) => {
+    mouse.downAt(startX, startY);
+    mouse.move(-1000, -1000);
+    mouse.moveTo(endX, endY);
+    mouse.up();
+  };
+
+  const boxSelectTopLeftAabbCorner = (
+    element: ReturnType<typeof API.createElement>,
+  ) => {
+    const sceneElement = API.getElement(element);
+    const elementsMap = h.scene.getNonDeletedElementsMap();
+    const [x1, y1] = getElementBounds(sceneElement, elementsMap);
+
+    boxSelect(x1 + 2, y1 + 2, x1 + 12, y1 + 12);
+  };
+
+  const boxSelectTopRightAabbCorner = (
+    element: ReturnType<typeof API.createElement>,
+  ) => {
+    const sceneElement = API.getElement(element);
+    const elementsMap = h.scene.getNonDeletedElementsMap();
+    const [, y1, x2] = getElementBounds(sceneElement, elementsMap);
+
+    boxSelect(x2 - 12, y1 + 2, x2 - 2, y1 + 12);
+  };
+
+  const boxSelectTopLeftRotatedLocalBoundsCorner = (
+    element: ReturnType<typeof API.createElement>,
+  ) => {
+    const sceneElement = API.getElement(element);
+    const elementsMap = h.scene.getNonDeletedElementsMap();
+    const [x1, y1, x2, y2] = getElementBounds(sceneElement, elementsMap, true);
+    const center = pointFrom((x1 + x2) / 2, (y1 + y2) / 2);
+    const [cornerX, cornerY] = pointRotateRads(
+      pointFrom(x1, y1),
+      center,
+      sceneElement.angle,
+    );
+
+    boxSelect(cornerX - 4, cornerY - 4, cornerX + 4, cornerY + 4);
+  };
+
+  beforeEach(async () => {
+    await render(
+      <Excalidraw
+        initialData={{ appState: { boxSelectionMode: "overlap" } }}
+      />,
+    );
+  });
+
+  it("should select an element when the selection box partially overlaps it", () => {
+    const rect1 = API.createElement({
+      type: "rectangle",
+      x: 0,
+      y: 0,
+      width: 50,
+      height: 50,
+      backgroundColor: "red",
+      fillStyle: "solid",
+    });
+
+    API.setElements([rect1]);
+
+    boxSelect(25, -20, 75, 70);
+
+    assertSelectedElements([rect1.id]);
+  });
+
+  it("should not select a transparent rectangle when the selection box stays inside it", () => {
+    const rect1 = API.createElement({
+      type: "rectangle",
+      x: 0,
+      y: 0,
+      width: 100,
+      height: 100,
+      backgroundColor: "transparent",
+      fillStyle: "solid",
+    });
+
+    API.setElements([rect1]);
+
+    boxSelect(25, 25, 75, 75);
+
+    assertSelectedElements([]);
+  });
+
+  it("should select a transparent rectangle when the selection box crosses its outline", () => {
+    const rect1 = API.createElement({
+      type: "rectangle",
+      x: 0,
+      y: 0,
+      width: 100,
+      height: 100,
+      backgroundColor: "transparent",
+      fillStyle: "solid",
+    });
+
+    API.setElements([rect1]);
+
+    boxSelect(25, 25, 125, 75);
+
+    assertSelectedElements([rect1.id]);
+  });
+
+  it("should not select a rotated transparent rectangle when the selection box stays inside it", () => {
+    const rect1 = API.createElement({
+      type: "rectangle",
+      x: 0,
+      y: 0,
+      width: 100,
+      height: 100,
+      angle: Math.PI / 4,
+      backgroundColor: "transparent",
+      fillStyle: "solid",
+    });
+
+    API.setElements([rect1]);
+
+    boxSelect(40, 40, 60, 60);
+
+    assertSelectedElements([]);
+  });
+
+  it("should select a rotated rounded rectangle when the selection box contains its outline but not its bounds", () => {
+    const rect = API.createElement({
+      type: "rectangle",
+      x: 0,
+      y: 0,
+      width: 100,
+      height: 180,
+      angle: Math.PI / 6,
+      backgroundColor: "transparent",
+      fillStyle: "solid",
+      roundness: { type: ROUNDNESS.ADAPTIVE_RADIUS },
+      roughness: 0,
+    });
+
+    API.setElements([rect]);
+
+    const sceneRect = API.getElement(rect);
+    const elementsMap = h.scene.getNonDeletedElementsMap();
+    const [boundsX1, boundsY1, boundsX2, boundsY2] = getElementBounds(
+      sceneRect,
+      elementsMap,
+    );
+    const [outlineX1, outlineY1, outlineX2, outlineY2] = getOutlineBounds(rect);
+
+    expect(outlineX1).toBeGreaterThan(boundsX1 - 1);
+    expect(outlineY1).toBeGreaterThan(boundsY1 - 1);
+    expect(outlineX2).toBeLessThan(boundsX2 + 1);
+    expect(outlineY2).toBeLessThan(boundsY2 + 1);
+
+    boxSelect(
+      outlineX1 - (outlineX1 - boundsX1) / 2,
+      outlineY1 - (outlineY1 - boundsY1) / 2,
+      outlineX2 + (boundsX2 - outlineX2) / 2,
+      outlineY2 + (boundsY2 - outlineY2) / 2,
+    );
+
+    assertSelectedElements([rect.id]);
+  });
+
+  it("should not select a filled rotated rectangle when the selection box only overlaps its axis-aligned bounds", () => {
+    const rect = API.createElement({
+      type: "rectangle",
+      x: 0,
+      y: 0,
+      width: 100,
+      height: 100,
+      angle: Math.PI / 4,
+      backgroundColor: "red",
+      fillStyle: "solid",
+    });
+
+    API.setElements([rect]);
+
+    boxSelectTopLeftAabbCorner(rect);
+
+    assertSelectedElements([]);
+  });
+
+  it("should not select a filled ellipse when the selection box only overlaps its bounds corner", () => {
+    const ellipse = API.createElement({
+      type: "ellipse",
+      x: 0,
+      y: 0,
+      width: 100,
+      height: 100,
+      backgroundColor: "red",
+      fillStyle: "solid",
+    });
+
+    API.setElements([ellipse]);
+
+    boxSelectTopRightAabbCorner(ellipse);
+
+    assertSelectedElements([]);
+  });
+
+  it("should not select a filled diamond when the selection box only overlaps its bounds corner", () => {
+    const diamond = API.createElement({
+      type: "diamond",
+      x: 0,
+      y: 0,
+      width: 100,
+      height: 100,
+      backgroundColor: "red",
+      fillStyle: "solid",
+    });
+
+    API.setElements([diamond]);
+
+    boxSelectTopRightAabbCorner(diamond);
+
+    assertSelectedElements([]);
+  });
+
+  it("should not select a filled rotated ellipse when the selection box only overlaps its axis-aligned bounds", () => {
+    const ellipse = API.createElement({
+      type: "ellipse",
+      x: 0,
+      y: 0,
+      width: 100,
+      height: 100,
+      angle: Math.PI / 4,
+      backgroundColor: "red",
+      fillStyle: "solid",
+    });
+
+    API.setElements([ellipse]);
+
+    boxSelectTopLeftRotatedLocalBoundsCorner(ellipse);
+
+    assertSelectedElements([]);
+  });
+
+  it("should not select a filled rotated diamond when the selection box only overlaps its rotated local bounds", () => {
+    const diamond = API.createElement({
+      type: "diamond",
+      x: 0,
+      y: 0,
+      width: 100,
+      height: 100,
+      angle: Math.PI / 4,
+      backgroundColor: "red",
+      fillStyle: "solid",
+    });
+
+    API.setElements([diamond]);
+
+    boxSelectTopLeftRotatedLocalBoundsCorner(diamond);
+
+    assertSelectedElements([]);
+  });
+
+  it("should not select rotated text when the selection box only overlaps its axis-aligned bounds", () => {
+    const text = API.createElement({
+      type: "text",
+      x: 0,
+      y: 0,
+      width: 100,
+      height: 100,
+      angle: Math.PI / 4,
+      text: "test",
+    });
+
+    API.setElements([text]);
+
+    boxSelect(-18, -18, -8, -8);
+
+    assertSelectedElements([]);
+  });
+
+  it("should not select rotated image when the selection box only overlaps its axis-aligned bounds", () => {
+    const image = API.createElement({
+      type: "image",
+      x: 0,
+      y: 0,
+      width: 100,
+      height: 100,
+      angle: Math.PI / 4,
+      fileId: "file_A",
+      status: "saved",
+    });
+
+    API.setElements([image]);
+
+    boxSelect(-18, -18, -8, -8);
+
+    assertSelectedElements([]);
+  });
+
+  it("should deselect a selected rotated rectangle when clicking in the empty corner of its axis-aligned bounds", () => {
+    const rect = API.createElement({
+      type: "rectangle",
+      x: 0,
+      y: 0,
+      width: 100,
+      height: 100,
+      angle: Math.PI / 4,
+      backgroundColor: "red",
+      fillStyle: "solid",
+    });
+
+    API.setElements([rect]);
+
+    mouse.clickAt(50, 50);
+    assertSelectedElements([rect.id]);
+
+    const sceneRect = API.getElement(rect);
+    const elementsMap = h.scene.getNonDeletedElementsMap();
+    const [x1, y1] = getElementBounds(sceneRect, elementsMap);
+
+    mouse.clickAt(x1 + 2, y1 + 2);
+
+    assertSelectedElements([]);
+  });
+
+  it("should not select a line when the selection box only overlaps its bounds", () => {
+    const line = API.createElement({
+      type: "line",
+      x: 0,
+      y: 0,
+      width: 100,
+      height: 100,
+      backgroundColor: "transparent",
+      points: [pointFrom<LocalPoint>(0, 0), pointFrom<LocalPoint>(100, 100)],
+    });
+
+    API.setElements([line]);
+
+    boxSelect(20, 50, 30, 60);
+
+    assertSelectedElements([]);
+  });
+
+  it("should not click-select rotated freedraw in the corner of its axis-aligned bounds", () => {
+    const freedraw = API.createElement({
+      type: "freedraw",
+      x: 0,
+      y: 0,
+      width: 100,
+      height: 100,
+      angle: Math.PI / 4,
+      backgroundColor: "transparent",
+      points: [
+        pointFrom<LocalPoint>(0, 0),
+        pointFrom<LocalPoint>(100, 0),
+        pointFrom<LocalPoint>(100, 100),
+        pointFrom<LocalPoint>(0, 100),
+        pointFrom<LocalPoint>(0, 0),
+      ],
+    });
+
+    API.setElements([freedraw]);
+
+    const sceneFreedraw = API.getElement(freedraw);
+    const elementsMap = h.scene.getNonDeletedElementsMap();
+    const [x1, y1] = getElementBounds(sceneFreedraw, elementsMap);
+
+    mouse.clickAt(x1 + 2, y1 + 2);
+
+    assertSelectedElements([]);
+  });
+
+  it("should not select a freedraw when the selection box only overlaps its bounds", () => {
+    const freedraw = API.createElement({
+      type: "freedraw",
+      x: 0,
+      y: 0,
+      width: 100,
+      height: 100,
+      backgroundColor: "transparent",
+      points: [
+        pointFrom<LocalPoint>(0, 0),
+        pointFrom<LocalPoint>(50, 50),
+        pointFrom<LocalPoint>(100, 100),
+      ],
+    });
+
+    API.setElements([freedraw]);
+
+    boxSelect(20, 50, 30, 60);
+
+    assertSelectedElements([]);
+  });
+
+  it("should not select a transparent framed element when the selection box stays inside its clipped bounds", () => {
+    const frame = API.createElement({
+      type: "frame",
+      x: 0,
+      y: 0,
+      width: 100,
+      height: 100,
+      backgroundColor: "transparent",
+      fillStyle: "solid",
+    });
+    const rect1 = API.createElement({
+      type: "rectangle",
+      x: 50,
+      y: 10,
+      width: 100,
+      height: 80,
+      frameId: frame.id,
+      backgroundColor: "transparent",
+      fillStyle: "solid",
+    });
+
+    API.setElements([frame, rect1]);
+
+    boxSelect(60, 20, 90, 60);
+
+    assertSelectedElements([]);
+  });
 });
 
 describe("inner box-selection", () => {
@@ -326,7 +833,7 @@ describe("select single element on the scene", () => {
     fireEvent.pointerUp(canvas);
 
     expect(renderInteractiveScene).toHaveBeenCalledTimes(8);
-    expect(renderStaticScene).toHaveBeenCalledTimes(6);
+    expect(renderStaticScene).toHaveBeenCalledTimes(7);
     expect(h.state.selectionElement).toBeNull();
     expect(h.elements.length).toEqual(1);
     expect(h.state.selectedElementIds[h.elements[0].id]).toBeTruthy();
@@ -359,7 +866,7 @@ describe("select single element on the scene", () => {
     fireEvent.pointerUp(canvas);
 
     expect(renderInteractiveScene).toHaveBeenCalledTimes(8);
-    expect(renderStaticScene).toHaveBeenCalledTimes(6);
+    expect(renderStaticScene).toHaveBeenCalledTimes(7);
     expect(h.state.selectionElement).toBeNull();
     expect(h.elements.length).toEqual(1);
     expect(h.state.selectedElementIds[h.elements[0].id]).toBeTruthy();
@@ -392,7 +899,7 @@ describe("select single element on the scene", () => {
     fireEvent.pointerUp(canvas);
 
     expect(renderInteractiveScene).toHaveBeenCalledTimes(8);
-    expect(renderStaticScene).toHaveBeenCalledTimes(6);
+    expect(renderStaticScene).toHaveBeenCalledTimes(7);
     expect(h.state.selectionElement).toBeNull();
     expect(h.elements.length).toEqual(1);
     expect(h.state.selectedElementIds[h.elements[0].id]).toBeTruthy();
@@ -438,7 +945,7 @@ describe("select single element on the scene", () => {
     fireEvent.pointerUp(canvas);
 
     expect(renderInteractiveScene).toHaveBeenCalledTimes(10);
-    expect(renderStaticScene).toHaveBeenCalledTimes(8);
+    expect(renderStaticScene).toHaveBeenCalledTimes(9);
     expect(h.state.selectionElement).toBeNull();
     expect(h.elements.length).toEqual(1);
     expect(h.state.selectedElementIds[h.elements[0].id]).toBeTruthy();
@@ -483,7 +990,7 @@ describe("select single element on the scene", () => {
     fireEvent.pointerUp(canvas);
 
     expect(renderInteractiveScene).toHaveBeenCalledTimes(10);
-    expect(renderStaticScene).toHaveBeenCalledTimes(8);
+    expect(renderStaticScene).toHaveBeenCalledTimes(9);
     expect(h.state.selectionElement).toBeNull();
     expect(h.elements.length).toEqual(1);
     expect(h.state.selectedElementIds[h.elements[0].id]).toBeTruthy();
@@ -558,3 +1065,58 @@ describe("selectedElementIds stability", () => {
     expect(h.state.selectedElementIds).toBe(selectedElementIds_2);
   });
 });
+
+describe("deselecting", () => {
+  beforeEach(async () => {
+    await render(<Excalidraw handleKeyboardGlobally={true} />);
+  });
+
+  it("esc unwinds nested group editing before deselecting", () => {
+    const rectA = API.createElement({
+      type: "rectangle",
+      x: 0,
+      y: 0,
+      groupIds: ["inner", "outer"],
+    });
+    const rectB = API.createElement({
+      type: "rectangle",
+      x: 100,
+      y: 0,
+      groupIds: ["outer"],
+    });
+    const rectC = API.createElement({
+      type: "rectangle",
+      x: 200,
+      y: 0,
+      groupIds: ["inner", "outer"],
+    });
+
+    API.setElements([rectA, rectB, rectC]);
+
+    mouse.select(rectA);
+    assertSelectedElements(rectA, rectB, rectC);
+    expect(h.state.editingGroupId).toBeNull();
+
+    mouse.doubleClickOn(rectA);
+    assertSelectedElements(rectA, rectC);
+    expect(h.state.editingGroupId).toBe("outer");
+
+    mouse.doubleClickOn(rectA);
+    assertSelectedElements(rectA);
+    expect(h.state.editingGroupId).toBe("inner");
+
+    Keyboard.keyPress(KEYS.ESCAPE);
+    assertSelectedElements(rectA, rectC);
+    expect(h.state.editingGroupId).toBe("outer");
+
+    Keyboard.keyPress(KEYS.ESCAPE);
+    assertSelectedElements(rectA, rectB, rectC);
+    expect(h.state.editingGroupId).toBeNull();
+    expect(h.state.selectedGroupIds).toEqual({ outer: true });
+
+    Keyboard.keyPress(KEYS.ESCAPE);
+    expect(API.getSelectedElements()).toEqual([]);
+    expect(h.state.editingGroupId).toBeNull();
+    expect(h.state.selectedGroupIds).toEqual({});
+  });
+});

packages/excalidraw/types.ts

@@ -269,6 +269,8 @@ export type ObservedElementsAppState = {
   activeLockedId: AppState["activeLockedId"];
 };
 
+export type BoxSelectionMode = "contain" | "overlap";
+
 export interface AppState {
   contextMenu: {
     items: ContextMenuItems;
@@ -307,6 +309,8 @@ export interface AppState {
    * `bindingPreference` and keyboard modifiers (ctrl/alt)
    */
   isBindingEnabled: boolean;
+  /** user box selection preference; defaults to "contain" when unset */
+  boxSelectionMode: BoxSelectionMode;
   /** user arrow binding preference */
   bindingPreference: "enabled" | "disabled";
   /** user preference whether arrow snap to midpoints while binding */
@@ -450,6 +454,7 @@ export interface AppState {
   userToFollow: UserToFollow | null;
   /** the socket ids of the users following the current user */
   followedBy: Set<SocketId>;
+  scrollConstraints: ScrollConstraints | null;
 
   /** image cropping */
   isCropping: boolean;
@@ -542,6 +547,8 @@ export type ExcalidrawInitialDataState = Merge<
   ImportedDataState,
   {
     libraryItems?: MaybePromise<Required<ImportedDataState>["libraryItems"]>;
+    scrollX?: number;
+    scrollY?: number;
   }
 >;
 
@@ -658,6 +665,7 @@ export interface ExcalidrawProps {
   onScrollChange?: (scrollX: number, scrollY: number, zoom: Zoom) => void;
   onUserFollow?: (payload: OnUserFollowedPayload) => void;
   children?: React.ReactNode;
+  scrollConstraints?: AppState["scrollConstraints"];
   validateEmbeddable?:
     | boolean
     | string[]
@@ -984,6 +992,8 @@ export interface ExcalidrawImperativeAPI {
   ) => UnsubscribeCallback;
   onStateChange: InstanceType<typeof App>["onStateChange"];
   onEvent: InstanceType<typeof App>["onEvent"];
+  app: InstanceType<typeof App>;
+  setScrollConstraints: InstanceType<typeof App>["setScrollConstraints"];
 }
 
 export type FrameNameBounds = {
@@ -1050,3 +1060,69 @@ export type Offsets = Partial<{
   bottom: number;
   left: number;
 }>;
+
+export type ScrollConstraints = {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+  animateOnNextUpdate?: boolean;
+  /**
+   * A factor that determines the minimum zoom level that should fit the
+   * constrained area into the viewport.
+   */
+  viewportZoomFactor?: number;
+  /**
+   * If true, the user will not be able to zoom out beyond the scroll
+   * constraints (taking into account the viewportZoomFactor).
+   */
+  lockZoom?: boolean;
+  /**
+   * <0-1> - how much can you scroll beyond the constrained area within the
+   * timeout window. Note you will still be snapped back to the constrained area
+   * after the timeout.
+   */
+  overscrollAllowance?: number;
+};
+
+/**
+ * Optional scroll constraint settings derived from the final viewport computed
+ * by `scrollToContent()`.
+ */
+export type ScrollToContentLockOptions = {
+  lockZoom?: boolean;
+  overscrollAllowance?: number;
+  viewportZoomFactor?: number;
+};
+
+export type ScrollToContentOptions =
+  | ({
+      fitToContent?: boolean;
+      fitToViewport?: never;
+      viewportZoomFactor?: number;
+      animate?: boolean;
+      duration?: number;
+      scrollLock?: boolean | ScrollToContentLockOptions;
+    } & {
+      minZoom?: number;
+      maxZoom?: number;
+      canvasOffsets?: Offsets;
+    })
+  | ({
+      fitToContent?: never;
+      fitToViewport?: boolean;
+      viewportZoomFactor?: number;
+      animate?: boolean;
+      duration?: number;
+      scrollLock?: boolean | ScrollToContentLockOptions;
+    } & {
+      minZoom?: number;
+      maxZoom?: number;
+      canvasOffsets?: Offsets;
+    });
+
+export type AnimateTranslateCanvasValues = {
+  scrollX: AppState["scrollX"];
+  scrollY: AppState["scrollY"];
+  zoom: AppState["zoom"]["value"];
+};

packages/excalidraw/wysiwyg/textWysiwyg.test.tsx

@@ -45,6 +45,28 @@ unmountComponent();
 const tab = "    ";
 const mouse = new Pointer("mouse");
 
+const exitTextEditorAndAssertSelection = async ({
+  editor,
+  selectedIds,
+  nextText,
+}: {
+  editor: HTMLTextAreaElement;
+  selectedIds: string[];
+  nextText?: string;
+}) => {
+  if (nextText !== undefined) {
+    updateTextEditor(editor, nextText);
+  }
+
+  Keyboard.exitTextEditor(editor);
+
+  expect(await getTextEditor({ waitForEditor: false })).toBe(null);
+  expect(window.h.state.editingTextElement).toBeNull();
+  expect(API.getSelectedElements().map((element) => element.id)).toEqual(
+    selectedIds,
+  );
+};
+
 describe("textWysiwyg", () => {
   describe("start text editing", () => {
     const { h } = window;
@@ -271,6 +293,33 @@ describe("textWysiwyg", () => {
       expect(h.elements.length).toBe(1);
     });
 
+    it("should reselect text after exiting wysiwyg with escape", async () => {
+      const text = API.createElement({
+        type: "text",
+        text: "ola",
+        x: 60,
+        y: 0,
+        width: 100,
+        height: 100,
+      });
+
+      API.setElements([text]);
+      API.setSelectedElements([text]);
+      UI.clickTool("selection");
+
+      Keyboard.keyPress(KEYS.ENTER);
+
+      const editor = await getTextEditor();
+
+      expect(editor).not.toBe(null);
+      expect(h.state.editingTextElement?.id).toBe(text.id);
+
+      await exitTextEditorAndAssertSelection({
+        editor,
+        selectedIds: [text.id],
+      });
+    });
+
     it("should edit selected bound text on single click", async () => {
       const container = API.createElement({
         type: "rectangle",
@@ -1305,6 +1354,40 @@ describe("textWysiwyg", () => {
       );
     });
 
+    it.each([
+      {
+        label: "container",
+        createElements: () => API.createTextContainer(),
+      },
+      {
+        label: "arrow",
+        createElements: () => API.createLabeledArrow(),
+      },
+    ])(
+      "should reselect $label after deleting bound text with escape",
+      async ({ createElements }) => {
+        const [selectedElement, text] = createElements();
+        API.setElements([selectedElement, text]);
+        API.setSelectedElements([selectedElement]);
+
+        Keyboard.keyPress(KEYS.ENTER);
+        const editor = await getTextEditor();
+
+        await exitTextEditorAndAssertSelection({
+          editor,
+          nextText: "",
+          selectedIds: [selectedElement.id],
+        });
+
+        expect(selectedElement.boundElements).toStrictEqual([]);
+        expect(h.elements[1]).toEqual(
+          expect.objectContaining({
+            isDeleted: true,
+          }),
+        );
+      },
+    );
+
     it("should restore original container height and clear cache once text is unbind", async () => {
       const container = API.createElement({
         type: "rectangle",

packages/math/src/curve.ts

@@ -137,8 +137,17 @@ const calculate = <Point extends GlobalPoint | LocalPoint>(
   [t0, s0]: [number, number],
   l: LineSegment<Point>,
   c: Curve<Point>,
+  tolerance: number = 1e-2,
+  iterLimit: number = 4,
 ) => {
-  const solution = solveWithAnalyticalJacobian(c, l, t0, s0, 1e-2, 4);
+  const solution = solveWithAnalyticalJacobian(
+    c,
+    l,
+    t0,
+    s0,
+    tolerance,
+    iterLimit,
+  );
 
   if (!solution) {
     return null;
@@ -158,18 +167,43 @@ const calculate = <Point extends GlobalPoint | LocalPoint>(
  */
 export function curveIntersectLineSegment<
   Point extends GlobalPoint | LocalPoint,
->(c: Curve<Point>, l: LineSegment<Point>): Point[] {
+>(
-  let solution = calculate(initial_guesses[0], l, c);
+  c: Curve<Point>,
+  l: LineSegment<Point>,
+  opts?: {
+    tolerance?: number;
+    iterLimit?: number;
+  },
+): Point[] {
+  let solution = calculate(
+    initial_guesses[0],
+    l,
+    c,
+    opts?.tolerance,
+    opts?.iterLimit,
+  );
   if (solution) {
     return [solution];
   }
 
-  solution = calculate(initial_guesses[1], l, c);
+  solution = calculate(
+    initial_guesses[1],
+    l,
+    c,
+    opts?.tolerance,
+    opts?.iterLimit,
+  );
   if (solution) {
     return [solution];
   }
 
-  solution = calculate(initial_guesses[2], l, c);
+  solution = calculate(
+    initial_guesses[2],
+    l,
+    c,
+    opts?.tolerance,
+    opts?.iterLimit,
+  );
   if (solution) {
     return [solution];
   }

packages/math/src/segment.ts

@@ -40,7 +40,7 @@ export const isLineSegment = <Point extends GlobalPoint | LocalPoint>(
   Array.isArray(segment) &&
   segment.length === 2 &&
   isPoint(segment[0]) &&
-  isPoint(segment[0]);
+  isPoint(segment[1]);
 
 /**
  * Return the coordinates resulting from rotating the given line about an origin by an angle in radians

packages/math/tests/segment.test.ts

@@ -1,5 +1,9 @@
 import { pointFrom } from "../src/point";
-import { lineSegment, lineSegmentIntersectionPoints } from "../src/segment";
+import {
+  lineSegment,
+  lineSegmentIntersectionPoints,
+  isLineSegment,
+} from "../src/segment";
 
 describe("line-segment intersections", () => {
   it("should correctly detect intersection", () => {
@@ -19,3 +23,23 @@ describe("line-segment intersections", () => {
     ).toEqual(null);
   });
 });
+describe("isLineSegment validation", () => {
+  it("should return true for a valid segment", () => {
+    expect(
+      isLineSegment([
+        [0, 0],
+        [1, 1],
+      ]),
+    ).toBe(true);
+  });
+
+  it("should return false if second element is not a point", () => {
+    const invalidSegment = [[0, 0], "not-a-point"] as any;
+
+    expect(isLineSegment(invalidSegment)).toBe(false);
+  });
+
+  it("should return false for wrong length", () => {
+    expect(isLineSegment([[0, 0]])).toBe(false);
+  });
+});

packages/utils/tests/__snapshots__/export.test.ts.snap

@@ -13,6 +13,7 @@ exports[`exportToSvg > with default arguments 1`] = `
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -84,6 +85,7 @@ exports[`exportToSvg > with default arguments 1`] = `
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,

scripts/woff2/woff2-vite-plugins.js

@@ -90,6 +90,13 @@ module.exports.woff2BrowserPlugin = () => {
         type="font/woff2"
         crossorigin="anonymous"
       />
+      <link
+        rel="preload"
+        href="${OSS_FONTS_CDN}fonts/Assistant/Assistant-SemiBold.woff2"
+        as="font"
+        type="font/woff2"
+        crossorigin="anonymous"
+      />
       <link
         rel="preload"
         href="${OSS_FONTS_CDN}fonts/ComicShanns/ComicShanns-Regular-279a7b317d12eb88de06167bd672b4b4.woff2"

vercel.json

@@ -1,5 +1,4 @@
 {
-  "public": true,
   "headers": [
     {
       "source": "/(.*)",

yarn.lock

@@ -1531,10 +1531,10 @@
   resolved "https://registry.yarnpkg.com/@excalidraw/markdown-to-text/-/markdown-to-text-0.1.2.tgz#1703705e7da608cf478f17bfe96fb295f55a23eb"
   integrity sha512-1nDXBNAojfi3oSFwJswKREkFm5wrSjqay81QlyRv2pkITG/XYB5v+oChENVBQLcxQwX4IUATWvXM5BcaNhPiIg==
 
-"@excalidraw/mermaid-to-excalidraw@2.1.0":
+"@excalidraw/mermaid-to-excalidraw@2.2.2":
-  version "2.1.0"
+  version "2.2.2"
-  resolved "https://registry.yarnpkg.com/@excalidraw/mermaid-to-excalidraw/-/mermaid-to-excalidraw-2.1.0.tgz#a5b9cf87c3185558cda7f9687d87b9937f452358"
+  resolved "https://registry.yarnpkg.com/@excalidraw/mermaid-to-excalidraw/-/mermaid-to-excalidraw-2.2.2.tgz#ee6b597a0d95b9a76f7ae41ce0e3733a9b96e4a0"
-  integrity sha512-RMd+c2b7WzzUjhERMpKwp8PhF2/XlHDjr/zK+Gxfp8K9sVlafPYJ5OEa/GkN6edi2rBUXRfW+41WdO6L56b6Kw==
+  integrity sha512-5VKQq5CdRocC82vOIUpQ5ufJOVV9FpBTdHGA+ULqazeIVV+cr299877omQCibsdS3Bpitz2fsnTwnIXEmLVDSg==
   dependencies:
     "@excalidraw/markdown-to-text" "0.1.2"
     "@mermaid-js/parser" "^0.6.3"