Merge branch 'master' into mtolmacs/feat/freedraw-research-1

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

.github/workflows/autorelease-excalidraw.yml

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

.github/workflows/build-docker.yml

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

.github/workflows/lint.yml

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

.github/workflows/locales-coverage.yml

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

.github/workflows/publish-docker.yml

@@ -11,7 +11,7 @@ jobs:
 
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v3
+        uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
       - name: Login to DockerHub
         uses: docker/login-action@465a07811f14bebb1938fbed4728c6a1ff8901fc # v2
         with:

.github/workflows/sentry-production.yml

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

.github/workflows/size-limit.yml

@@ -10,9 +10,9 @@ jobs:
       CI_JOB_NUMBER: 1
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v3
+        uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
       - name: Setup Node.js
-        uses: actions/setup-node@v3
+        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4
         with:
           node-version: 20.x
       - name: Install in packages/excalidraw

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

@@ -10,9 +10,9 @@ jobs:
       pull-requests: write
 
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
       - name: "Install Node"
-        uses: actions/setup-node@v2
+        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4
         with:
           node-version: "20.x"
       - name: "Install Deps"

.github/workflows/test.yml

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

Dockerfile

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

excalidraw-app/App.tsx

@@ -136,6 +136,7 @@ import { useHandleAppTheme } from "./useHandleAppTheme";
 import { getPreferredLanguage } from "./app-language/language-detector";
 import { useAppLangCode } from "./app-language/language-state";
 import DebugCanvas, {
+  ConsoleLogger,
   debugRenderer,
   isVisualDebuggerEnabled,
   loadSavedDebugState,
@@ -1261,6 +1262,7 @@ const ExcalidrawWrapper = () => {
             ref={debugCanvasRef}
           />
         )}
+        {isVisualDebuggerEnabled() && <ConsoleLogger />}
       </Excalidraw>
     </div>
   );

excalidraw-app/app_constants.ts

@@ -42,6 +42,7 @@ export const STORAGE_KEYS = {
   LOCAL_STORAGE_COLLAB: "excalidraw-collab",
   LOCAL_STORAGE_THEME: "excalidraw-theme",
   LOCAL_STORAGE_DEBUG: "excalidraw-debug",
+  LOCAL_STORAGE_DEBUG_CONSOLE: "excalidraw-debug-console",
   VERSION_DATA_STATE: "version-dataState",
   VERSION_FILES: "version-files",
 

excalidraw-app/collab/Collab.tsx

@@ -355,6 +355,8 @@ class Collab extends PureComponent<CollabProps, CollabState> {
   };
 
   stopCollaboration = (keepRemoteState = true) => {
+    this.broadcastElements.flush();
+    this.broadcastElements.cancel();
     this.queueBroadcastAllElements.cancel();
     this.queueSaveToFirebase.cancel();
     this.loadImageFiles.cancel();
@@ -941,7 +943,9 @@ class Collab extends PureComponent<CollabProps, CollabState> {
     this.portal.broadcastIdleChange(userState);
   };
 
-  broadcastElements = (elements: readonly OrderedExcalidrawElement[]) => {
+  private _broadcastElements = (
+    elements: readonly OrderedExcalidrawElement[],
+  ) => {
     if (
       getSceneVersion(elements) >
       this.getLastBroadcastedOrReceivedSceneVersion()
@@ -952,6 +956,13 @@ class Collab extends PureComponent<CollabProps, CollabState> {
     }
   };
 
+  broadcastElements = throttle(
+    (elements: readonly OrderedExcalidrawElement[]) =>
+      this._broadcastElements(elements),
+    10,
+    { leading: true, trailing: true },
+  );
+
   syncElements = (elements: readonly OrderedExcalidrawElement[]) => {
     this.broadcastElements(elements);
     this.queueSaveToFirebase();

excalidraw-app/components/AppMainMenu.tsx

@@ -4,7 +4,8 @@ import {
   eyeIcon,
 } from "@excalidraw/excalidraw/components/icons";
 import { MainMenu } from "@excalidraw/excalidraw/index";
-import React from "react";
+import DropdownMenuItemCheckbox from "@excalidraw/excalidraw/components/dropdownMenu/DropdownMenuItemCheckbox";
+import React, { useState } from "react";
 
 import { isDevEnv } from "@excalidraw/common";
 
@@ -13,7 +14,29 @@ import type { Theme } from "@excalidraw/element/types";
 import { LanguageList } from "../app-language/LanguageList";
 import { isExcalidrawPlusSignedUser } from "../app_constants";
 
-import { saveDebugState } from "./DebugCanvas";
+import {
+  isVisualDebuggerEnabled,
+  loadConsoleLoggerState,
+  saveDebugState,
+  setConsoleLoggerEnabled,
+} from "./DebugCanvas";
+
+const ConsoleLoggerToggle = () => {
+  const [checked, setChecked] = useState(() => loadConsoleLoggerState());
+  return (
+    <DropdownMenuItemCheckbox
+      checked={checked}
+      onSelect={(event) => {
+        const next = !checked;
+        setChecked(next);
+        setConsoleLoggerEnabled(next);
+        event.preventDefault();
+      }}
+    >
+      Show console log overlay
+    </DropdownMenuItemCheckbox>
+  );
+};
 
 export const AppMainMenu: React.FC<{
   onCollabDialogOpen: () => any;
@@ -77,7 +100,13 @@ export const AppMainMenu: React.FC<{
         </MainMenu.Item>
       )}
       <MainMenu.Separator />
-      <MainMenu.DefaultItems.Preferences />
+      <MainMenu.DefaultItems.Preferences
+        additionalItems={
+          isDevEnv() && isVisualDebuggerEnabled() ? (
+            <ConsoleLoggerToggle />
+          ) : null
+        }
+      />
       <MainMenu.DefaultItems.ToggleTheme
         allowSystemTheme
         theme={props.theme}

excalidraw-app/components/DebugCanvas.tsx

@@ -9,7 +9,7 @@ import {
 } from "@excalidraw/excalidraw/renderer/helpers";
 import { type AppState } from "@excalidraw/excalidraw/types";
 import { arrayToMap, throttleRAF } from "@excalidraw/common";
-import { useCallback } from "react";
+import { useCallback, useEffect, useRef, useState } from "react";
 
 import {
   getGlobalFixedPointForBindableElement,
@@ -435,6 +435,34 @@ export const loadSavedDebugState = () => {
 export const isVisualDebuggerEnabled = () =>
   Array.isArray(window.visualDebug?.data);
 
+export const loadConsoleLoggerState = (): boolean => {
+  try {
+    const raw = localStorage.getItem(STORAGE_KEYS.LOCAL_STORAGE_DEBUG_CONSOLE);
+    if (raw !== null) {
+      return JSON.parse(raw) === true;
+    }
+  } catch {}
+  return false;
+};
+
+export const saveConsoleLoggerState = (enabled: boolean) => {
+  try {
+    localStorage.setItem(
+      STORAGE_KEYS.LOCAL_STORAGE_DEBUG_CONSOLE,
+      JSON.stringify(enabled),
+    );
+  } catch {}
+};
+
+const CONSOLE_LOGGER_TOGGLE_EVENT = "excalidraw-debug-console-toggle";
+
+export const setConsoleLoggerEnabled = (enabled: boolean) => {
+  saveConsoleLoggerState(enabled);
+  window.dispatchEvent(
+    new CustomEvent<boolean>(CONSOLE_LOGGER_TOGGLE_EVENT, { detail: enabled }),
+  );
+};
+
 export const DebugFooter = ({ onChange }: { onChange: () => void }) => {
   const moveForward = useCallback(() => {
     if (
@@ -459,6 +487,7 @@ export const DebugFooter = ({ onChange }: { onChange: () => void }) => {
   }, [onChange]);
   const reset = useCallback(() => {
     window.visualDebug!.currentFrame = undefined;
+    _clearLogsCallback?.();
     onChange();
   }, [onChange]);
   const trashFrames = useCallback(() => {
@@ -466,6 +495,7 @@ export const DebugFooter = ({ onChange }: { onChange: () => void }) => {
       window.visualDebug.currentFrame = undefined;
       window.visualDebug.data = [];
     }
+    _clearLogsCallback?.();
     onChange();
   }, [onChange]);
 
@@ -563,4 +593,181 @@ const DebugCanvas = React.forwardRef<HTMLCanvasElement, DebugCanvasProps>(
   },
 );
 
+type LogLevel = "log" | "info" | "warn" | "error";
+
+interface LogEntry {
+  id: number;
+  level: LogLevel;
+  message: string;
+  timestamp: number;
+}
+
+const LOG_COLORS: Record<LogLevel, string> = {
+  log: "rgba(220,220,220,0.9)",
+  info: "rgba(100,180,255,0.9)",
+  warn: "rgba(255,200,60,0.9)",
+  error: "rgba(255,90,90,0.9)",
+};
+
+const MAX_LOGS = 500;
+let logIdCounter = 0;
+let _clearLogsCallback: (() => void) | null = null;
+
+export const ConsoleLogger = () => {
+  const [enabled, setEnabled] = useState(() => loadConsoleLoggerState());
+  const [logs, setLogs] = useState<LogEntry[]>([]);
+  const logsRef = useRef<LogEntry[]>([]);
+  const scrollRef = useRef<HTMLDivElement>(null);
+  const dragState = useRef<{ startY: number; startScrollTop: number } | null>(
+    null,
+  );
+  const isDragging = useRef(false);
+
+  useEffect(() => {
+    const handler = (e: Event) => {
+      setEnabled((e as CustomEvent<boolean>).detail);
+    };
+    window.addEventListener(CONSOLE_LOGGER_TOGGLE_EVENT, handler);
+    return () => {
+      window.removeEventListener(CONSOLE_LOGGER_TOGGLE_EVENT, handler);
+    };
+  }, []);
+
+  useEffect(() => {
+    _clearLogsCallback = () => {
+      logsRef.current = [];
+      setLogs([]);
+    };
+    return () => {
+      _clearLogsCallback = null;
+    };
+  }, []);
+
+  useEffect(() => {
+    const originals: Record<LogLevel, (...args: unknown[]) => void> = {
+      // eslint-disable-next-line no-console
+      log: console.log.bind(console),
+      info: console.info.bind(console),
+      warn: console.warn.bind(console),
+      error: console.error.bind(console),
+    };
+
+    const patch = (level: LogLevel) => {
+      // eslint-disable-next-line no-console
+      console[level] = (...args: unknown[]) => {
+        originals[level](...args);
+        const message = args
+          .map((a) =>
+            typeof a === "object" ? JSON.stringify(a, null, 0) : String(a),
+          )
+          .join(" ");
+        const entry: LogEntry = {
+          id: ++logIdCounter,
+          level,
+          message,
+          timestamp: Date.now(),
+        };
+        logsRef.current = [...logsRef.current, entry].slice(-MAX_LOGS);
+        setLogs([...logsRef.current]);
+        if (!isDragging.current && scrollRef.current) {
+          scrollRef.current.scrollTop = scrollRef.current.scrollHeight;
+        }
+      };
+    };
+
+    (["log", "info", "warn", "error"] as LogLevel[]).forEach(patch);
+
+    return () => {
+      (["log", "info", "warn", "error"] as LogLevel[]).forEach((level) => {
+        // eslint-disable-next-line no-console
+        console[level] = originals[level];
+      });
+    };
+  }, []);
+
+  const onPointerDown = useCallback((e: React.PointerEvent<HTMLDivElement>) => {
+    if (!scrollRef.current) {
+      return;
+    }
+    dragState.current = {
+      startY: e.clientY,
+      startScrollTop: scrollRef.current.scrollTop,
+    };
+    scrollRef.current.setPointerCapture(e.pointerId);
+    isDragging.current = true;
+    e.preventDefault();
+  }, []);
+
+  const onPointerMove = useCallback((e: React.PointerEvent<HTMLDivElement>) => {
+    if (!dragState.current || !scrollRef.current) {
+      return;
+    }
+    const delta = dragState.current.startY - e.clientY;
+    scrollRef.current.scrollTop = dragState.current.startScrollTop + delta;
+    e.preventDefault();
+  }, []);
+
+  const onPointerUp = useCallback(() => {
+    dragState.current = null;
+    isDragging.current = false;
+  }, []);
+
+  if (!enabled || logs.length === 0) {
+    return null;
+  }
+
+  return (
+    <div
+      ref={scrollRef}
+      onPointerDown={onPointerDown}
+      onPointerMove={onPointerMove}
+      onPointerUp={onPointerUp}
+      onPointerCancel={onPointerUp}
+      style={{
+        position: "fixed",
+        top: 8,
+        right: 8,
+        zIndex: 9999,
+        maxWidth: 420,
+        maxHeight: "60vh",
+        overflowY: "auto",
+        display: "flex",
+        flexDirection: "column",
+        gap: 2,
+        pointerEvents: "all",
+        cursor: "grab",
+        userSelect: "none",
+        scrollbarWidth: "none",
+      }}
+    >
+      {logs.map((entry) => (
+        <div
+          key={entry.id}
+          style={{
+            background: "rgba(18,18,20,0.55)",
+            backdropFilter: "blur(8px) saturate(1.4)",
+            WebkitBackdropFilter: "blur(8px) saturate(1.4)",
+            borderLeft: `3px solid ${LOG_COLORS[entry.level]}`,
+            borderRadius: 4,
+            padding: "2px 8px",
+            fontFamily: "monospace",
+            fontSize: 11,
+            lineHeight: 1.5,
+            color: LOG_COLORS[entry.level],
+            wordBreak: "break-all",
+            whiteSpace: "pre-wrap",
+            opacity: 0.95,
+            boxShadow: "0 1px 4px rgba(0,0,0,0.35)",
+          }}
+        >
+          <span style={{ opacity: 0.5, marginRight: 6 }}>
+            {entry.level.toUpperCase()}
+          </span>
+          {entry.message}
+        </div>
+      ))}
+    </div>
+  );
+};
+
 export default DebugCanvas;

packages/common/src/colors.ts

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

packages/common/src/constants.ts

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

packages/element/src/index.ts

@@ -81,6 +81,7 @@ export * from "./mutateElement";
 export * from "./newElement";
 export * from "./positionElementsOnGrid";
 export * from "./renderElement";
+export { invalidateFreeDrawIncrementalCanvas } from "./renderFreedraw";
 export * from "./resizeElements";
 export * from "./resizeTest";
 export * from "./Scene";

packages/element/src/renderElement.ts

@@ -65,8 +65,12 @@ import {
 } from "./typeChecks";
 import { getContainingFrame } from "./frame";
 import { getCornerRadius } from "./utils";
-
 import { ShapeCache } from "./shape";
+import {
+  drawFreeDrawSegments,
+  generateOrUpdateFreeDrawIncrementalCanvas,
+  getFreedrawCanvasPadding,
+} from "./renderFreedraw";
 
 import type {
   ExcalidrawElement,
@@ -92,7 +96,7 @@ const isPendingImageElement = (
 const getCanvasPadding = (element: ExcalidrawElement) => {
   switch (element.type) {
     case "freedraw":
-      return element.strokeWidth * 12;
+      return getFreedrawCanvasPadding(element);
     case "text":
       return element.fontSize / 2;
     case "arrow":
@@ -144,6 +148,15 @@ export interface ExcalidrawElementWithCanvas {
   imageCrop: ExcalidrawImageElement["crop"] | null;
   containingFrameOpacity: number;
   boundTextCanvas: HTMLCanvasElement;
+  canvasOriginSceneX?: number;
+  canvasOriginSceneY?: number;
+  /**
+   * Tip canvas for incremental freedraw rendering.  Contains only the last
+   * unfinalised segment (whose Catmull-Rom right-hand tangent changes with
+   * each new point) and is cleared + redrawn every frame.  Composited on top
+   * of `canvas` (the committed accumulation canvas) in drawElementFromCanvas.
+   */
+  tipCanvas?: HTMLCanvasElement;
 }
 
 const cappedElementCanvasSize = (
@@ -253,7 +266,7 @@ const generateElementCanvas = (
 
   const rc = rough.canvas(canvas);
 
-  drawElementOnCanvas(element, rc, context, renderConfig);
+  drawElementOnCanvas(element, rc, context, renderConfig, scale);
 
   context.restore();
 
@@ -389,6 +402,7 @@ const drawElementOnCanvas = (
   rc: RoughCanvas,
   context: CanvasRenderingContext2D,
   renderConfig: StaticCanvasRenderConfig,
+  scale = 1,
 ) => {
   switch (element.type) {
     case "rectangle":
@@ -415,23 +429,8 @@ const drawElementOnCanvas = (
       break;
     }
     case "freedraw": {
-      // Draw directly to canvas
       context.save();
-
+      drawFreeDrawSegments(element, context, renderConfig, 0, undefined, scale);
-      const shapes = ShapeCache.generateElementShape(element, renderConfig);
-
-      for (const shape of shapes) {
-        if (typeof shape === "string") {
-          context.fillStyle =
-            renderConfig.theme === THEME.DARK
-              ? applyDarkModeFilter(element.strokeColor)
-              : element.strokeColor;
-          context.fill(new Path2D(shape));
-        } else {
-          rc.draw(shape);
-        }
-      }
-
       context.restore();
       break;
     }
@@ -555,10 +554,10 @@ const drawElementOnCanvas = (
         context.canvas.setAttribute("dir", rtl ? "rtl" : "ltr");
         context.save();
         context.font = getFontString(element);
-        context.fillStyle =
+        context.fillStyle = applyDarkModeFilter(
-          renderConfig.theme === THEME.DARK
+          element.strokeColor,
-            ? applyDarkModeFilter(element.strokeColor)
+          renderConfig.theme === THEME.DARK,
-            : element.strokeColor;
+        );
         context.textAlign = element.textAlign as CanvasTextAlign;
 
         // Canvas does not support multiline text by default
@@ -616,6 +615,24 @@ const generateElementWithCanvas = (
     : {
         value: 1 as NormalizedZoomValue,
       };
+
+  // Incremental rendering path for freedraw elements being actively drawn.
+  // ShapeCache.delete() clears elementWithCanvasCache on every added point, so
+  // we bypass that cache entirely and use freedrawIncrementalCache instead.
+  if (
+    isFreeDrawElement(element) &&
+    "newElement" in appState &&
+    appState.newElement?.id === element.id
+  ) {
+    return generateOrUpdateFreeDrawIncrementalCanvas(
+      element as ExcalidrawFreeDrawElement,
+      elementsMap,
+      zoom,
+      renderConfig,
+      appState,
+    );
+  }
+
   const prevElementWithCanvas = elementWithCanvasCache.get(element);
   const shouldRegenerateBecauseZoom =
     prevElementWithCanvas &&
@@ -718,16 +735,39 @@ const drawElementFromCanvas = (
     // revert afterwards we don't have account for it during drawing
     context.translate(-cx, -cy);
 
+    // For the incremental freedraw path, the canvas origin is stored explicitly
+    // because the canvas is over-allocated beyond the tight element bounds.
+    const destX =
+      elementWithCanvas.canvasOriginSceneX !== undefined
+        ? (elementWithCanvas.canvasOriginSceneX + appState.scrollX) *
+          window.devicePixelRatio
+        : (x1 + appState.scrollX) * window.devicePixelRatio - padding;
+    const destY =
+      elementWithCanvas.canvasOriginSceneY !== undefined
+        ? (elementWithCanvas.canvasOriginSceneY + appState.scrollY) *
+          window.devicePixelRatio
+        : (y1 + appState.scrollY) * window.devicePixelRatio - padding;
     context.drawImage(
       elementWithCanvas.canvas!,
-      (x1 + appState.scrollX) * window.devicePixelRatio -
+      destX,
-        (padding * elementWithCanvas.scale) / elementWithCanvas.scale,
+      destY,
-      (y1 + appState.scrollY) * window.devicePixelRatio -
-        (padding * elementWithCanvas.scale) / elementWithCanvas.scale,
       elementWithCanvas.canvas!.width / elementWithCanvas.scale,
       elementWithCanvas.canvas!.height / elementWithCanvas.scale,
     );
 
+    // Composite the tip canvas (incremental freedraw path) on top.  It is
+    // the same size and at the same scene origin as the committed canvas, so
+    // it uses identical destX / destY / dimensions.
+    if (elementWithCanvas.tipCanvas) {
+      context.drawImage(
+        elementWithCanvas.tipCanvas,
+        destX,
+        destY,
+        elementWithCanvas.tipCanvas.width / elementWithCanvas.scale,
+        elementWithCanvas.tipCanvas.height / elementWithCanvas.scale,
+      );
+    }
+
     if (
       import.meta.env.VITE_APP_DEBUG_ENABLE_TEXT_CONTAINER_BOUNDING_BOX ===
         "true" &&
@@ -811,10 +851,10 @@ export const renderElement = (
         context.fillStyle = "rgba(0, 0, 200, 0.04)";
 
         context.lineWidth = FRAME_STYLE.strokeWidth / appState.zoom.value;
-        context.strokeStyle =
+        context.strokeStyle = applyDarkModeFilter(
-          appState.theme === THEME.DARK
+          FRAME_STYLE.strokeColor,
-            ? applyDarkModeFilter(FRAME_STYLE.strokeColor)
+          appState.theme === THEME.DARK,
-            : FRAME_STYLE.strokeColor;
+        );
 
         // TODO change later to only affect AI frames
         if (isMagicFrameElement(element)) {
@@ -867,6 +907,14 @@ export const renderElement = (
           return;
         }
 
+        const currentImageSmoothingStatus = context.imageSmoothingEnabled;
+        if (
+          !appState?.shouldCacheIgnoreZoom &&
+          (!element.angle || isRightAngleRads(element.angle))
+        ) {
+          context.imageSmoothingEnabled = false;
+        }
+
         drawElementFromCanvas(
           elementWithCanvas,
           context,
@@ -874,6 +922,8 @@ export const renderElement = (
           appState,
           allElementsMap,
         );
+
+        context.imageSmoothingEnabled = currentImageSmoothingStatus;
       }
 
       break;
@@ -983,7 +1033,7 @@ export const renderElement = (
         }
 
         context.restore();
-        // not exporting → optimized rendering (cache & render from element
+        // not exporting -> optimized rendering (cache & render from element
         // canvases)
       } else {
         const elementWithCanvas = generateElementWithCanvas(

packages/element/src/renderFreedraw.ts

@@ -0,0 +1,549 @@
+import { applyDarkModeFilter, THEME } from "@excalidraw/common";
+
+import type { StaticCanvasRenderConfig } from "@excalidraw/excalidraw/scene/types";
+
+import type {
+  AppState,
+  InteractiveCanvasAppState,
+  StaticCanvasAppState,
+  Zoom,
+} from "@excalidraw/excalidraw/types";
+
+import { getElementAbsoluteCoords } from "./bounds";
+import { getContainingFrame } from "./frame";
+
+import type { ExcalidrawElementWithCanvas } from "./renderElement";
+import type {
+  ExcalidrawFreeDrawElement,
+  NonDeletedSceneElementsMap,
+} from "./types";
+
+const DEFAULT_FREEDRAW_PRESSURE = 0.5;
+
+/**
+ * Half-width (in samples) of the triangular smoothing kernel applied to raw
+ * pressure values before computing stroke radii.  A radius of R means each
+ * pressure sample is averaged with R neighbours on each side, weighted
+ * linearly so the centre sample has weight R+1 and the outermost weight 1.
+ * Larger values produce a smoother, more uniform stroke width.
+ */
+const PRESSURE_SMOOTHING_RADIUS = 6;
+
+/**
+ * Draws a single stroke segment primitive for the triplet (pPrev, pCur, pNext).
+ *
+ * The primitive is a closed quadrilateral with curved top and bottom edges:
+ *   A        = midpoint(pPrev, pCur)  — left junction, shared with the previous primitive
+ *   B        = midpoint(pCur, pNext)  — right junction, shared with the next primitive
+ *   M'1/M'2  at A:    ±rA perpendicular to the pPrev→pCur direction
+ *   M1/M2    at pCur: ±rCur along the bisector normal of the two edge directions
+ *   M''1/M''2 at B:   ±rB perpendicular to the pCur→pNext direction
+ *
+ * Shape boundary (clockwise):
+ *   M'1 →[quadratic Bezier through M1]→ M''1 →[line]→ M''2
+ *       →[quadratic Bezier through M2]→  M'2  →[line]→  M'1
+ *
+ * Adjacent primitives share their junction points so the stroke outline is
+ * geometrically continuous with no gaps or overlaps.
+ */
+const drawStrokeSegment = (
+  context: CanvasRenderingContext2D,
+  pPrevX: number,
+  pPrevY: number,
+  rPrev: number,
+  pCurX: number,
+  pCurY: number,
+  rCur: number,
+  pNextX: number,
+  pNextY: number,
+  rNext: number,
+) => {
+  // A = midpoint(pPrev, pCur), B = midpoint(pCur, pNext)
+  const ax = (pPrevX + pCurX) * 0.5;
+  const ay = (pPrevY + pCurY) * 0.5;
+  const rA = (rPrev + rCur) * 0.5;
+  const bx = (pCurX + pNextX) * 0.5;
+  const by = (pCurY + pNextY) * 0.5;
+  const rB = (rCur + rNext) * 0.5;
+
+  // Perpendicular unit vector at A (normal to pPrev→pCur)
+  const daX = pCurX - pPrevX;
+  const daY = pCurY - pPrevY;
+  const daLenInv = 1 / (Math.sqrt(daX * daX + daY * daY) || 1e-10);
+  const nAX = -daY * daLenInv;
+  const nAY = daX * daLenInv;
+
+  // Perpendicular unit vector at B (normal to pCur→pNext)
+  const dbX = pNextX - pCurX;
+  const dbY = pNextY - pCurY;
+  const dbLenInv = 1 / (Math.sqrt(dbX * dbX + dbY * dbY) || 1e-10);
+  const nBX = -dbY * dbLenInv;
+  const nBY = dbX * dbLenInv;
+
+  // Bisector normal at pCur: normalised average of nA and nB
+  const bisRawX = nAX + nBX;
+  const bisRawY = nAY + nBY;
+  const bisLen = Math.sqrt(bisRawX * bisRawX + bisRawY * bisRawY);
+  const bisNX = bisLen > 1e-10 ? bisRawX / bisLen : nAX;
+  const bisNY = bisLen > 1e-10 ? bisRawY / bisLen : nAY;
+
+  // M'1, M'2 at A
+  const mp1x = ax + nAX * rA;
+  const mp1y = ay + nAY * rA;
+  const mp2x = ax - nAX * rA;
+  const mp2y = ay - nAY * rA;
+
+  // M1, M2 at pCur — used directly as the quadratic Bézier control points.
+  // The junction points (M'1, M''1, etc.) are midpoints between consecutive
+  // control points, which is the classic midpoint quadratic B-spline scheme.
+  // This guarantees C1 continuity: the shared junction is always the midpoint
+  // of the two flanking CPs, so the tangent is continuous across segments.
+  const m1x = pCurX + bisNX * rCur;
+  const m1y = pCurY + bisNY * rCur;
+  const m2x = pCurX - bisNX * rCur;
+  const m2y = pCurY - bisNY * rCur;
+
+  // M''1, M''2 at B
+  const mpp1x = bx + nBX * rB;
+  const mpp1y = by + nBY * rB;
+  const mpp2x = bx - nBX * rB;
+  const mpp2y = by - nBY * rB;
+
+  context.beginPath();
+  context.moveTo(mp1x, mp1y);
+  // Top edge: M'1 → M''1, control point = M1 (bisector offset at pCur)
+  context.quadraticCurveTo(m1x, m1y, mpp1x, mpp1y);
+  // Right cap: M''1 → M''2
+  context.lineTo(mpp2x, mpp2y);
+  // Bottom edge: M''2 → M'2, control point = M2
+  context.quadraticCurveTo(m2x, m2y, mp2x, mp2y);
+  // Left cap: M'2 → M'1
+  context.closePath();
+  context.fill();
+
+  // Filled circles at the junction midpoints seal any sub-pixel anti-aliasing
+  // gap where adjacent segment fills share a boundary edge.
+  context.beginPath();
+  context.arc(ax, ay, rA, 0, Math.PI * 2);
+  context.fill();
+  context.beginPath();
+  context.arc(bx, by, rB, 0, Math.PI * 2);
+  context.fill();
+};
+
+/**
+ * Draws freedraw points as pressure-aware curved stroke segment primitives.
+ * For each consecutive triplet of points (i-1, i, i+1) a curved quadrilateral
+ * is drawn whose side edges sit at the midpoints of the consecutive point pairs
+ * and whose top/bottom edges are quadratic Bezier curves passing through the
+ * stroke-width offset at the centre point.  Adjacent primitives share their
+ * side-edge positions, so the rendered outline is continuous with no gaps.
+ *
+ * @param fromIndex   Draw segments starting from this point index (inclusive).
+ *                    Pass 0 to draw from the beginning.
+ * @param upToIndex   Draw segments only up to (but not including) this point
+ *                    index.  Omit or pass `undefined` to draw all remaining
+ *                    points.  Used by the incremental canvas to stop short of
+ *                    the last segment so the committed canvas only contains
+ *                    segments whose geometry is fully determined by immutable
+ *                    points.
+ */
+export const drawFreeDrawSegments = (
+  element: ExcalidrawFreeDrawElement,
+  context: CanvasRenderingContext2D,
+  renderConfig: StaticCanvasRenderConfig,
+  fromIndex: number,
+  upToIndex?: number,
+  scale = 1,
+) => {
+  const { points, pressures } = element;
+  const N = points.length;
+  const strokeColor =
+    renderConfig.theme === THEME.DARK
+      ? applyDarkModeFilter(element.strokeColor)
+      : element.strokeColor;
+
+  context.fillStyle = applyDarkModeFilter(
+    strokeColor,
+    renderConfig.theme === THEME.DARK,
+  );
+
+  const baseRadius = (element.strokeWidth * 1.25) / 2;
+
+  // Causal (one-sided) triangular-kernel weighted average of past pressure
+  // samples.  Only looks backward [i-R .. i], so a newly-arrived point never
+  // retroactively changes the smoothed pressure of any previously rendered
+  // segment.  This ensures live and final renders are identical at all points.
+  // When simulatePressure is true, constant pressure is used for all points.
+  const getSmoothedPressure = (i: number): number => {
+    if (element.simulatePressure || pressures.length === 0) {
+      return DEFAULT_FREEDRAW_PRESSURE;
+    }
+    let sum = 0;
+    let totalWeight = 0;
+    for (let k = -PRESSURE_SMOOTHING_RADIUS; k <= 0; k++) {
+      const idx = i + k;
+      if (idx < 0) {
+        continue;
+      }
+      const p =
+        idx < pressures.length ? pressures[idx] : DEFAULT_FREEDRAW_PRESSURE;
+      const w = PRESSURE_SMOOTHING_RADIUS + 1 + k; // 1 at i-R, R+1 at i
+      sum += p * w;
+      totalWeight += w;
+    }
+    return totalWeight > 0 ? sum / totalWeight : DEFAULT_FREEDRAW_PRESSURE;
+  };
+
+  if (
+    fromIndex === 0 &&
+    N === 1 &&
+    (upToIndex === undefined || upToIndex >= 1)
+  ) {
+    // Single-point stroke -> filled circle (dot)
+    const r = baseRadius * getSmoothedPressure(0) * 2;
+    context.beginPath();
+    context.arc(points[0][0], points[0][1], r, 0, Math.PI * 2);
+    context.fill();
+
+    return;
+  }
+
+  const end = upToIndex !== undefined ? Math.min(upToIndex, N) : N;
+  const start = Math.max(fromIndex, 1);
+  for (let i = start; i < end; i++) {
+    const p0 = points[i - 1];
+    const p1 = points[i];
+    const r0 = baseRadius * getSmoothedPressure(i - 1) * 2;
+    const r1 = baseRadius * getSmoothedPressure(i) * 2;
+
+    // Triplet: need i+1; if at the last point, mirror i-1 around i (degenerate tip).
+    let p2x: number;
+    let p2y: number;
+    let r2: number;
+    if (i < N - 1) {
+      p2x = points[i + 1][0];
+      p2y = points[i + 1][1];
+      r2 = baseRadius * getSmoothedPressure(i + 1) * 2;
+    } else {
+      p2x = 2 * p1[0] - p0[0];
+      p2y = 2 * p1[1] - p0[1];
+      r2 = r0;
+    }
+
+    drawStrokeSegment(
+      context,
+      p0[0],
+      p0[1],
+      r0,
+      p1[0],
+      p1[1],
+      r1,
+      p2x,
+      p2y,
+      r2,
+    );
+  }
+};
+
+// ─── Incremental freedraw canvas cache ───────────────────────────────────────
+// A separate WeakMap that survives ShapeCache.delete() calls so that the raster
+// accumulates new capsule segments without full regeneration on every added
+// point.
+
+// screen pixels - minimum extra lookahead space on each side
+// (divided by scale at use)
+const FREEDRAW_CANVAS_OVERSHOOT_MIN = 200;
+
+// allocate current_dimension * factor extra on each side
+const FREEDRAW_CANVAS_OVERSHOOT_FACTOR = 0.5;
+
+interface FreeDrawIncrementalCanvas {
+  /**
+   * Accumulation canvas - contains all segments whose Catmull-Rom tangents are
+   * fully finalised (right-hand neighbour is known).  With N points the last
+   * finalised segment ends at index `committedPointCount - 1`, meaning segment
+   * `[committedPointCount-2 -> committedPointCount-1]` has been drawn with the
+   * correct tangent at `committedPointCount-1` (since point
+   * `committedPointCount` existed when it was drawn).  Never cleared; only
+   * appended to (or copied when bounds grow).
+   */
+  committedCanvas: HTMLCanvasElement;
+  /**
+   * Tip canvas - same pixel dimensions and scene origin as `committedCanvas`.
+   * Cleared and redrawn every frame to contain only the last segment
+   * `[committedPointCount-1 -> N-1]` whose tangent at `N-1` is still
+   * provisional (no right-hand neighbour yet).  Composited on top of
+   * `committedCanvas` at display time.
+   */
+  tipCanvas: HTMLCanvasElement;
+  /**
+   * Number of points that have been permanently drawn on `committedCanvas`.
+   * The committed canvas contains segments through point index
+   * `committedPointCount - 1` with final tangents.  Always lags the current
+   * point count by 1 (the tip holds the last unfinalisable segment).
+   */
+  committedPointCount: number;
+  canvasOriginSceneX: number;
+  canvasOriginSceneY: number;
+  canvasAllocX1: number;
+  canvasAllocY1: number;
+  canvasAllocX2: number;
+  canvasAllocY2: number;
+  scale: number;
+  theme: AppState["theme"];
+}
+
+const freedrawIncrementalCache = new WeakMap<
+  ExcalidrawFreeDrawElement,
+  FreeDrawIncrementalCanvas
+>();
+
+export const getFreedrawCanvasPadding = (element: ExcalidrawFreeDrawElement) =>
+  element.strokeWidth * 12;
+
+/**
+ * Generates or incrementally updates the two-canvas (committed + tip) raster
+ * for a freedraw element being actively drawn.
+ *
+ * ## Two-canvas split
+ *
+ * A Catmull-Rom tangent at point `i` depends on `points[i+1]`.  Until
+ * `points[i+1]` arrives, the tangent at `i` uses a mirrored fallback and is
+ * therefore provisional.  The segment ending at the current tip `[N-2 -> N-1]`
+ * is the only one with a provisional tangent.
+ *
+ * - **`committedCanvas`** - contains all segments whose tangents are final.
+ *   With N points: segments `[0->1, ..., N-3->N-2]` (`committedPointCount =
+ *   N-1`).  This canvas is append-only; its pixels are never invalidated.
+ *   When a new point `N` arrives, the segment `[N-2 -> N-1]` is now
+ *   finalised (tangent at `N-1` uses `N` as the right-hand neighbour) and is
+ *   drawn onto the committed canvas.  `committedPointCount` advances to `N`.
+ *
+ * - **`tipCanvas`** - cleared and redrawn every frame to contain only the
+ *   last provisional segment `[committedPointCount-1 -> N-1]`.  Composited on
+ *   top of `committedCanvas` at display time.
+ */
+export const generateOrUpdateFreeDrawIncrementalCanvas = (
+  element: ExcalidrawFreeDrawElement,
+  elementsMap: NonDeletedSceneElementsMap,
+  zoom: Zoom,
+  renderConfig: StaticCanvasRenderConfig,
+  appState: StaticCanvasAppState | InteractiveCanvasAppState,
+): ExcalidrawElementWithCanvas | null => {
+  const scale = zoom.value;
+  const dpr = window.devicePixelRatio;
+  const padding = getFreedrawCanvasPadding(element);
+  const [x1, y1, x2, y2] = getElementAbsoluteCoords(element, elementsMap);
+  const containingFrameOpacity =
+    getContainingFrame(element, elementsMap)?.opacity || 100;
+  const N = element.points.length;
+
+  const prevInc = freedrawIncrementalCache.get(element);
+
+  const boundsExceeded =
+    prevInc !== undefined &&
+    (x1 < prevInc.canvasAllocX1 ||
+      y1 < prevInc.canvasAllocY1 ||
+      x2 > prevInc.canvasAllocX2 ||
+      y2 > prevInc.canvasAllocY2);
+
+  const needsAlloc =
+    prevInc === undefined ||
+    boundsExceeded ||
+    prevInc.scale !== scale ||
+    prevInc.theme !== appState.theme;
+
+  // ── Canvas allocation / reallocation ──────────────────────────────────────
+  let committedCanvas: HTMLCanvasElement;
+  let tipCanvas: HTMLCanvasElement;
+  let canvasOriginSceneX: number;
+  let canvasOriginSceneY: number;
+  let canvasScale: number;
+  // How many points to start the committed-canvas update from.  On a full
+  // regen this is 0; on a bounds-exceeded realloc it is the existing committed
+  // count so we only append the new segments.
+  let committedFromIndex: number;
+
+  if (needsAlloc) {
+    // Over-allocate proportionally to the current bounding box so fast large
+    // strokes trigger far fewer reallocations.
+    const overshootX = Math.max(
+      FREEDRAW_CANVAS_OVERSHOOT_MIN / scale,
+      (x2 - x1) * FREEDRAW_CANVAS_OVERSHOOT_FACTOR,
+    );
+    const overshootY = Math.max(
+      FREEDRAW_CANVAS_OVERSHOOT_MIN / scale,
+      (y2 - y1) * FREEDRAW_CANVAS_OVERSHOOT_FACTOR,
+    );
+    const allocX1 = x1 - overshootX;
+    const allocY1 = y1 - overshootY;
+    const allocX2 = x2 + overshootX;
+    const allocY2 = y2 + overshootY;
+
+    canvasOriginSceneX = allocX1 - padding / dpr;
+    canvasOriginSceneY = allocY1 - padding / dpr;
+
+    const rawW = (allocX2 - allocX1) * dpr + padding * 2;
+    const rawH = (allocY2 - allocY1) * dpr + padding * 2;
+
+    // Respect browser canvas size limits.
+    const AREA_LIMIT = 16777216;
+    const WIDTH_HEIGHT_LIMIT = 32767;
+    canvasScale = scale;
+    if (
+      rawW * canvasScale > WIDTH_HEIGHT_LIMIT ||
+      rawH * canvasScale > WIDTH_HEIGHT_LIMIT
+    ) {
+      canvasScale = Math.min(
+        WIDTH_HEIGHT_LIMIT / rawW,
+        WIDTH_HEIGHT_LIMIT / rawH,
+      );
+    }
+    if (rawW * rawH * canvasScale * canvasScale > AREA_LIMIT) {
+      canvasScale = Math.sqrt(AREA_LIMIT / (rawW * rawH));
+    }
+
+    const canvasWidth = Math.floor(rawW * canvasScale);
+    const canvasHeight = Math.floor(rawH * canvasScale);
+    if (!canvasWidth || !canvasHeight) {
+      return null;
+    }
+
+    committedCanvas = document.createElement("canvas");
+    committedCanvas.width = canvasWidth;
+    committedCanvas.height = canvasHeight;
+
+    tipCanvas = document.createElement("canvas");
+    tipCanvas.width = canvasWidth;
+    tipCanvas.height = canvasHeight;
+
+    if (
+      prevInc !== undefined &&
+      boundsExceeded &&
+      prevInc.scale === canvasScale &&
+      prevInc.theme === appState.theme
+    ) {
+      // Bounds grew: copy committed raster to new canvas at the correct offset
+      // and keep accumulating.  Tip will be redrawn below.
+      const copyX =
+        (prevInc.canvasOriginSceneX - canvasOriginSceneX) * dpr * canvasScale;
+      const copyY =
+        (prevInc.canvasOriginSceneY - canvasOriginSceneY) * dpr * canvasScale;
+      committedCanvas
+        .getContext("2d")!
+        .drawImage(prevInc.committedCanvas, copyX, copyY);
+      committedFromIndex = prevInc.committedPointCount;
+    } else {
+      // Full regeneration: zoom/theme change or first frame.
+      committedFromIndex = 0;
+    }
+
+    freedrawIncrementalCache.set(element, {
+      committedCanvas,
+      tipCanvas,
+      committedPointCount: committedFromIndex,
+      canvasOriginSceneX,
+      canvasOriginSceneY,
+      canvasAllocX1: allocX1,
+      canvasAllocY1: allocY1,
+      canvasAllocX2: allocX2,
+      canvasAllocY2: allocY2,
+      scale: canvasScale,
+      theme: appState.theme,
+    });
+  } else {
+    committedCanvas = prevInc.committedCanvas;
+    tipCanvas = prevInc.tipCanvas;
+    canvasOriginSceneX = prevInc.canvasOriginSceneX;
+    canvasOriginSceneY = prevInc.canvasOriginSceneY;
+    canvasScale = prevInc.scale;
+    committedFromIndex = prevInc.committedPointCount;
+  }
+
+  const inc = freedrawIncrementalCache.get(element)!;
+
+  // ── Helper: draw onto a canvas with the element's scene->pixel transform ──
+  const withElementContext = (
+    target: HTMLCanvasElement,
+    fn: (ctx: CanvasRenderingContext2D) => void,
+  ) => {
+    const ctx = target.getContext("2d")!;
+    const offsetX = (element.x - canvasOriginSceneX) * dpr * canvasScale;
+    const offsetY = (element.y - canvasOriginSceneY) * dpr * canvasScale;
+    ctx.save();
+    ctx.translate(offsetX, offsetY);
+    ctx.scale(dpr * canvasScale, dpr * canvasScale);
+    fn(ctx);
+    ctx.restore();
+  };
+
+  // ── Update committed canvas ───────────────────────────────────────────────
+  // With N points the last finalisable segment ends at N-2 (needs N-1 as
+  // right-hand neighbour for the tangent at N-2, and N-1 is always present).
+  // We draw from `committedFromIndex` up to (but not including) point N-1,
+  // so the committed canvas contains segments [0->1, ..., N-3->N-2].
+  const newCommittedCount = Math.max(1, N - 1);
+  if (committedFromIndex < newCommittedCount) {
+    withElementContext(committedCanvas, (ctx) => {
+      drawFreeDrawSegments(
+        element,
+        ctx,
+        renderConfig,
+        committedFromIndex,
+        newCommittedCount, // upToIndex - stop before the last provisional segment
+        canvasScale,
+      );
+    });
+    inc.committedPointCount = newCommittedCount;
+  }
+
+  // ── Redraw tip canvas ─────────────────────────────────────────────────────
+  // Always cleared and redrawn: contains the single provisional segment
+  // [committedPointCount-1 -> N-1] with a predicted-point ghost if available.
+  withElementContext(tipCanvas, (ctx) => {
+    ctx.clearRect(
+      -(element.x - canvasOriginSceneX),
+      -(element.y - canvasOriginSceneY),
+      tipCanvas.width / (dpr * canvasScale),
+      tipCanvas.height / (dpr * canvasScale),
+    );
+    drawFreeDrawSegments(
+      element,
+      ctx,
+      renderConfig,
+      inc.committedPointCount,
+      undefined, // draw to natural end (the tip segment)
+      canvasScale,
+    );
+  });
+
+  return {
+    element,
+    canvas: committedCanvas,
+    tipCanvas,
+    theme: appState.theme,
+    scale: canvasScale,
+    angle: element.angle,
+    zoomValue: zoom.value,
+    canvasOffsetX: 0,
+    canvasOffsetY: 0,
+    boundTextElementVersion: null,
+    imageCrop: null,
+    containingFrameOpacity,
+    boundTextCanvas: document.createElement("canvas"),
+    canvasOriginSceneX: inc.canvasOriginSceneX,
+    canvasOriginSceneY: inc.canvasOriginSceneY,
+  };
+};
+
+/**
+ * Removes the incremental freedraw canvas for the given element.
+ * Call this when a freedraw stroke is finalised so the next render
+ * produces a fresh tight-bounds canvas instead of the over-allocated one.
+ */
+export const invalidateFreeDrawIncrementalCanvas = (
+  element: ExcalidrawFreeDrawElement,
+) => {
+  freedrawIncrementalCache.delete(element);
+};

packages/element/src/shape.ts

@@ -1,5 +1,4 @@
 import { simplify } from "points-on-curve";
-import { getStroke } from "perfect-freehand";
 
 import {
   type GeometricShape,
@@ -28,6 +27,12 @@ import {
 
 import { RoughGenerator } from "roughjs/bin/generator";
 
+import type {
+  ElementShape,
+  ElementShapes,
+  SVGPathString,
+} from "@excalidraw/excalidraw/scene/types";
+
 import type { GlobalPoint } from "@excalidraw/math";
 
 import type { Mutable } from "@excalidraw/common/utility-types";
@@ -36,11 +41,6 @@ import type {
   AppState,
   EmbedsValidationStatus,
 } from "@excalidraw/excalidraw/types";
-import type {
-  ElementShape,
-  ElementShapes,
-  SVGPathString,
-} from "@excalidraw/excalidraw/scene/types";
 
 import { elementWithCanvasCache } from "./renderElement";
 
@@ -218,9 +218,7 @@ export const generateRoughOptions = (
     fillWeight: element.strokeWidth / 2,
     hachureGap: element.strokeWidth * 4,
     roughness: adjustRoughness(element),
-    stroke: isDarkMode
+    stroke: applyDarkModeFilter(element.strokeColor, isDarkMode),
-      ? applyDarkModeFilter(element.strokeColor)
-      : element.strokeColor,
     preserveVertices:
       continuousPath || element.roughness < ROUGHNESS.cartoonist,
   };
@@ -234,9 +232,7 @@ export const generateRoughOptions = (
       options.fillStyle = element.fillStyle;
       options.fill = isTransparent(element.backgroundColor)
         ? undefined
-        : isDarkMode
+        : applyDarkModeFilter(element.backgroundColor, isDarkMode);
-        ? applyDarkModeFilter(element.backgroundColor)
-        : element.backgroundColor;
       if (element.type === "ellipse") {
         options.curveFitting = 1;
       }
@@ -249,9 +245,7 @@ export const generateRoughOptions = (
         options.fill =
           element.backgroundColor === "transparent"
             ? undefined
-            : isDarkMode
+            : applyDarkModeFilter(element.backgroundColor, isDarkMode);
-            ? applyDarkModeFilter(element.backgroundColor)
-            : element.backgroundColor;
       }
       return options;
     }
@@ -386,12 +380,11 @@ const getArrowheadShapes = (
     return [];
   }
 
-  const strokeColor = isDarkMode
+  const strokeColor = applyDarkModeFilter(element.strokeColor, isDarkMode);
-    ? applyDarkModeFilter(element.strokeColor)
+  const backgroundFillColor = applyDarkModeFilter(
-    : element.strokeColor;
+    canvasBackgroundColor,
-  const backgroundFillColor = isDarkMode
+    isDarkMode,
-    ? applyDarkModeFilter(canvasBackgroundColor)
+  );
-    : canvasBackgroundColor;
   const cardinalityOneOrManyOffset = -0.25;
   const cardinalityZeroCircleScale = 0.8;
 
@@ -981,7 +974,7 @@ const _generateElementShape = (
       }
 
       // (2) stroke
-      shapes.push(getFreeDrawSvgPath(element));
+      shapes.push(...getFreeDrawCapsulePaths(element));
 
       return shapes;
     }
@@ -1171,64 +1164,351 @@ export const toggleLinePolygonState = (
 //                         freedraw shape helper
 // -----------------------------------------------------------------------------
 
-// NOTE not cached (-> for SVG export)
+const FREEDRAW_DEFAULT_PRESSURE = 0.5;
-const getFreeDrawSvgPath = (element: ExcalidrawFreeDrawElement) => {
+const FREEDRAW_BEZIER_SUBDIVIDE_TARGET_SPACING = 3;
-  return getSvgPathFromStroke(
+const FREEDRAW_PRESSURE_SMOOTHING_RADIUS = 6;
-    getFreedrawOutlinePoints(element),
-  ) as SVGPathString;
-};
 
-export const getFreedrawOutlinePoints = (
+// Round to 2 dp — sub-pixel accuracy at SVG 96 dpi
-  element: ExcalidrawFreeDrawElement,
+const r2 = (v: number) => Math.round(v * 100) / 100;
-) => {
-  // If input points are empty (should they ever be?) return a dot
-  const inputPoints = element.simulatePressure
-    ? element.points
-    : element.points.length
-    ? element.points.map(([x, y], i) => [x, y, element.pressures[i]])
-    : [[0, 0, 0.5]];
 
-  return getStroke(inputPoints as number[][], {
+/**
-    simulatePressure: element.simulatePressure,
+ * SVG path `d` string for a single tapered capsule. Uses clockwise arcs
-    size: element.strokeWidth * 4.25,
+ * (sweep=1) so the geometry matches the canvas 2D
-    thinning: 0.6,
+ * `arc(..., anticlockwise=false)` calls.
-    smoothing: 0.5,
+ */
-    streamline: 0.5,
+const freedrawTaperedCapsulePath = (
-    easing: (t) => Math.sin((t * Math.PI) / 2), // https://easings.net/#easeOutSine
+  x0: number,
-    last: true,
+  y0: number,
-  }) as [number, number][];
+  r0: number,
-};
+  x1: number,
+  y1: number,
+  r1: number,
+): string => {
+  const dx = x1 - x0;
+  const dy = y1 - y0;
+  const len = Math.sqrt(dx * dx + dy * dy);
+  const r = Math.max(r0, r1);
 
-const med = (A: number[], B: number[]) => {
+  if (len < r / 2) {
-  return [(A[0] + B[0]) / 2, (A[1] + B[1]) / 2];
+    // Degenerate — full circle at midpoint via two clockwise 180° arcs.
-};
+    const cx = r2((x0 + x1) / 2);
-
+    const cy = r2((y0 + y1) / 2);
-// Trim SVG path data so number are each two decimal points. This
+    const rr = r2(r);
-// improves SVG exports, and prevents rendering errors on points
+    return (
-// with long decimals.
+      `M ${(cx - rr).toFixed(2)} ${cy.toFixed(2)} ` +
-const TO_FIXED_PRECISION = /(\s?[A-Z]?,?-?[0-9]*\.[0-9]{0,2})(([0-9]|e|-)*)/g;
+      `A ${rr} ${rr} 0 1 1 ${(cx + rr).toFixed(2)} ${cy.toFixed(2)} ` +
-
+      `A ${rr} ${rr} 0 1 1 ${(cx - rr).toFixed(2)} ${cy.toFixed(2)} Z`
-const getSvgPathFromStroke = (points: number[][]): string => {
+    );
-  if (!points.length) {
-    return "";
   }
 
-  const max = points.length - 1;
+  const px = -dy / len; // perpendicular unit x
+  const py = dx / len; // perpendicular unit y
 
-  return points
+  // P0 +/- perp·r0  (start / back cap tangent points)
-    .reduce(
+  const b0x = r2(x0 + px * r0);
-      (acc, point, i, arr) => {
+  const b0y = r2(y0 + py * r0);
-        if (i === max) {
+  const b1x = r2(x0 - px * r0);
-          acc.push(point, med(point, arr[0]), "L", arr[0], "Z");
+  const b1y = r2(y0 - py * r0);
-        } else {
+  // P1 +/- perp·r1  (end / front cap tangent points)
-          acc.push(point, med(point, arr[i + 1]));
+  const f0x = r2(x1 - px * r1);
-        }
+  const f0y = r2(y1 - py * r1);
-        return acc;
+  const f1x = r2(x1 + px * r1);
-      },
+  const f1y = r2(y1 + py * r1);
-      ["M", points[0], "Q"],
+  const rr0 = r2(r0);
-    )
+  const rr1 = r2(r1);
-    .join(" ")
+
-    .replace(TO_FIXED_PRECISION, "$1");
+  // Back cap: clockwise 180° arc from (b0) to (b1) around P0.
+  // Front cap: clockwise 180° arc from (f0) to (f1) around P1.
+  return (
+    `M ${b0x.toFixed(2)} ${b0y.toFixed(2)} ` +
+    `A ${rr0.toFixed(2)} ${rr0.toFixed(2)} 0 1 1 ${b1x.toFixed(
+      2,
+    )} ${b1y.toFixed(2)} ` +
+    `L ${f0x.toFixed(2)} ${f0y.toFixed(2)} ` +
+    `A ${rr1.toFixed(2)} ${rr1.toFixed(2)} 0 1 1 ${f1x.toFixed(
+      2,
+    )} ${f1y.toFixed(2)} Z`
+  );
+};
+
+/**
+ * Catmull-Rom tangent at points[i].Identical math to `getCatmullRomTangent`
+ * in renderElement.ts (predictedPoint is not needed for finalised strokes).
+ */
+const freedrawCatmullRomTangent = (
+  points: readonly (readonly [number, number])[],
+  i: number,
+): [number, number] => {
+  const N = points.length;
+  const cur = points[i];
+
+  let next: readonly [number, number];
+  if (i < N - 1) {
+    next = points[i + 1];
+  } else {
+    const prev2 = i > 0 ? points[i - 1] : cur;
+    next = [2 * cur[0] - prev2[0], 2 * cur[1] - prev2[1]];
+  }
+
+  let tx: number;
+  let ty: number;
+  if (i === 0) {
+    tx = (next[0] - cur[0]) * 0.5;
+    ty = (next[1] - cur[1]) * 0.5;
+  } else {
+    const prev = points[i - 1];
+    tx = (next[0] - prev[0]) * 0.5;
+    ty = (next[1] - prev[1]) * 0.5;
+  }
+
+  // Chord-length clamping (PCHIP-style).
+  const magSq = tx * tx + ty * ty;
+  if (magSq > 0) {
+    const dNx = next[0] - cur[0];
+    const dNy = next[1] - cur[1];
+    const chordNext = Math.sqrt(dNx * dNx + dNy * dNy);
+    let chordPrev = chordNext;
+    if (i > 0) {
+      const prev = points[i - 1];
+      const dPx = cur[0] - prev[0];
+      const dPy = cur[1] - prev[1];
+      chordPrev = Math.sqrt(dPx * dPx + dPy * dPy);
+    }
+    const maxMag = 3 * Math.min(chordNext, chordPrev);
+    const mag = Math.sqrt(magSq);
+    if (mag > maxMag) {
+      const s = maxMag / mag;
+      tx *= s;
+      ty *= s;
+    }
+  }
+
+  return [tx, ty];
+};
+
+/**
+ * Triangular-kernel causal weighted pressure average (backward-only window).
+ * When `simulatePressure` is true or pressures array is empty, returns the
+ * default constant pressure so the geometry mirrors constant-pressure rendering.
+ */
+const getFreeDrawSmoothedPressure = (
+  element: ExcalidrawFreeDrawElement,
+  i: number,
+): number => {
+  const { pressures } = element;
+  if (element.simulatePressure || pressures.length === 0) {
+    return FREEDRAW_DEFAULT_PRESSURE;
+  }
+  let sum = 0;
+  let totalWeight = 0;
+  for (let k = -FREEDRAW_PRESSURE_SMOOTHING_RADIUS; k <= 0; k++) {
+    const idx = i + k;
+    if (idx < 0) {
+      continue;
+    }
+    const p =
+      idx < pressures.length ? pressures[idx] : FREEDRAW_DEFAULT_PRESSURE;
+    const w = FREEDRAW_PRESSURE_SMOOTHING_RADIUS + 1 + k;
+    sum += p * w;
+    totalWeight += w;
+  }
+  return totalWeight > 0 ? sum / totalWeight : FREEDRAW_DEFAULT_PRESSURE;
+};
+
+/**
+ * Returns one SVG path `d` string per tapered-capsule sub-segment for a
+ * freedraw element, using the same Catmull-Rom Bezier subdivision and pressure
+ * smoothing as the canvas renderer.
+ */
+const getFreeDrawCapsulePaths = (
+  element: ExcalidrawFreeDrawElement,
+): SVGPathString[] => {
+  const { points } = element;
+  const N = points.length;
+  const baseRadius = (element.strokeWidth * 1.25) / 2;
+
+  const getSmoothedPressure = (i: number): number =>
+    getFreeDrawSmoothedPressure(element, i);
+
+  const paths: SVGPathString[] = [];
+
+  if (N === 1) {
+    // Single-point stroke — filled circle.
+    const rr = r2(baseRadius * getSmoothedPressure(0) * 2);
+    const cx = r2(points[0][0]);
+    const cy = r2(points[0][1]);
+    paths.push(
+      `M ${(cx - rr).toFixed(2)} ${cy.toFixed(2)} A ${rr} ${rr} 0 1 1 ${(
+        cx + rr
+      ).toFixed(2)} ${cy.toFixed(2)} A ${rr} ${rr} 0 1 1 ${(cx - rr).toFixed(
+        2,
+      )} ${cy.toFixed(2)} Z` as SVGPathString,
+    );
+    return paths;
+  }
+
+  for (let i = 1; i < N; i++) {
+    const p0 = points[i - 1];
+    const p1 = points[i];
+    const r0 = baseRadius * getSmoothedPressure(i - 1) * 2;
+    const r1 = baseRadius * getSmoothedPressure(i) * 2;
+
+    const t0 = freedrawCatmullRomTangent(points, i - 1);
+    const t1 = freedrawCatmullRomTangent(points, i);
+
+    // Bezier subdivision.
+    const segLen = Math.sqrt((p1[0] - p0[0]) ** 2 + (p1[1] - p0[1]) ** 2);
+    const nSubdiv = Math.max(
+      1,
+      Math.ceil(segLen / FREEDRAW_BEZIER_SUBDIVIDE_TARGET_SPACING),
+    );
+
+    const cp1x = p0[0] + t0[0] / 3;
+    const cp1y = p0[1] + t0[1] / 3;
+    const cp2x = p1[0] - t1[0] / 3;
+    const cp2y = p1[1] - t1[1] / 3;
+
+    let prevX = p0[0];
+    let prevY = p0[1];
+    let prevR = r0;
+
+    for (let k = 1; k <= nSubdiv; k++) {
+      const t = k / nSubdiv;
+      const mt = 1 - t;
+      const mt2 = mt * mt;
+      const t2 = t * t;
+      const mt3 = mt2 * mt;
+      const t3 = t2 * t;
+
+      const x =
+        mt3 * p0[0] + 3 * mt2 * t * cp1x + 3 * mt * t2 * cp2x + t3 * p1[0];
+      const y =
+        mt3 * p0[1] + 3 * mt2 * t * cp1y + 3 * mt * t2 * cp2y + t3 * p1[1];
+      const r = r0 + (r1 - r0) * t;
+
+      paths.push(
+        freedrawTaperedCapsulePath(
+          prevX,
+          prevY,
+          prevR,
+          x,
+          y,
+          r,
+        ) as SVGPathString,
+      );
+      prevX = x;
+      prevY = y;
+      prevR = r;
+    }
+  }
+
+  return paths;
+};
+
+/**
+ * Generates an outline polygon for a freedraw element using the same
+ * Catmull-Rom Bezier subdivision and pressure smoothing as the canvas renderer.
+ * Returns `[x, y]` points in element-local coordinates that form a closed
+ * polygon around the stroke (left side + right side reversed), suitable for
+ * hit-testing and eraser intersection.
+ */
+export const getFreedrawOutlinePoints = (
+  element: ExcalidrawFreeDrawElement,
+): [number, number][] => {
+  const { points } = element;
+  const N = points.length;
+  const baseRadius = (element.strokeWidth * 1.25) / 2;
+
+  if (N === 0) {
+    return [];
+  }
+
+  const radius0 = baseRadius * getFreeDrawSmoothedPressure(element, 0) * 2;
+
+  if (N === 1) {
+    // Single point case
+    const cx = points[0][0];
+    const cy = points[0][1];
+    const result: [number, number][] = [];
+    for (let i = 0; i < 8; i++) {
+      const angle = (i / 8) * Math.PI * 2;
+      result.push([
+        cx + Math.cos(angle) * radius0,
+        cy + Math.sin(angle) * radius0,
+      ]);
+    }
+    return result;
+  }
+
+  const leftPoints: [number, number][] = [];
+  const rightPoints: [number, number][] = [];
+
+  for (let i = 1; i < N; i++) {
+    const p0 = points[i - 1];
+    const p1 = points[i];
+    const r0 = baseRadius * getFreeDrawSmoothedPressure(element, i - 1) * 2;
+    const r1 = baseRadius * getFreeDrawSmoothedPressure(element, i) * 2;
+
+    const t0 = freedrawCatmullRomTangent(points, i - 1);
+    const t1 = freedrawCatmullRomTangent(points, i);
+
+    const segLen = Math.sqrt((p1[0] - p0[0]) ** 2 + (p1[1] - p0[1]) ** 2);
+    const nSubdiv = Math.max(
+      1,
+      Math.ceil(segLen / FREEDRAW_BEZIER_SUBDIVIDE_TARGET_SPACING),
+    );
+
+    const cp1x = p0[0] + t0[0] / 3;
+    const cp1y = p0[1] + t0[1] / 3;
+    const cp2x = p1[0] - t1[0] / 3;
+    const cp2y = p1[1] - t1[1] / 3;
+
+    // Include the start point of the first segment.
+    const kStart = i === 1 ? 0 : 1;
+
+    for (let k = kStart; k <= nSubdiv; k++) {
+      const tParam = k / nSubdiv;
+      const mt = 1 - tParam;
+      const mt2 = mt * mt;
+      const t2 = tParam * tParam;
+      const mt3 = mt2 * mt;
+      const t3 = t2 * tParam;
+
+      const x =
+        mt3 * p0[0] + 3 * mt2 * tParam * cp1x + 3 * mt * t2 * cp2x + t3 * p1[0];
+      const y =
+        mt3 * p0[1] + 3 * mt2 * tParam * cp1y + 3 * mt * t2 * cp2y + t3 * p1[1];
+
+      // Bezier first derivative for the tangent direction.
+      const dtx =
+        3 *
+        (mt2 * (cp1x - p0[0]) +
+          2 * mt * tParam * (cp2x - cp1x) +
+          t2 * (p1[0] - cp2x));
+      const dty =
+        3 *
+        (mt2 * (cp1y - p0[1]) +
+          2 * mt * tParam * (cp2y - cp1y) +
+          t2 * (p1[1] - cp2y));
+
+      const len = Math.sqrt(dtx * dtx + dty * dty);
+      if (len === 0) {
+        continue;
+      }
+
+      // Perpendicular (left = +, right = −).
+      const px = -dty / len;
+      const py = dtx / len;
+
+      const r = r0 + (r1 - r0) * tParam;
+
+      leftPoints.push([x + px * r, y + py * r]);
+      rightPoints.push([x - px * r, y - py * r]);
+    }
+  }
+
+  // Closed polygon: left side (start -> end) + right side (end -> start).
+  return [...leftPoints, ...rightPoints.reverse()];
 };
 
 // -----------------------------------------------------------------------------

packages/excalidraw/actions/actionFinalize.tsx

@@ -14,6 +14,8 @@ import {
   isLineElement,
 } from "@excalidraw/element";
 
+import { invalidateFreeDrawIncrementalCanvas } from "@excalidraw/element";
+
 import {
   KEYS,
   arrayToMap,
@@ -313,6 +315,10 @@ export const actionFinalize = register<FormData>({
         }
       : selectedLinearElement;
 
+    if (element && isFreeDrawElement(element)) {
+      invalidateFreeDrawIncrementalCanvas(element);
+    }
+
     return {
       elements: newElements,
       appState: {

packages/excalidraw/actions/actionProperties.tsx

@@ -1,3 +1,5 @@
+import clsx from "clsx";
+
 import { pointFrom } from "@excalidraw/math";
 
 import { useEffect, useMemo, useRef, useState } from "react";
@@ -47,6 +49,7 @@ import {
   isArrowElement,
   isBoundToContainer,
   isElbowArrow,
+  isFreeDrawElement,
   isLinearElement,
   isLineElement,
   isTextElement,
@@ -131,6 +134,8 @@ import {
   ArrowheadCardinalityOneOrManyIcon,
   ArrowheadCardinalityZeroOrManyIcon,
   ArrowheadCardinalityZeroOrOneIcon,
+  FreedrawPressureConstantIcon,
+  FreedrawPressureSensitiveIcon,
 } from "../components/icons";
 
 import { Fonts } from "../fonts";
@@ -2041,3 +2046,89 @@ export const actionChangeArrowType = register<keyof typeof ARROW_TYPE>({
     );
   },
 });
+
+export const actionChangeStrokeShape = register<boolean>({
+  name: "changeStrokeShape",
+  label: "labels.strokeShape",
+  trackEvent: false,
+  perform: (elements, appState, value) => {
+    return {
+      elements: changeProperty(elements, appState, (el) => {
+        if (isFreeDrawElement(el)) {
+          return newElementWith(el, {
+            simulatePressure: value,
+          });
+        }
+        return el;
+      }),
+      appState: { ...appState, currentItemFreedrawConstantPressure: value },
+      captureUpdate: CaptureUpdateAction.IMMEDIATELY,
+    };
+  },
+  PanelComponent: ({ elements, appState, updateData, app }) => {
+    const { isCompact } = getStylesPanelInfo(app);
+
+    const currentValue = getFormValue(
+      elements,
+      app,
+      (element) => {
+        if (isFreeDrawElement(element)) {
+          return element.simulatePressure;
+        }
+        return null;
+      },
+      (element) => isFreeDrawElement(element),
+      (hasSelection) =>
+        hasSelection ? null : appState.currentItemFreedrawConstantPressure,
+    );
+
+    if (isCompact) {
+      const isConstantPressure = currentValue !== false;
+      return (
+        <button
+          type="button"
+          className={clsx("compact-action-button", {
+            active: !isConstantPressure,
+          })}
+          title={
+            isConstantPressure
+              ? t("labels.strokeShape_constant")
+              : t("labels.strokeShape_pressure")
+          }
+          onClick={() => updateData(!isConstantPressure)}
+        >
+          {isConstantPressure
+            ? FreedrawPressureConstantIcon
+            : FreedrawPressureSensitiveIcon}
+        </button>
+      );
+    }
+
+    return (
+      <fieldset>
+        <legend>{t("labels.strokeShape")}</legend>
+        <div className="buttonList">
+          <RadioSelection
+            group="stroke-shape"
+            options={[
+              {
+                value: true,
+                text: t("labels.strokeShape_constant"),
+                icon: FreedrawPressureConstantIcon,
+                testId: "strokeShape-constant",
+              },
+              {
+                value: false,
+                text: t("labels.strokeShape_pressure"),
+                icon: FreedrawPressureSensitiveIcon,
+                testId: "strokeShape-pressure",
+              },
+            ]}
+            value={currentValue}
+            onChange={(value) => updateData(value)}
+          />
+        </div>
+      </fieldset>
+    );
+  },
+});

packages/excalidraw/actions/index.ts

@@ -19,6 +19,7 @@ export {
   actionChangeTextAlign,
   actionChangeVerticalAlign,
   actionChangeArrowProperties,
+  actionChangeStrokeShape,
 } from "./actionProperties";
 
 export {

packages/excalidraw/animatedTrail.ts

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

packages/excalidraw/animation-frame-handler.ts

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

packages/excalidraw/appState.ts

@@ -40,6 +40,7 @@ export const getDefaultAppState = (): Omit<
     currentItemArrowType: ARROW_TYPE.round,
     currentItemStrokeStyle: DEFAULT_ELEMENT_PROPS.strokeStyle,
     currentItemStrokeWidth: DEFAULT_ELEMENT_PROPS.strokeWidth,
+    currentItemFreedrawConstantPressure: true,
     currentItemTextAlign: DEFAULT_TEXT_ALIGN,
     currentHoveredFontFamily: null,
     cursorButton: "up",
@@ -171,6 +172,11 @@ const APP_STATE_STORAGE_CONF = (<
   currentItemStrokeColor: { browser: true, export: false, server: false },
   currentItemStrokeStyle: { browser: true, export: false, server: false },
   currentItemStrokeWidth: { browser: true, export: false, server: false },
+  currentItemFreedrawConstantPressure: {
+    browser: true,
+    export: false,
+    server: false,
+  },
   currentItemTextAlign: { browser: true, export: false, server: false },
   currentHoveredFontFamily: { browser: false, export: false, server: false },
   cursorButton: { browser: true, export: false, server: false },

packages/excalidraw/components/Actions.tsx

@@ -834,6 +834,14 @@ export const CompactShapeActions = ({
         container={container}
       />
 
+      {/* Stroke Shape Toggle (freedraw only) */}
+      {(appState.activeTool.type === "freedraw" ||
+        targetElements.some((element) => element.type === "freedraw")) && (
+        <div className="compact-action-item">
+          {renderAction("changeStrokeShape")}
+        </div>
+      )}
+
       <CombinedArrowProperties
         appState={appState}
         renderAction={renderAction}
@@ -969,6 +977,13 @@ export const MobileShapeActions = ({
           targetElements={targetElements}
           container={container}
         />
+        {/* Stroke Shape Toggle (freedraw only) */}
+        {(appState.activeTool.type === "freedraw" ||
+          targetElements.some((element) => element.type === "freedraw")) && (
+          <div className="compact-action-item">
+            {renderAction("changeStrokeShape")}
+          </div>
+        )}
         {/* Combined Arrow Properties */}
         <CombinedArrowProperties
           appState={appState}

packages/excalidraw/components/App.tsx

@@ -28,7 +28,6 @@ import {
   APP_NAME,
   CURSOR_TYPE,
   DEFAULT_TRANSFORM_HANDLE_SPACING,
-  DEFAULT_MAX_IMAGE_WIDTH_OR_HEIGHT,
   DEFAULT_VERTICAL_ALIGN,
   DRAGGING_THRESHOLD,
   ELEMENT_SHIFT_TRANSLATE_AMOUNT,
@@ -38,7 +37,6 @@ import {
   IMAGE_MIME_TYPES,
   IMAGE_RENDER_TIMEOUT,
   LINE_CONFIRM_THRESHOLD,
-  MAX_ALLOWED_FILE_BYTES,
   MIME_TYPES,
   MQ_RIGHT_SIDEBAR_MIN_WIDTH,
   POINTER_BUTTON,
@@ -345,7 +343,6 @@ import { ActionManager } from "../actions/manager";
 import { actions } from "../actions/register";
 import { getShortcutFromShortcutName } from "../actions/shortcuts";
 import { trackEvent } from "../analytics";
-import { AnimationFrameHandler } from "../animation-frame-handler";
 import {
   getDefaultAppState,
   isEraserActive,
@@ -419,7 +416,7 @@ import {
   setCursorForShape,
 } from "../cursor";
 import { ElementCanvasButtons } from "../components/ElementCanvasButtons";
-import { LaserTrails } from "../laser-trails";
+import { LaserTrails } from "../laserTrails";
 import { withBatchedUpdates, withBatchedUpdatesThrottled } from "../reactUtils";
 import { isPointHittingTextAutoResizeHandle } from "../textAutoResizeHandle";
 import { textWysiwyg } from "../wysiwyg/textWysiwyg";
@@ -705,11 +702,9 @@ class App extends React.Component<AppProps, AppState> {
   previousPointerMoveCoords: { x: number; y: number } | null = null;
   lastViewportPosition = { x: 0, y: 0 };
 
-  animationFrameHandler = new AnimationFrameHandler();
+  laserTrails = new LaserTrails(this);
-
+  eraserTrail = new EraserTrail(this);
-  laserTrails = new LaserTrails(this.animationFrameHandler, this);
+  lassoTrail = new LassoTrail(this);
-  eraserTrail = new EraserTrail(this.animationFrameHandler, this);
-  lassoTrail = new LassoTrail(this.animationFrameHandler, this);
 
   onChangeEmitter = new Emitter<
     [
@@ -2000,9 +1995,10 @@ class App extends React.Component<AppProps, AppState> {
               }
             }}
             style={{
-              background: isDarkTheme
+              background: applyDarkModeFilter(
-                ? applyDarkModeFilter(this.state.viewBackgroundColor)
+                this.state.viewBackgroundColor,
-                : this.state.viewBackgroundColor,
+                isDarkTheme,
+              ),
               zIndex: 2,
               border: "none",
               display: "block",
@@ -4617,6 +4613,7 @@ class App extends React.Component<AppProps, AppState> {
       }
 
       if (collaborators) {
+        this.laserTrails.updateCollabTrails(collaborators);
         this.setState({ collaborators });
       }
     },
@@ -9027,7 +9024,7 @@ class App extends React.Component<AppProps, AppState> {
       y: gridY,
     });
 
-    const simulatePressure = event.pressure === 0.5;
+    const simulatePressure = this.state.currentItemFreedrawConstantPressure;
 
     const element = newFreeDrawElement({
       type: elementType,
@@ -9045,7 +9042,7 @@ class App extends React.Component<AppProps, AppState> {
       locked: false,
       frameId: topLayerFrame ? topLayerFrame.id : null,
       points: [pointFrom<LocalPoint>(0, 0)],
-      pressures: simulatePressure ? [] : [event.pressure],
+      pressures: [event.pressure],
     });
 
     this.insertNewElement(element);
@@ -9674,10 +9671,61 @@ class App extends React.Component<AppProps, AppState> {
     });
   }
 
+  /**
+   * Returns the timestamp of a pointer event, in milliseconds.
+   * Extracted as a method so tests can spy on it and return a fixed value,
+   * making the One Euro Filter in the freedraw handler deterministic.
+   */
+  protected getPointerEventTimestamp(
+    ev: Pick<PointerEvent, "timeStamp">,
+  ): number {
+    return ev.timeStamp;
+  }
+
   private onPointerMoveFromPointerDownHandler(
     pointerDownState: PointerDownState,
   ) {
-    return withBatchedUpdatesThrottled((event: PointerEvent) => {
+    // Per-stroke One Euro Filter state for mouse freedraw smoothing.
+    // Reference: Casiez et al. 2012 "1€ Filter: A Simple Speed-based Low-pass
+    // Filter for Noisy Input in Interactive Systems".
+    //
+    // The filter adapts its EMA alpha to the current speed of the pointer:
+    //   slow movement  → low cutoff → heavy smoothing (removes jitter)
+    //   fast movement  → high cutoff → near-raw tracking (minimal lag)
+    //
+    // State variables (reset at stroke start via null sentinel):
+    let emaX: number | null = null; // smoothed position x
+    let emaY: number | null = null; // smoothed position y
+    let emaDx = 0; // smoothed derivative x
+    let emaDy = 0; // smoothed derivative y
+    let prevRawX: number | null = null; // previous raw x for derivative
+    let prevRawY: number | null = null;
+    let prevTs: number | null = null; // previous event timestamp (ms)
+
+    // Pen pressure warmup: the first few samples from a pen digitizer are
+    // unreliable (often spike to ~0.5).  We apply an EMA whose alpha ramps
+    // from PEN_PRESSURE_INITIAL_ALPHA up to 1 over PEN_PRESSURE_WARMUP_SAMPLES
+    // so the stroke gradually eases from heavy smoothing into raw pressure.
+    let penPressureEma: number | null = null;
+    let penPressureSampleCount = 0;
+    const PEN_PRESSURE_WARMUP_SAMPLES = 20;
+    const PEN_PRESSURE_INITIAL_ALPHA = 0.1;
+
+    // Tuning constants:
+    //   MIN_CUTOFF  – cutoff frequency (Hz) when speed ≈ 0; smaller = more smoothing
+    //   BETA        – rate at which cutoff grows with speed; larger = quicker adaptation
+    //   D_CUTOFF    – fixed cutoff for the derivative pre-filter
+    const MIN_CUTOFF = 0.5;
+    const BETA = 0.01;
+    const D_CUTOFF = 2.0;
+
+    /** Compute EMA alpha from cutoff frequency (Hz) and timestep (seconds). */
+    const emaAlpha = (cutoff: number, dt: number): number => {
+      const tau = 1 / (2 * Math.PI * cutoff);
+      return 1 / (1 + tau / dt);
+    };
+
+    const handler = (event: PointerEvent) => {
       if (this.state.openDialog?.name === "elementLinkSelector") {
         return;
       }
@@ -10369,23 +10417,98 @@ class App extends React.Component<AppProps, AppState> {
         }
 
         if (newElement.type === "freedraw") {
-          const points = newElement.points;
+          const coalescedEvents: PointerEvent[] =
-          const dx = pointerCoords.x - newElement.x;
+            event.getCoalescedEvents?.() ?? [];
-          const dy = pointerCoords.y - newElement.y;
+          const allEvents =
+            coalescedEvents.length > 0 ? coalescedEvents : [event];
+          const newPoints: LocalPoint[] = [];
+          const newPressures: number[] = [];
 
-          const lastPoint = points.length > 0 && points[points.length - 1];
+          let lastPoint =
-          const discardPoint =
+            newElement.points.length > 0
-            lastPoint && lastPoint[0] === dx && lastPoint[1] === dy;
+              ? newElement.points[newElement.points.length - 1]
+              : null;
 
-          if (!discardPoint) {
+          for (const ev of allEvents) {
-            const pressures = newElement.simulatePressure
+            const coords = viewportCoordsToSceneCoords(ev, this.state);
-              ? newElement.pressures
+            const rawDx = coords.x - newElement.x;
-              : [...newElement.pressures, event.pressure];
+            const rawDy = coords.y - newElement.y;
+            let dx = rawDx;
+            let dy = rawDy;
+
+            if (event.pointerType === "mouse") {
+              // One Euro Filter: speed-adaptive low-pass for mouse events.
+              const evTs = this.getPointerEventTimestamp(ev);
+              const dt = Math.max(
+                prevTs !== null ? (evTs - prevTs) / 1000 : 1 / 60,
+                0.001,
+              ); // seconds
+
+              // 1. Smooth the derivative (fixed D_CUTOFF pre-filter).
+              const alphaD = emaAlpha(D_CUTOFF, dt);
+              const rawDxDt = prevRawX !== null ? (rawDx - prevRawX) / dt : 0;
+              const rawDyDt = prevRawY !== null ? (rawDy - prevRawY) / dt : 0;
+              emaDx = alphaD * rawDxDt + (1 - alphaD) * emaDx;
+              emaDy = alphaD * rawDyDt + (1 - alphaD) * emaDy;
+
+              // 2. Adaptive cutoff: higher speed → higher cutoff → less lag.
+              // Normalize to screen-space pixels/sec so BETA behaves the same
+              // regardless of zoom level (scene units are 1/zoom px at high zoom).
+              const speed =
+                Math.sqrt(emaDx * emaDx + emaDy * emaDy) *
+                this.state.zoom.value;
+              const cutoff = MIN_CUTOFF + BETA * speed;
+              const alphaP = emaAlpha(cutoff, dt);
+
+              // 3. Smooth position with adaptive alpha.
+              emaX =
+                emaX === null ? rawDx : alphaP * rawDx + (1 - alphaP) * emaX;
+              emaY =
+                emaY === null ? rawDy : alphaP * rawDy + (1 - alphaP) * emaY;
+
+              prevRawX = rawDx;
+              prevRawY = rawDy;
+              prevTs = evTs;
+
+              dx = emaX;
+              dy = emaY;
+            }
+
+            if (!lastPoint || lastPoint[0] !== dx || lastPoint[1] !== dy) {
+              const pt = pointFrom<LocalPoint>(dx, dy);
+              newPoints.push(pt);
+
+              let pressure = ev.pressure;
+              if (event.pointerType === "pen") {
+                // Gradually ease from aggressive smoothing into raw pressure to
+                // suppress the unreliable spike at the start of a pen stroke.
+                const progress = Math.min(
+                  1,
+                  penPressureSampleCount / PEN_PRESSURE_WARMUP_SAMPLES,
+                );
+                const alpha =
+                  PEN_PRESSURE_INITIAL_ALPHA +
+                  progress * (1 - PEN_PRESSURE_INITIAL_ALPHA);
+                penPressureEma =
+                  penPressureEma === null
+                    ? pressure
+                    : alpha * pressure + (1 - alpha) * penPressureEma;
+                pressure = penPressureEma;
+                penPressureSampleCount++;
+              }
+
+              newPressures.push(pressure);
+              lastPoint = pt;
+            }
+          }
+
+          if (newPoints.length > 0) {
+            const pressures = [...newElement.pressures, ...newPressures];
 
             this.scene.mutateElement(
               newElement,
               {
-                points: [...points, pointFrom<LocalPoint>(dx, dy)],
+                points: [...newElement.points, ...newPoints],
                 pressures,
               },
               {
@@ -10561,7 +10684,23 @@ class App extends React.Component<AppProps, AppState> {
           });
         }
       }
-    });
+    };
+
+    // For freedraw, bypass RAF throttling so every pointer event is processed
+    // synchronously. This preserves coalesced pointer events and eliminates
+    // stroke lag on high-frequency stylus / pointer input.
+    if (this.state.activeTool.type === "freedraw") {
+      const immediate = withBatchedUpdates(handler);
+      const result = immediate as typeof immediate & {
+        flush(): void;
+        cancel(): void;
+      };
+      result.flush = () => {};
+      result.cancel = () => {};
+      return result;
+    }
+
+    return withBatchedUpdatesThrottled(handler);
   }
 
   // Returns whether the pointer move happened over either scrollbar
@@ -10852,9 +10991,7 @@ class App extends React.Component<AppProps, AppState> {
           dx += 0.0001;
         }
 
-        const pressures = newElement.simulatePressure
+        const pressures = [...newElement.pressures, childEvent.pressure];
-          ? []
-          : [...newElement.pressures, childEvent.pressure];
 
         this.scene.mutateElement(newElement, {
           points: [...points, pointFrom<LocalPoint>(dx, dy)],
@@ -11721,9 +11858,11 @@ class App extends React.Component<AppProps, AppState> {
 
     const existingFileData = this.files[fileId];
     if (!existingFileData?.dataURL) {
+      const { maxWidthOrHeight, maxFileSizeBytes } = this.props.imageOptions;
+
       try {
         imageFile = await resizeImageFile(imageFile, {
-          maxWidthOrHeight: DEFAULT_MAX_IMAGE_WIDTH_OR_HEIGHT,
+          maxWidthOrHeight,
         });
       } catch (error: any) {
         console.error(
@@ -11732,10 +11871,10 @@ class App extends React.Component<AppProps, AppState> {
         );
       }
 
-      if (imageFile.size > MAX_ALLOWED_FILE_BYTES) {
+      if (imageFile.size > maxFileSizeBytes) {
         throw new Error(
           t("errors.fileTooBig", {
-            maxSize: `${Math.trunc(MAX_ALLOWED_FILE_BYTES / 1024 / 1024)}MB`,
+            maxSize: `${Math.trunc(maxFileSizeBytes / 1024 / 1024)}MB`,
           }),
         );
       }

packages/excalidraw/components/SVGLayer.tsx

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

packages/excalidraw/components/icons.tsx

@@ -1186,6 +1186,26 @@ export const StrokeWidthExtraBoldIcon = createIcon(
   modifiedTablerIconProps,
 );
 
+export const FreedrawPressureConstantIcon = createIcon(
+  <path
+    d="M4 10h12"
+    stroke="currentColor"
+    strokeWidth="3"
+    strokeLinecap="round"
+    strokeLinejoin="round"
+  />,
+  modifiedTablerIconProps,
+);
+
+export const FreedrawPressureSensitiveIcon = createIcon(
+  <path
+    d="M4 10C6 9.5 10 8 16 7L16 13C10 12 6 10.5 4 10Z"
+    fill="currentColor"
+    stroke="none"
+  />,
+  modifiedTablerIconProps,
+);
+
 export const StrokeStyleSolidIcon = React.memo(({ theme }: { theme: Theme }) =>
   createIcon(
     <path

packages/excalidraw/data/blob.ts

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

packages/excalidraw/data/restore.ts

@@ -1,4 +1,4 @@
-import { isFiniteNumber, pointFrom } from "@excalidraw/math";
+import { isFiniteNumber, isValidPoint, pointFrom } from "@excalidraw/math";
 
 import {
   type CombineBrandsIfNeeded,
@@ -98,6 +98,67 @@ type RestoredAppState = Omit<
 
 const MAX_ARROW_PX = 75_000;
 
+const restoreLinearElementPoints = (
+  points: unknown,
+  width: unknown,
+  height: unknown,
+): LocalPoint[] => {
+  const restoredPoints = Array.isArray(points)
+    ? points.reduce<LocalPoint[]>((acc, point) => {
+        if (isValidPoint(point)) {
+          acc.push(pointFrom<LocalPoint>(point[0], point[1]));
+        }
+        return acc;
+      }, [])
+    : [];
+
+  return restoredPoints.length < 2
+    ? [
+        pointFrom<LocalPoint>(0, 0),
+        pointFrom<LocalPoint>(
+          isFiniteNumber(width) ? width : 0,
+          isFiniteNumber(height) ? height : 0,
+        ),
+      ]
+    : restoredPoints;
+};
+
+const restoreFreedrawPoints = (
+  points: unknown,
+  pressures: unknown,
+): {
+  points: LocalPoint[];
+  pressures: number[];
+} => {
+  if (!Array.isArray(points)) {
+    return {
+      points: [],
+      pressures: [],
+    };
+  }
+
+  const pressureValues: readonly unknown[] = Array.isArray(pressures)
+    ? pressures
+    : [];
+  const restoredPoints: LocalPoint[] = [];
+  const restoredPressures: number[] = [];
+
+  points.forEach((point, index) => {
+    if (isValidPoint(point)) {
+      restoredPoints.push(pointFrom<LocalPoint>(point[0], point[1]));
+      if (index in pressureValues) {
+        const pressure = pressureValues[index];
+        restoredPressures.push(isFiniteNumber(pressure) ? pressure : 0.5);
+      }
+    }
+  });
+
+  return {
+    points: restoredPoints,
+    pressures: restoredPressures,
+  };
+};
+
 export const AllowedExcalidrawActiveTools: Record<
   AppState["activeTool"]["type"],
   boolean
@@ -414,10 +475,15 @@ export const restoreElement = (
 
       return element;
     case "freedraw": {
+      const { points, pressures } = restoreFreedrawPoints(
+        element.points,
+        element.pressures,
+      );
+
       return restoreElementWithProperties(element, {
-        points: element.points,
+        points,
         simulatePressure: element.simulatePressure,
-        pressures: element.pressures,
+        pressures,
       });
     }
     case "image":
@@ -435,14 +501,20 @@ export const restoreElement = (
       const endArrowhead = normalizeArrowhead(element.endArrowhead);
       let x = element.x;
       let y = element.y;
-      let points = // migrate old arrow model to new one
+      let points = restoreLinearElementPoints(
-        !Array.isArray(element.points) || element.points.length < 2
+        element.points,
-          ? [pointFrom(0, 0), pointFrom(element.width, element.height)]
+        element.width,
-          : element.points;
+        element.height,
+      );
 
       if (points[0][0] !== 0 || points[0][1] !== 0) {
         ({ points, x, y } =
-          LinearElementEditor.getNormalizeElementPointsAndCoords(element));
+          LinearElementEditor.getNormalizeElementPointsAndCoords({
+            ...element,
+            points,
+            x: x ?? 0,
+            y: y ?? 0,
+          } as ExcalidrawLinearElement));
       }
 
       return restoreElementWithProperties(element, {
@@ -456,7 +528,7 @@ export const restoreElement = (
         y,
         ...(isLineElement(element)
           ? {
-              polygon: isValidPolygon(element.points)
+              polygon: isValidPolygon(points)
                 ? element.polygon ?? false
                 : false,
             }
@@ -471,22 +543,29 @@ export const restoreElement = (
           : normalizeArrowhead(element.endArrowhead);
       const x = element.x as number | undefined;
       const y = element.y as number | undefined;
-      const points: readonly LocalPoint[] | undefined = // migrate old arrow model to new one
+      const points = restoreLinearElementPoints(
-        !Array.isArray(element.points) || element.points.length < 2
+        element.points,
-          ? [pointFrom(0, 0), pointFrom(element.width, element.height)]
+        element.width,
-          : element.points;
+        element.height,
+      );
+      const elementWithRestoredPoints = {
+        ...element,
+        points,
+        x: x ?? 0,
+        y: y ?? 0,
+      } as ExcalidrawArrowElement;
 
       const base = {
         type: element.type,
         startBinding: repairBinding(
-          element as ExcalidrawArrowElement,
+          elementWithRestoredPoints,
           element.startBinding,
           targetElementsMap,
           existingElementsMap,
           "start",
         ),
         endBinding: repairBinding(
-          element as ExcalidrawArrowElement,
+          elementWithRestoredPoints,
           element.endBinding,
           targetElementsMap,
           existingElementsMap,

packages/excalidraw/eraser/index.ts

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

packages/excalidraw/index.tsx

@@ -6,7 +6,12 @@ import React, {
   useState,
 } from "react";
 
-import { DEFAULT_UI_OPTIONS, isShallowEqual } from "@excalidraw/common";
+import {
+  applyDarkModeFilter,
+  DEFAULT_IMAGE_OPTIONS,
+  DEFAULT_UI_OPTIONS,
+  isShallowEqual,
+} from "@excalidraw/common";
 
 import App, {
   ExcalidrawAPIContext,
@@ -98,6 +103,7 @@ const ExcalidrawBase = (props: ExcalidrawProps) => {
     aiEnabled,
     showDeprecatedFonts,
     renderScrollbars,
+    imageOptions,
   } = props;
 
   const canvasActions = props.UIOptions?.canvasActions;
@@ -128,6 +134,13 @@ const ExcalidrawBase = (props: ExcalidrawProps) => {
     UIOptions.canvasActions.toggleTheme = true;
   }
 
+  const normalizedImageOptions: AppProps["imageOptions"] = {
+    maxFileSizeBytes:
+      imageOptions?.maxFileSizeBytes ?? DEFAULT_IMAGE_OPTIONS.maxFileSizeBytes,
+    maxWidthOrHeight:
+      imageOptions?.maxWidthOrHeight ?? DEFAULT_IMAGE_OPTIONS.maxWidthOrHeight,
+  };
+
   const setExcalidrawAPI = useContext(ExcalidrawAPISetContext);
 
   const onExcalidrawAPIRef = useRef(onExcalidrawAPI);
@@ -208,6 +221,7 @@ const ExcalidrawBase = (props: ExcalidrawProps) => {
           aiEnabled={aiEnabled !== false}
           showDeprecatedFonts={showDeprecatedFonts}
           renderScrollbars={renderScrollbars}
+          imageOptions={normalizedImageOptions}
         >
           {children}
         </App>
@@ -225,11 +239,13 @@ const areEqual = (prevProps: ExcalidrawProps, nextProps: ExcalidrawProps) => {
   const {
     initialData: prevInitialData,
     UIOptions: prevUIOptions = {},
+    imageOptions: prevImageOptions,
     ...prev
   } = prevProps;
   const {
     initialData: nextInitialData,
     UIOptions: nextUIOptions = {},
+    imageOptions: nextImageOptions,
     ...next
   } = nextProps;
 
@@ -273,7 +289,17 @@ const areEqual = (prevProps: ExcalidrawProps, nextProps: ExcalidrawProps) => {
     return prevUIOptions[key] === nextUIOptions[key];
   });
 
-  return isUIOptionsSame && isShallowEqual(prev, next);
+  const isImageOptionsSame =
+    (prevImageOptions?.maxWidthOrHeight ??
+      DEFAULT_IMAGE_OPTIONS.maxWidthOrHeight) ===
+      (nextImageOptions?.maxWidthOrHeight ??
+        DEFAULT_IMAGE_OPTIONS.maxWidthOrHeight) &&
+    (prevImageOptions?.maxFileSizeBytes ??
+      DEFAULT_IMAGE_OPTIONS.maxFileSizeBytes) ===
+      (nextImageOptions?.maxFileSizeBytes ??
+        DEFAULT_IMAGE_OPTIONS.maxFileSizeBytes);
+
+  return isUIOptionsSame && isImageOptionsSame && isShallowEqual(prev, next);
 };
 
 export const Excalidraw = React.memo(ExcalidrawBase, areEqual);
@@ -425,3 +451,5 @@ export function useExcalidrawStateValue(
 // -----------------------------------------------------------------------------
 
 export { _useOnAppStateChange as useOnExcalidrawStateChange };
+
+export { applyDarkModeFilter };

packages/excalidraw/laserTrails.ts

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

packages/excalidraw/lasso/index.ts

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

packages/excalidraw/locales/en.json

@@ -30,6 +30,9 @@
     "changeBackground": "Change background color",
     "fill": "Fill",
     "strokeWidth": "Stroke width",
+    "strokeShape": "Pressure",
+    "strokeShape_constant": "Constant pressure",
+    "strokeShape_pressure": "Pressure-sensitive",
     "strokeStyle": "Stroke style",
     "strokeStyle_solid": "Solid",
     "strokeStyle_dashed": "Dashed",

packages/excalidraw/package.json

@@ -103,7 +103,6 @@
     "lodash.throttle": "4.1.1",
     "nanoid": "3.3.3",
     "pako": "2.0.3",
-    "perfect-freehand": "1.2.0",
     "pica": "7.1.1",
     "png-chunk-text": "1.0.0",
     "png-chunks-encode": "1.0.0",

packages/excalidraw/renderer/animation.ts

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

packages/excalidraw/renderer/helpers.ts

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

packages/excalidraw/renderer/staticSvgScene.ts

@@ -377,18 +377,27 @@ const renderElementToSvg = (
     case "freedraw": {
       const wrapper = svgRoot.ownerDocument.createElementNS(SVG_NS, "g");
 
+      // Set fill once on the group so all capsule paths inherit it
+      // instead of repeating the attribute on every child element.
+      wrapper.setAttribute(
+        "fill",
+        renderConfig.theme === THEME.DARK
+          ? applyDarkModeFilter(element.strokeColor)
+          : element.strokeColor,
+      );
+
       const shapes = ShapeCache.generateElementShape(element, renderConfig);
       // always ordered as [background, stroke]
       for (const shape of shapes) {
         if (typeof shape === "string") {
-          // stroke (SVGPathString)
+          // stroke (SVGPathString) — fill inherited from wrapper <g>
-
           const path = svgRoot.ownerDocument.createElementNS(SVG_NS, "path");
           path.setAttribute(
             "fill",
-            renderConfig.theme === THEME.DARK
+            applyDarkModeFilter(
-              ? applyDarkModeFilter(element.strokeColor)
+              element.strokeColor,
-              : element.strokeColor,
+              renderConfig.theme === THEME.DARK,
+            ),
           );
           path.setAttribute("d", shape);
           wrapper.appendChild(path);
@@ -621,9 +630,10 @@ const renderElementToSvg = (
         rect.setAttribute("fill", "none");
         rect.setAttribute(
           "stroke",
-          renderConfig.theme === THEME.DARK
+          applyDarkModeFilter(
-            ? applyDarkModeFilter(FRAME_STYLE.strokeColor)
+            FRAME_STYLE.strokeColor,
-            : FRAME_STYLE.strokeColor,
+            renderConfig.theme === THEME.DARK,
+          ),
         );
         rect.setAttribute("stroke-width", FRAME_STYLE.strokeWidth.toString());
 
@@ -677,9 +687,10 @@ const renderElementToSvg = (
           text.setAttribute("font-size", `${element.fontSize}px`);
           text.setAttribute(
             "fill",
-            renderConfig.theme === THEME.DARK
+            applyDarkModeFilter(
-              ? applyDarkModeFilter(element.strokeColor)
+              element.strokeColor,
-              : element.strokeColor,
+              renderConfig.theme === THEME.DARK,
+            ),
           );
           text.setAttribute("text-anchor", textAnchor);
           text.setAttribute("style", "white-space: pre;");

packages/excalidraw/scene/export.ts

@@ -459,9 +459,7 @@ export const exportToSvg = async (
     rect.setAttribute("height", `${height}`);
     rect.setAttribute(
       "fill",
-      exportWithDarkMode
+      applyDarkModeFilter(viewBackgroundColor, exportWithDarkMode),
-        ? applyDarkModeFilter(viewBackgroundColor)
-        : viewBackgroundColor,
     );
     svgRoot.appendChild(rect);
   }

packages/excalidraw/tests/MermaidToExcalidraw.test.tsx

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

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

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

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

@@ -898,6 +898,7 @@ exports[`contextMenu element > right-clicking on a group should select whole gro
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -1097,6 +1098,7 @@ exports[`contextMenu element > selecting 'Add to library' in context menu adds e
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -1311,6 +1313,7 @@ exports[`contextMenu element > selecting 'Bring forward' in context menu brings
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -1642,6 +1645,7 @@ exports[`contextMenu element > selecting 'Bring to front' in context menu brings
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -1973,6 +1977,7 @@ exports[`contextMenu element > selecting 'Copy styles' in context menu copies st
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -2187,6 +2192,7 @@ exports[`contextMenu element > selecting 'Delete' in context menu deletes elemen
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -2428,6 +2434,7 @@ exports[`contextMenu element > selecting 'Duplicate' in context menu duplicates
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -2726,6 +2733,7 @@ exports[`contextMenu element > selecting 'Group selection' in context menu group
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -3098,6 +3106,7 @@ exports[`contextMenu element > selecting 'Paste styles' in context menu pastes s
   "currentItemFillStyle": "cross-hatch",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 60,
   "currentItemRoughness": 2,
   "currentItemRoundness": "sharp",
@@ -3591,6 +3600,7 @@ exports[`contextMenu element > selecting 'Send backward' in context menu sends e
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -3914,6 +3924,7 @@ exports[`contextMenu element > selecting 'Send to back' in context menu sends el
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -4237,6 +4248,7 @@ exports[`contextMenu element > selecting 'Ungroup selection' in context menu ung
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -5522,6 +5534,7 @@ exports[`contextMenu element > shows 'Group selection' in context menu for multi
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -6739,6 +6752,7 @@ exports[`contextMenu element > shows 'Ungroup selection' in context menu for gro
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -7696,6 +7710,7 @@ exports[`contextMenu element > shows context menu for canvas > [end of test] app
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -8696,6 +8711,7 @@ exports[`contextMenu element > shows context menu for element > [end of test] ap
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -9687,6 +9703,7 @@ exports[`contextMenu element > shows context menu for element > [end of test] ap
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",

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

@@ -24,6 +24,7 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -658,6 +659,7 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -1220,6 +1222,7 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -1580,6 +1583,7 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -1942,6 +1946,7 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -2205,6 +2210,7 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -2692,6 +2698,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -2995,6 +3002,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -3314,6 +3322,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -3608,6 +3617,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -3894,6 +3904,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -4129,6 +4140,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -4386,6 +4398,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -4657,6 +4670,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -4886,6 +4900,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -5115,6 +5130,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -5362,6 +5378,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -5618,6 +5635,7 @@ exports[`history > multiplayer undo/redo > conflicts in frames and their childre
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -5876,6 +5894,7 @@ exports[`history > multiplayer undo/redo > should iterate through the history wh
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -6205,6 +6224,7 @@ exports[`history > multiplayer undo/redo > should iterate through the history wh
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -6632,6 +6652,7 @@ exports[`history > multiplayer undo/redo > should iterate through the history wh
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -7006,6 +7027,7 @@ exports[`history > multiplayer undo/redo > should iterate through the history wh
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -7318,6 +7340,7 @@ exports[`history > multiplayer undo/redo > should iterate through the history wh
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -7611,6 +7634,7 @@ exports[`history > multiplayer undo/redo > should iterate through the history wh
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -7841,6 +7865,7 @@ exports[`history > multiplayer undo/redo > should iterate through the history wh
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -8193,6 +8218,7 @@ exports[`history > multiplayer undo/redo > should iterate through the history wh
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -8545,6 +8571,7 @@ exports[`history > multiplayer undo/redo > should not let remote changes to inte
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -8951,6 +8978,7 @@ exports[`history > multiplayer undo/redo > should not let remote changes to inte
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -9065,8 +9093,8 @@ exports[`history > multiplayer undo/redo > should not let remote changes to inte
       20,
     ],
     [
-      50,
+      "21.04874",
-      50,
+      "21.04874",
     ],
     [
       50,
@@ -9081,7 +9109,7 @@ exports[`history > multiplayer undo/redo > should not let remote changes to inte
   ],
   "roughness": 1,
   "roundness": null,
-  "simulatePressure": false,
+  "simulatePressure": true,
   "strokeColor": "#1e1e1e",
   "strokeStyle": "solid",
   "strokeWidth": 2,
@@ -9167,8 +9195,8 @@ exports[`history > multiplayer undo/redo > should not let remote changes to inte
                 20,
               ],
               [
-                50,
+                "21.04874",
-                50,
+                "21.04874",
               ],
               [
                 50,
@@ -9183,7 +9211,7 @@ exports[`history > multiplayer undo/redo > should not let remote changes to inte
             ],
             "roughness": 1,
             "roundness": null,
-            "simulatePressure": false,
+            "simulatePressure": true,
             "strokeColor": "#1e1e1e",
             "strokeStyle": "solid",
             "strokeWidth": 2,
@@ -9230,6 +9258,7 @@ exports[`history > multiplayer undo/redo > should not let remote changes to inte
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -9494,6 +9523,7 @@ exports[`history > multiplayer undo/redo > should not override remote changes on
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -9759,6 +9789,7 @@ exports[`history > multiplayer undo/redo > should not override remote changes on
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -9991,6 +10022,7 @@ exports[`history > multiplayer undo/redo > should override remotely added groups
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -10288,6 +10320,7 @@ exports[`history > multiplayer undo/redo > should override remotely added points
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -10606,6 +10639,7 @@ exports[`history > multiplayer undo/redo > should redistribute deltas when eleme
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -10842,6 +10876,7 @@ exports[`history > multiplayer undo/redo > should redraw arrows on undo > [end o
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -11260,489 +11295,6 @@ exports[`history > multiplayer undo/redo > should redraw arrows on undo > [end o
 
 exports[`history > multiplayer undo/redo > should redraw arrows on undo > [end of test] undo stack 1`] = `[]`;
 
-exports[`history > multiplayer undo/redo > should support undo and redo when escape unwinds nested group editing > [end of test] appState 1`] = `
-{
-  "activeEmbeddable": null,
-  "activeLockedId": null,
-  "activeTool": {
-    "customType": null,
-    "fromSelection": false,
-    "lastActiveTool": null,
-    "locked": false,
-    "type": "selection",
-  },
-  "bindMode": "orbit",
-  "bindingPreference": "enabled",
-  "collaborators": Map {},
-  "contextMenu": null,
-  "croppingElementId": null,
-  "currentHoveredFontFamily": null,
-  "currentItemArrowType": "round",
-  "currentItemBackgroundColor": "transparent",
-  "currentItemEndArrowhead": "arrow",
-  "currentItemFillStyle": "solid",
-  "currentItemFontFamily": 5,
-  "currentItemFontSize": 20,
-  "currentItemOpacity": 100,
-  "currentItemRoughness": 1,
-  "currentItemRoundness": "sharp",
-  "currentItemStartArrowhead": null,
-  "currentItemStrokeColor": "#1e1e1e",
-  "currentItemStrokeStyle": "solid",
-  "currentItemStrokeWidth": 2,
-  "currentItemTextAlign": "left",
-  "cursorButton": "up",
-  "defaultSidebarDockedPreference": false,
-  "editingFrame": null,
-  "editingGroupId": null,
-  "editingTextElement": null,
-  "elementsToHighlight": null,
-  "errorMessage": null,
-  "exportBackground": true,
-  "exportEmbedScene": false,
-  "exportScale": 1,
-  "exportWithDarkMode": false,
-  "fileHandle": null,
-  "followedBy": Set {},
-  "frameRendering": {
-    "clip": true,
-    "enabled": true,
-    "name": true,
-    "outline": true,
-  },
-  "frameToHighlight": null,
-  "gridModeEnabled": false,
-  "gridSize": 20,
-  "gridStep": 5,
-  "height": 0,
-  "hoveredElementIds": {},
-  "isBindingEnabled": true,
-  "isCropping": false,
-  "isLoading": false,
-  "isMidpointSnappingEnabled": true,
-  "isResizing": false,
-  "isRotating": false,
-  "lastPointerDownWith": "mouse",
-  "lockedMultiSelections": {},
-  "multiElement": null,
-  "newElement": null,
-  "objectsSnapModeEnabled": false,
-  "offsetLeft": 0,
-  "offsetTop": 0,
-  "openDialog": null,
-  "openMenu": null,
-  "openPopup": null,
-  "openSidebar": null,
-  "originSnapOffset": null,
-  "penDetected": false,
-  "penMode": false,
-  "preferredSelectionTool": {
-    "initialized": true,
-    "type": "selection",
-  },
-  "previousSelectedElementIds": {},
-  "resizingElement": null,
-  "scrollX": 0,
-  "scrollY": 0,
-  "searchMatches": null,
-  "selectedElementIds": {},
-  "selectedElementsAreBeingDragged": false,
-  "selectedGroupIds": {},
-  "selectionElement": null,
-  "shouldCacheIgnoreZoom": false,
-  "showHyperlinkPopup": false,
-  "showWelcomeScreen": true,
-  "snapLines": [],
-  "startBoundElement": null,
-  "stats": {
-    "open": false,
-    "panels": 3,
-  },
-  "suggestedBinding": null,
-  "theme": "light",
-  "toast": null,
-  "userToFollow": null,
-  "viewBackgroundColor": "#ffffff",
-  "viewModeEnabled": false,
-  "width": 0,
-  "zenModeEnabled": false,
-  "zoom": {
-    "value": 1,
-  },
-}
-`;
-
-exports[`history > multiplayer undo/redo > should support undo and redo when escape unwinds nested group editing > [end of test] element 0 1`] = `
-{
-  "angle": 0,
-  "backgroundColor": "transparent",
-  "boundElements": null,
-  "customData": undefined,
-  "fillStyle": "solid",
-  "frameId": null,
-  "groupIds": [
-    "inner",
-    "outer",
-  ],
-  "height": 100,
-  "id": "id0",
-  "index": "a0",
-  "isDeleted": false,
-  "link": null,
-  "locked": false,
-  "opacity": 100,
-  "roughness": 1,
-  "roundness": null,
-  "strokeColor": "#1e1e1e",
-  "strokeStyle": "solid",
-  "strokeWidth": 2,
-  "type": "rectangle",
-  "updated": 1,
-  "version": 2,
-  "width": 100,
-  "x": 0,
-  "y": 0,
-}
-`;
-
-exports[`history > multiplayer undo/redo > should support undo and redo when escape unwinds nested group editing > [end of test] element 1 1`] = `
-{
-  "angle": 0,
-  "backgroundColor": "transparent",
-  "boundElements": null,
-  "customData": undefined,
-  "fillStyle": "solid",
-  "frameId": null,
-  "groupIds": [
-    "outer",
-  ],
-  "height": 100,
-  "id": "id1",
-  "index": "a1",
-  "isDeleted": false,
-  "link": null,
-  "locked": false,
-  "opacity": 100,
-  "roughness": 1,
-  "roundness": null,
-  "strokeColor": "#1e1e1e",
-  "strokeStyle": "solid",
-  "strokeWidth": 2,
-  "type": "rectangle",
-  "updated": 1,
-  "version": 2,
-  "width": 100,
-  "x": 100,
-  "y": 100,
-}
-`;
-
-exports[`history > multiplayer undo/redo > should support undo and redo when escape unwinds nested group editing > [end of test] element 2 1`] = `
-{
-  "angle": 0,
-  "backgroundColor": "transparent",
-  "boundElements": null,
-  "customData": undefined,
-  "fillStyle": "solid",
-  "frameId": null,
-  "groupIds": [
-    "inner",
-    "outer",
-  ],
-  "height": 100,
-  "id": "id2",
-  "index": "a2",
-  "isDeleted": false,
-  "link": null,
-  "locked": false,
-  "opacity": 100,
-  "roughness": 1,
-  "roundness": null,
-  "strokeColor": "#1e1e1e",
-  "strokeStyle": "solid",
-  "strokeWidth": 2,
-  "type": "rectangle",
-  "updated": 1,
-  "version": 2,
-  "width": 100,
-  "x": 200,
-  "y": 200,
-}
-`;
-
-exports[`history > multiplayer undo/redo > should support undo and redo when escape unwinds nested group editing > [end of test] number of elements 1`] = `3`;
-
-exports[`history > multiplayer undo/redo > should support undo and redo when escape unwinds nested group editing > [end of test] number of renders 1`] = `16`;
-
-exports[`history > multiplayer undo/redo > should support undo and redo when escape unwinds nested group editing > [end of test] redo stack 1`] = `[]`;
-
-exports[`history > multiplayer undo/redo > should support undo and redo when escape unwinds nested group editing > [end of test] undo stack 1`] = `
-[
-  {
-    "appState": AppStateDelta {
-      "delta": Delta {
-        "deleted": {
-          "selectedElementIds": {
-            "id0": true,
-            "id1": true,
-            "id2": true,
-          },
-          "selectedGroupIds": {
-            "outer": true,
-          },
-        },
-        "inserted": {
-          "selectedElementIds": {},
-          "selectedGroupIds": {},
-        },
-      },
-    },
-    "elements": {
-      "added": {},
-      "removed": {
-        "id0": {
-          "deleted": {
-            "angle": 0,
-            "backgroundColor": "transparent",
-            "boundElements": null,
-            "customData": undefined,
-            "fillStyle": "solid",
-            "frameId": null,
-            "groupIds": [
-              "inner",
-              "outer",
-            ],
-            "height": 100,
-            "index": "a0",
-            "isDeleted": false,
-            "link": null,
-            "locked": false,
-            "opacity": 100,
-            "roughness": 1,
-            "roundness": null,
-            "strokeColor": "#1e1e1e",
-            "strokeStyle": "solid",
-            "strokeWidth": 2,
-            "type": "rectangle",
-            "version": 2,
-            "width": 100,
-            "x": 0,
-            "y": 0,
-          },
-          "inserted": {
-            "isDeleted": true,
-            "version": 1,
-          },
-        },
-        "id1": {
-          "deleted": {
-            "angle": 0,
-            "backgroundColor": "transparent",
-            "boundElements": null,
-            "customData": undefined,
-            "fillStyle": "solid",
-            "frameId": null,
-            "groupIds": [
-              "outer",
-            ],
-            "height": 100,
-            "index": "a1",
-            "isDeleted": false,
-            "link": null,
-            "locked": false,
-            "opacity": 100,
-            "roughness": 1,
-            "roundness": null,
-            "strokeColor": "#1e1e1e",
-            "strokeStyle": "solid",
-            "strokeWidth": 2,
-            "type": "rectangle",
-            "version": 2,
-            "width": 100,
-            "x": 100,
-            "y": 100,
-          },
-          "inserted": {
-            "isDeleted": true,
-            "version": 1,
-          },
-        },
-        "id2": {
-          "deleted": {
-            "angle": 0,
-            "backgroundColor": "transparent",
-            "boundElements": null,
-            "customData": undefined,
-            "fillStyle": "solid",
-            "frameId": null,
-            "groupIds": [
-              "inner",
-              "outer",
-            ],
-            "height": 100,
-            "index": "a2",
-            "isDeleted": false,
-            "link": null,
-            "locked": false,
-            "opacity": 100,
-            "roughness": 1,
-            "roundness": null,
-            "strokeColor": "#1e1e1e",
-            "strokeStyle": "solid",
-            "strokeWidth": 2,
-            "type": "rectangle",
-            "version": 2,
-            "width": 100,
-            "x": 200,
-            "y": 200,
-          },
-          "inserted": {
-            "isDeleted": true,
-            "version": 1,
-          },
-        },
-      },
-      "updated": {},
-    },
-    "id": "id5",
-  },
-  {
-    "appState": AppStateDelta {
-      "delta": Delta {
-        "deleted": {
-          "editingGroupId": "outer",
-          "selectedElementIds": {},
-          "selectedGroupIds": {
-            "inner": true,
-          },
-        },
-        "inserted": {
-          "editingGroupId": null,
-          "selectedElementIds": {
-            "id1": true,
-          },
-          "selectedGroupIds": {
-            "outer": true,
-          },
-        },
-      },
-    },
-    "elements": {
-      "added": {},
-      "removed": {},
-      "updated": {},
-    },
-    "id": "id7",
-  },
-  {
-    "appState": AppStateDelta {
-      "delta": Delta {
-        "deleted": {
-          "editingGroupId": "inner",
-          "selectedElementIds": {},
-          "selectedGroupIds": {},
-        },
-        "inserted": {
-          "editingGroupId": "outer",
-          "selectedElementIds": {
-            "id2": true,
-          },
-          "selectedGroupIds": {
-            "inner": true,
-          },
-        },
-      },
-    },
-    "elements": {
-      "added": {},
-      "removed": {},
-      "updated": {},
-    },
-    "id": "id9",
-  },
-  {
-    "appState": AppStateDelta {
-      "delta": Delta {
-        "deleted": {
-          "editingGroupId": "outer",
-          "selectedElementIds": {
-            "id2": true,
-          },
-          "selectedGroupIds": {
-            "inner": true,
-          },
-        },
-        "inserted": {
-          "editingGroupId": "inner",
-          "selectedElementIds": {},
-          "selectedGroupIds": {},
-        },
-      },
-    },
-    "elements": {
-      "added": {},
-      "removed": {},
-      "updated": {},
-    },
-    "id": "id19",
-  },
-  {
-    "appState": AppStateDelta {
-      "delta": Delta {
-        "deleted": {
-          "editingGroupId": null,
-          "selectedElementIds": {
-            "id1": true,
-          },
-          "selectedGroupIds": {
-            "outer": true,
-          },
-        },
-        "inserted": {
-          "editingGroupId": "outer",
-          "selectedElementIds": {},
-          "selectedGroupIds": {
-            "inner": true,
-          },
-        },
-      },
-    },
-    "elements": {
-      "added": {},
-      "removed": {},
-      "updated": {},
-    },
-    "id": "id20",
-  },
-  {
-    "appState": AppStateDelta {
-      "delta": Delta {
-        "deleted": {
-          "selectedElementIds": {},
-          "selectedGroupIds": {},
-        },
-        "inserted": {
-          "selectedElementIds": {
-            "id0": true,
-            "id1": true,
-            "id2": true,
-          },
-          "selectedGroupIds": {
-            "outer": true,
-          },
-        },
-      },
-    },
-    "elements": {
-      "added": {},
-      "removed": {},
-      "updated": {},
-    },
-    "id": "id21",
-  },
-]
-`;
-
 exports[`history > multiplayer undo/redo > should update history entries after remote changes on the same properties > [end of test] appState 1`] = `
 {
   "activeEmbeddable": null,
@@ -11767,6 +11319,7 @@ exports[`history > multiplayer undo/redo > should update history entries after r
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -12027,6 +11580,7 @@ exports[`history > singleplayer undo/redo > remounting undo/redo buttons should
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -12262,6 +11816,7 @@ exports[`history > singleplayer undo/redo > should clear the redo stack on eleme
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -12499,6 +12054,7 @@ exports[`history > singleplayer undo/redo > should create entry when selecting f
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -12654,7 +12210,7 @@ exports[`history > singleplayer undo/redo > should create entry when selecting f
   ],
   "roughness": 1,
   "roundness": null,
-  "simulatePressure": false,
+  "simulatePressure": true,
   "strokeColor": "#1e1e1e",
   "strokeStyle": "solid",
   "strokeWidth": 2,
@@ -12704,7 +12260,7 @@ exports[`history > singleplayer undo/redo > should create entry when selecting f
   ],
   "roughness": 1,
   "roundness": null,
-  "simulatePressure": false,
+  "simulatePressure": true,
   "strokeColor": "#e03131",
   "strokeStyle": "solid",
   "strokeWidth": 2,
@@ -12843,7 +12399,7 @@ exports[`history > singleplayer undo/redo > should create entry when selecting f
             ],
             "roughness": 1,
             "roundness": null,
-            "simulatePressure": false,
+            "simulatePressure": true,
             "strokeColor": "#e03131",
             "strokeStyle": "solid",
             "strokeWidth": 2,
@@ -12890,6 +12446,7 @@ exports[`history > singleplayer undo/redo > should create new history entry on e
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -13100,6 +12657,7 @@ exports[`history > singleplayer undo/redo > should create new history entry on e
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -13307,6 +12865,7 @@ exports[`history > singleplayer undo/redo > should create new history entry on i
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -13608,6 +13167,7 @@ exports[`history > singleplayer undo/redo > should create new history entry on i
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -13906,6 +13466,7 @@ exports[`history > singleplayer undo/redo > should create new history entry on s
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -14151,6 +13712,7 @@ exports[`history > singleplayer undo/redo > should disable undo/redo buttons whe
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -14388,6 +13950,7 @@ exports[`history > singleplayer undo/redo > should end up with no history entry
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -14625,6 +14188,7 @@ exports[`history > singleplayer undo/redo > should iterate through the history w
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -14872,6 +14436,7 @@ exports[`history > singleplayer undo/redo > should not clear the redo stack on s
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -15203,6 +14768,7 @@ exports[`history > singleplayer undo/redo > should not collapse when applying co
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -15373,6 +14939,7 @@ exports[`history > singleplayer undo/redo > should not end up with history entry
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -15657,6 +15224,7 @@ exports[`history > singleplayer undo/redo > should not end up with history entry
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -15920,6 +15488,7 @@ exports[`history > singleplayer undo/redo > should not modify anything on unrela
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -16073,6 +15642,7 @@ exports[`history > singleplayer undo/redo > should not override appstate changes
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -16355,6 +15925,7 @@ exports[`history > singleplayer undo/redo > should support appstate name or view
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -16517,6 +16088,7 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -17266,6 +16838,7 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -17913,6 +17486,7 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -18560,6 +18134,7 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -19310,6 +18885,7 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -20079,6 +19655,7 @@ exports[`history > singleplayer undo/redo > should support changes in elements'
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -20559,6 +20136,7 @@ exports[`history > singleplayer undo/redo > should support duplication of groups
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -21070,6 +20648,7 @@ exports[`history > singleplayer undo/redo > should support element creation, del
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -21529,6 +21108,7 @@ exports[`history > singleplayer undo/redo > should support linear element creati
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",

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

@@ -24,6 +24,7 @@ exports[`given element A and group of elements B and given both are selected whe
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -450,6 +451,7 @@ exports[`given element A and group of elements B and given both are selected whe
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -866,6 +868,7 @@ exports[`regression tests > Cmd/Ctrl-click exclusively select element under poin
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -1432,6 +1435,7 @@ exports[`regression tests > Drags selected element when hitting only bounding bo
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -1639,6 +1643,7 @@ exports[`regression tests > adjusts z order when grouping > [end of test] appSta
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -2023,6 +2028,7 @@ exports[`regression tests > alt-drag duplicates an element > [end of test] appSt
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -2268,6 +2274,7 @@ exports[`regression tests > arrow keys > [end of test] appState 1`] = `
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -2448,6 +2455,7 @@ exports[`regression tests > can drag element that covers another element, while
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -2773,6 +2781,7 @@ exports[`regression tests > change the properties of a shape > [end of test] app
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -3028,6 +3037,7 @@ exports[`regression tests > click on an element and drag it > [dragged] appState
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -3269,6 +3279,7 @@ exports[`regression tests > click on an element and drag it > [end of test] appS
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -3505,6 +3516,7 @@ exports[`regression tests > click to select a shape > [end of test] appState 1`]
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -3763,6 +3775,7 @@ exports[`regression tests > click-drag to select a group > [end of test] appStat
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -4077,6 +4090,7 @@ exports[`regression tests > deleting last but one element in editing group shoul
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -4513,6 +4527,7 @@ exports[`regression tests > deselects group of selected elements on pointer down
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -4796,6 +4811,7 @@ exports[`regression tests > deselects group of selected elements on pointer up w
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -5072,6 +5088,7 @@ exports[`regression tests > deselects selected element on pointer down when poin
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -5280,6 +5297,7 @@ exports[`regression tests > deselects selected element, on pointer up, when clic
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -5480,6 +5498,7 @@ exports[`regression tests > double click to edit a group > [end of test] appStat
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -5873,6 +5892,7 @@ exports[`regression tests > drags selected elements from point inside common bou
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -6170,6 +6190,7 @@ exports[`regression tests > draw every type of shape > [end of test] appState 1`
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -6912,7 +6933,7 @@ exports[`regression tests > draw every type of shape > [end of test] undo stack
             ],
             "roughness": 1,
             "roundness": null,
-            "simulatePressure": false,
+            "simulatePressure": true,
             "strokeColor": "#1e1e1e",
             "strokeStyle": "solid",
             "strokeWidth": 2,
@@ -6959,6 +6980,7 @@ exports[`regression tests > given a group of selected elements with an element t
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -7293,6 +7315,7 @@ exports[`regression tests > given a selected element A and a not selected elemen
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -7572,6 +7595,7 @@ exports[`regression tests > given selected element A with lower z-index than uns
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -7807,6 +7831,7 @@ exports[`regression tests > given selected element A with lower z-index than uns
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -8047,6 +8072,7 @@ exports[`regression tests > key 2 selects rectangle tool > [end of test] appStat
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -8227,6 +8253,7 @@ exports[`regression tests > key 3 selects diamond tool > [end of test] appState
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -8407,6 +8434,7 @@ exports[`regression tests > key 4 selects ellipse tool > [end of test] appState
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -8587,6 +8615,7 @@ exports[`regression tests > key 5 selects arrow tool > [end of test] appState 1`
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -8820,6 +8849,7 @@ exports[`regression tests > key 6 selects line tool > [end of test] appState 1`]
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -9051,6 +9081,7 @@ exports[`regression tests > key 7 selects freedraw tool > [end of test] appState
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -9196,7 +9227,7 @@ exports[`regression tests > key 7 selects freedraw tool > [end of test] undo sta
             ],
             "roughness": 1,
             "roundness": null,
-            "simulatePressure": false,
+            "simulatePressure": true,
             "strokeColor": "#1e1e1e",
             "strokeStyle": "solid",
             "strokeWidth": 2,
@@ -9243,6 +9274,7 @@ exports[`regression tests > key a selects arrow tool > [end of test] appState 1`
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -9476,6 +9508,7 @@ exports[`regression tests > key d selects diamond tool > [end of test] appState
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -9656,6 +9689,7 @@ exports[`regression tests > key l selects line tool > [end of test] appState 1`]
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -9887,6 +9921,7 @@ exports[`regression tests > key o selects ellipse tool > [end of test] appState
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -10067,6 +10102,7 @@ exports[`regression tests > key p selects freedraw tool > [end of test] appState
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -10212,7 +10248,7 @@ exports[`regression tests > key p selects freedraw tool > [end of test] undo sta
             ],
             "roughness": 1,
             "roundness": null,
-            "simulatePressure": false,
+            "simulatePressure": true,
             "strokeColor": "#1e1e1e",
             "strokeStyle": "solid",
             "strokeWidth": 2,
@@ -10259,6 +10295,7 @@ exports[`regression tests > key r selects rectangle tool > [end of test] appStat
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -10439,6 +10476,7 @@ exports[`regression tests > make a group and duplicate it > [end of test] appSta
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -10970,6 +11008,7 @@ exports[`regression tests > noop interaction after undo shouldn't create history
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -11250,6 +11289,7 @@ exports[`regression tests > pinch-to-zoom works > [end of test] appState 1`] = `
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -11373,6 +11413,7 @@ exports[`regression tests > shift click on selected element should deselect it o
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -11573,6 +11614,7 @@ exports[`regression tests > shift-click to multiselect, then drag > [end of test
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -11892,6 +11934,7 @@ exports[`regression tests > should group elements and ungroup them > [end of tes
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -12321,6 +12364,7 @@ exports[`regression tests > single-clicking on a subgroup of a selected group sh
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -12961,6 +13005,7 @@ exports[`regression tests > spacebar + drag scrolls the canvas > [end of test] a
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -13087,6 +13132,7 @@ exports[`regression tests > supports nested groups > [end of test] appState 1`]
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -13718,6 +13764,7 @@ exports[`regression tests > switches from group of selected elements to another
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -14057,6 +14104,7 @@ exports[`regression tests > switches selected element on pointer down > [end of
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -14321,6 +14369,7 @@ exports[`regression tests > two-finger scroll works > [end of test] appState 1`]
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -14444,6 +14493,7 @@ exports[`regression tests > undo/redo drawing an element > [end of test] appStat
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -14809,6 +14859,7 @@ exports[`regression tests > updates fontSize & fontFamily appState > [end of tes
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 8,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",
@@ -14932,6 +14983,7 @@ exports[`regression tests > zoom hotkeys > [end of test] appState 1`] = `
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",

packages/excalidraw/tests/animation.test.ts

@@ -0,0 +1,73 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import { AnimationController } from "../renderer/animation";
+
+const FIRST_KEY = "animation-test-first";
+const SECOND_KEY = "animation-test-second";
+
+describe("AnimationController", () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    window.EXCALIDRAW_THROTTLE_RENDER = false;
+  });
+
+  afterEach(() => {
+    AnimationController.cancel(FIRST_KEY);
+    AnimationController.cancel(SECOND_KEY);
+    window.EXCALIDRAW_THROTTLE_RENDER = undefined;
+    vi.useRealTimers();
+  });
+
+  it("starts a new animation after the previous last animation was cancelled", async () => {
+    let firstFrames = 0;
+    AnimationController.start(FIRST_KEY, () => {
+      firstFrames++;
+      return { keep: true };
+    });
+
+    expect(firstFrames).toBe(1);
+
+    AnimationController.cancel(FIRST_KEY);
+    await vi.runOnlyPendingTimersAsync();
+
+    let secondFrames = 0;
+    AnimationController.start(SECOND_KEY, () => {
+      secondFrames++;
+      return secondFrames === 1 ? { keep: true } : null;
+    });
+
+    expect(secondFrames).toBe(1);
+
+    await vi.runOnlyPendingTimersAsync();
+
+    expect(secondFrames).toBe(2);
+    expect(AnimationController.running(SECOND_KEY)).toBe(false);
+  });
+
+  it("cancels a frame scheduled during a tick if no animations remain", async () => {
+    let firstFrames = 0;
+    let secondFrames = 0;
+
+    AnimationController.start(FIRST_KEY, ({ state }) => {
+      if (!state) {
+        return { keep: true };
+      }
+
+      firstFrames++;
+
+      AnimationController.start(SECOND_KEY, () => {
+        secondFrames++;
+        return { keep: true };
+      });
+      AnimationController.cancel(SECOND_KEY);
+
+      return null;
+    });
+
+    await vi.runOnlyPendingTimersAsync();
+
+    expect(firstFrames).toBe(1);
+    expect(secondFrames).toBe(1);
+    expect(vi.getTimerCount()).toBe(0);
+  });
+});

packages/excalidraw/tests/data/restore.test.ts

@@ -160,6 +160,39 @@ describe("restoreElements", () => {
     });
   });
 
+  it("should restore only valid freedraw points and keep pressures aligned", () => {
+    const freedrawElement = API.createElement({
+      type: "freedraw",
+      id: "id-freedraw-invalid-points",
+      points: [pointFrom(0, 0), pointFrom(10, 10)],
+    });
+
+    const restoredFreedraw = restore.restoreElements(
+      [
+        {
+          ...freedrawElement,
+          simulatePressure: false,
+          points: [
+            pointFrom(0, 0),
+            [Infinity, 10],
+            null,
+            pointFrom(20, 20),
+            [NaN, 30],
+            [40, null],
+          ],
+          pressures: [0.1, 0.2, 0.3, 0.4, 0.5, 0.6],
+        } as any,
+      ],
+      null,
+    )[0] as ExcalidrawFreeDrawElement;
+
+    expect(restoredFreedraw.points).toEqual([
+      pointFrom(0, 0),
+      pointFrom(20, 20),
+    ]);
+    expect(restoredFreedraw.pressures).toEqual([0.1, 0.4]);
+  });
+
   it("should restore line and draw elements correctly", () => {
     const lineElement = API.createElement({ type: "line", id: "id-line01" });
 
@@ -400,6 +433,52 @@ describe("restoreElements", () => {
     expect(restoredLine.points).toMatchObject(expectedLinePoints);
   });
 
+  it("should restore only valid linear points", () => {
+    const lineElement: any = API.createElement({
+      type: "line",
+      x: 10,
+      y: 20,
+      width: 100,
+      height: 200,
+    });
+    const arrowElement: any = API.createElement({
+      type: "arrow",
+      width: 100,
+      height: 200,
+    });
+
+    lineElement.points = [
+      [2, 3],
+      null,
+      [Infinity, 4],
+      [5, 7],
+      [NaN, 8],
+      [9, null],
+    ];
+    arrowElement.points = [
+      [null, 0],
+      [Infinity, 4],
+    ];
+
+    const restoredElements = restore.restoreElements(
+      [lineElement, arrowElement],
+      null,
+    );
+    const restoredLine = restoredElements[0] as ExcalidrawLinearElement;
+    const restoredArrow = restoredElements[1] as ExcalidrawArrowElement;
+
+    expect(restoredLine.points).toEqual([pointFrom(0, 0), pointFrom(3, 4)]);
+    expect(restoredLine.x).toBe(12);
+    expect(restoredLine.y).toBe(23);
+    expect(restoredLine.width).toBe(3);
+    expect(restoredLine.height).toBe(4);
+
+    expect(restoredArrow.points).toEqual([
+      pointFrom(0, 0),
+      pointFrom(100, 200),
+    ]);
+  });
+
   it("when the number of points of a line is greater or equal 2", () => {
     const lineElement_0 = API.createElement({
       type: "line",

packages/excalidraw/tests/history.test.tsx

@@ -2120,6 +2120,9 @@ describe("history", () => {
       await render(
         <Excalidraw handleKeyboardGlobally={true} isCollaborating={true} />,
       );
+      // Pin the One Euro Filter clock to a fixed value so the smoothed
+      // intermediate freedraw point is deterministic regardless of system load.
+      vi.spyOn(h.app as any, "getPointerEventTimestamp").mockReturnValue(0);
     });
 
     it("should not override remote changes on different elements", async () => {

packages/excalidraw/tests/image.test.tsx

@@ -1,4 +1,4 @@
-import { randomId, reseed } from "@excalidraw/common";
+import { MIME_TYPES, randomId, reseed } from "@excalidraw/common";
 
 import type { FileId } from "@excalidraw/element/types";
 
@@ -17,18 +17,41 @@ import {
 } from "./fixtures/constants";
 import { INITIALIZED_IMAGE_PROPS } from "./helpers/constants";
 
+import type { ExcalidrawProps } from "../types";
+
 const { h } = window;
 
 export const setupImageTest = async (
   sizes: { width: number; height: number }[],
+  props?: ExcalidrawProps,
 ) => {
-  await render(<Excalidraw autoFocus={true} handleKeyboardGlobally={true} />);
+  await render(
+    <Excalidraw autoFocus={true} handleKeyboardGlobally={true} {...props} />,
+  );
 
   h.state.height = 1000;
 
   mockMultipleHTMLImageElements(sizes.map((size) => [size.width, size.height]));
 };
 
+describe("resizeImageFile", () => {
+  beforeEach(() => {
+    vi.unstubAllGlobals();
+  });
+
+  it("returns the original file when it already fits the max dimensions", async () => {
+    mockMultipleHTMLImageElements([[100, 100]]);
+
+    const imageFile = new File([new Uint8Array([1, 2, 3])], "image.png", {
+      type: MIME_TYPES.png,
+    });
+
+    await expect(
+      blobModule.resizeImageFile(imageFile, { maxWidthOrHeight: 200 }),
+    ).resolves.toBe(imageFile);
+  });
+});
+
 describe("image insertion", () => {
   beforeEach(() => {
     vi.clearAllMocks();
@@ -112,4 +135,42 @@ describe("image insertion", () => {
 
     await assert();
   });
+
+  it("passes host-configured max image dimensions to the resize helper", async () => {
+    await setupImageTest([DEER_IMAGE_DIMENSIONS], {
+      imageOptions: { maxWidthOrHeight: 2048 },
+    });
+
+    await API.drop([
+      { kind: "file", file: await API.loadFile("./fixtures/deer.png") },
+    ]);
+
+    await waitFor(() => {
+      expect(blobModule.resizeImageFile).toHaveBeenCalledWith(
+        expect.any(File),
+        { maxWidthOrHeight: 2048 },
+      );
+    });
+  });
+
+  it("enforces host-configured max image file size", async () => {
+    await setupImageTest([DEER_IMAGE_DIMENSIONS], {
+      imageOptions: { maxFileSizeBytes: 1024 * 1024 },
+    });
+
+    await API.drop([
+      {
+        kind: "file",
+        file: new File([new Uint8Array(2 * 1024 * 1024)], "image.png", {
+          type: MIME_TYPES.png,
+        }),
+      },
+    ]);
+
+    await waitFor(() => {
+      expect(h.state.errorMessage).toBe(
+        "File is too big. Maximum allowed size is 1MB.",
+      );
+    });
+  });
 });

packages/excalidraw/tests/laser.test.tsx

@@ -10,7 +10,7 @@ import { API } from "./helpers/api";
 import { Pointer } from "./helpers/ui";
 import { act, GlobalTestState, render, waitFor } from "./test-utils";
 
-import type { ExcalidrawProps } from "../types";
+import type { Collaborator, ExcalidrawProps, SocketId } from "../types";
 
 describe("laser tool interactions", () => {
   const h = window.h;
@@ -128,4 +128,36 @@ describe("laser tool interactions", () => {
     expect(h.state.scrollY).toBe(initialScrollY);
     expect(GlobalTestState.interactiveCanvas.style.cursor).toContain("");
   });
+
+  it("cleans up remote laser trails when the last collaborator leaves", async () => {
+    await render(<Excalidraw />);
+
+    const socketId = "socket-id" as SocketId;
+    const collaborators = new Map<SocketId, Collaborator>([
+      [
+        socketId,
+        {
+          pointer: {
+            x: 10,
+            y: 10,
+            tool: "laser",
+          },
+          button: "down",
+        },
+      ],
+    ]);
+    const svgLayer = document.querySelector(".SVGLayer svg")!;
+
+    act(() => {
+      h.app.updateScene({ collaborators });
+    });
+
+    expect(svgLayer.querySelectorAll("path")).toHaveLength(1);
+
+    act(() => {
+      h.app.updateScene({ collaborators: new Map() });
+    });
+
+    expect(svgLayer.querySelectorAll("path")).toHaveLength(0);
+  });
 });

packages/excalidraw/types.ts

@@ -363,6 +363,7 @@ export interface AppState {
   currentItemBackgroundColor: string;
   currentItemFillStyle: ExcalidrawElement["fillStyle"];
   currentItemStrokeWidth: number;
+  currentItemFreedrawConstantPressure: boolean;
   currentItemStrokeStyle: ExcalidrawElement["strokeStyle"];
   currentItemRoughness: number;
   currentItemOpacity: number;
@@ -645,6 +646,10 @@ export interface ExcalidrawProps {
     appState: UIAppState,
   ) => JSX.Element;
   UIOptions?: Partial<UIOptions>;
+  /**
+   * dimensions and size constraints for inserted images
+   */
+  imageOptions?: ImageOptions;
   detectScroll?: boolean;
   handleKeyboardGlobally?: boolean;
   onLibraryChange?: (libraryItems: LibraryItems) => void | Promise<any>;
@@ -731,6 +736,11 @@ export type ExportOpts = {
   ) => JSX.Element;
 };
 
+export type ImageOptions = Partial<{
+  maxWidthOrHeight: number;
+  maxFileSizeBytes: number;
+}>;
+
 // NOTE at the moment, if action name corresponds to canvasAction prop, its
 // truthiness value will determine whether the action is rendered or not
 // (see manager renderAction). We also override canvasAction values in
@@ -772,6 +782,7 @@ export type AppProps = Merge<
         canvasActions: Required<CanvasActions> & { export: ExportOpts };
       }
     >;
+    imageOptions: Required<ImageOptions>;
     detectScroll: boolean;
     handleKeyboardGlobally: boolean;
     isCollaborating: boolean;
@@ -899,7 +910,10 @@ export type PointerDownState = Readonly<{
   // We need to have these in the state so that we can unsubscribe them
   eventListeners: {
     // It's defined on the initial pointer down event
-    onMove: null | ReturnType<typeof throttleRAF>;
+    onMove:
+      | null
+      | ReturnType<typeof throttleRAF>
+      | (((event: PointerEvent) => void) & { flush(): void; cancel(): void });
     // It's defined on the initial pointer down event
     onUp: null | ((event: PointerEvent) => void);
     // It's defined on the initial pointer down event

packages/excalidraw/wysiwyg/textWysiwyg.tsx

@@ -392,10 +392,10 @@ export const textWysiwyg = ({
         ),
         textAlign,
         verticalAlign,
-        color:
+        color: applyDarkModeFilter(
-          appState.theme === THEME.DARK
+          updatedTextElement.strokeColor,
-            ? applyDarkModeFilter(updatedTextElement.strokeColor)
+          appState.theme === THEME.DARK,
-            : updatedTextElement.strokeColor,
+        ),
         opacity: updatedTextElement.opacity / 100,
         maxHeight: `${editorMaxHeight}px`,
       });

packages/math/src/point.ts

@@ -1,5 +1,5 @@
 import { degreesToRadians } from "./angle";
-import { PRECISION } from "./utils";
+import { isFiniteNumber, PRECISION } from "./utils";
 import { vectorFromPoint, vectorScale } from "./vector";
 
 import type {
@@ -253,3 +253,12 @@ export const isPointWithinBounds = <P extends GlobalPoint | LocalPoint>(
     q[1] >= Math.min(p[1], r[1])
   );
 };
+
+export const isValidPoint = (point: unknown): point is LocalPoint => {
+  return (
+    Array.isArray(point) &&
+    point.length === 2 &&
+    isFiniteNumber(point[0]) &&
+    isFiniteNumber(point[1])
+  );
+};

packages/utils/package.json

@@ -52,7 +52,6 @@
     "@excalidraw/laser-pointer": "1.3.1",
     "browser-fs-access": "0.38.0",
     "pako": "2.0.3",
-    "perfect-freehand": "1.2.0",
     "png-chunk-text": "1.0.0",
     "png-chunks-encode": "1.0.0",
     "png-chunks-extract": "1.0.0",

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

@@ -24,6 +24,7 @@ exports[`exportToSvg > with default arguments 1`] = `
   "currentItemFillStyle": "solid",
   "currentItemFontFamily": 5,
   "currentItemFontSize": 20,
+  "currentItemFreedrawConstantPressure": true,
   "currentItemOpacity": 100,
   "currentItemRoughness": 1,
   "currentItemRoundness": "sharp",

yarn.lock

@@ -8376,11 +8376,6 @@ pepjs@0.5.3:
   resolved "https://registry.yarnpkg.com/pepjs/-/pepjs-0.5.3.tgz#dc755f03d965c20e4b1bb65e42a03a97c382cfc7"
   integrity sha512-5yHVB9OHqKd9fr/OIsn8ss0NgThQ9buaqrEuwr9Or5YjPp6h+WTDKWZI+xZLaBGZCtODTnFtlSHNmhFsq67THg==
 
-perfect-freehand@1.2.0:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/perfect-freehand/-/perfect-freehand-1.2.0.tgz#706a0f854544f6175772440c51d3b0563eb3988a"
-  integrity sha512-h/0ikF1M3phW7CwpZ5MMvKnfpHficWoOEyr//KVNTxV4F6deRK1eYMtHyBKEAKFK0aXIEUK9oBvlF6PNXMDsAw==
-
 pica@7.1.1, pica@^7.1.0:
   version "7.1.1"
   resolved "https://registry.yarnpkg.com/pica/-/pica-7.1.1.tgz#c68b42f5cfa6cc26eaec5cfa10cc0a5299ef3b7a"