fix ts

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

excalidraw-app/components/DebugCanvas.tsx

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

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

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

packages/element/src/bounds.ts

@@ -789,27 +789,41 @@ export const getArrowheadPoints = (
     p0 = pointFrom(prevOp.data[4], prevOp.data[5]);
   }
 
-  // B(t) = p0 * (1-t)^3 + 3p1 * t * (1-t)^2 + 3p2 * t^2 * (1-t) + p3 * t^3
-  const equation = (t: number, idx: number) =>
-    Math.pow(1 - t, 3) * p3[idx] +
-    3 * t * Math.pow(1 - t, 2) * p2[idx] +
-    3 * Math.pow(t, 2) * (1 - t) * p1[idx] +
-    p0[idx] * Math.pow(t, 3);
-
-  // Ee know the last point of the arrow (or the first, if start arrowhead).
+  // We know the last point of the arrow (or the first, if start arrowhead).
   const [x2, y2] = position === "start" ? p0 : p3;
 
-  // By using cubic bezier equation (B(t)) and the given parameters,
-  // we calculate a point that is closer to the last point.
-  // The value 0.3 is chosen arbitrarily and it works best for all
-  // the tested cases.
-  const [x1, y1] = [equation(0.3, 0), equation(0.3, 1)];
-
-  // Find the normalized direction vector based on the
-  // previously calculated points.
-  const distance = Math.hypot(x2 - x1, y2 - y1);
-  const nx = (x2 - x1) / distance;
-  const ny = (y2 - y1) / distance;
+  // Use the analytic tangent at the Bézier endpoint for a precise arrowhead
+  // direction. For a cubic Bézier B(t) with control points p0p3:
+  //   B'(1): (p3 − p2) tangent at the end
+  //   B'(0): (p1 − p0) for start arrowhead, arrow points away: (p0 − p1)
+  let dx: number;
+  let dy: number;
+  if (position === "end") {
+    dx = p3[0] - p2[0];
+    dy = p3[1] - p2[1];
+    if (Math.hypot(dx, dy) < 1e-6) {
+      dx = p3[0] - p1[0];
+      dy = p3[1] - p1[1];
+    }
+    if (Math.hypot(dx, dy) < 1e-6) {
+      dx = p3[0] - p0[0];
+      dy = p3[1] - p0[1];
+    }
+  } else {
+    dx = p0[0] - p1[0];
+    dy = p0[1] - p1[1];
+    if (Math.hypot(dx, dy) < 1e-6) {
+      dx = p0[0] - p2[0];
+      dy = p0[1] - p2[1];
+    }
+    if (Math.hypot(dx, dy) < 1e-6) {
+      dx = p0[0] - p3[0];
+      dy = p0[1] - p3[1];
+    }
+  }
+  const distance = Math.hypot(dx, dy);
+  const nx = dx / distance;
+  const ny = dy / distance;
 
   const size = getArrowheadSize(arrowhead);
 

packages/element/src/collision.ts

@@ -465,12 +465,7 @@ export const intersectElementWithLineSegment = (
     case "line":
     case "freedraw":
     case "arrow":
-      return intersectLinearOrFreeDrawWithLineSegment(
-        element,
-        line,
-        elementsMap,
-        onlyFirst,
-      );
+      return intersectLinearOrFreeDrawWithLineSegment(element, line, onlyFirst);
   }
 };
 
@@ -537,15 +532,11 @@ const lineIntersections = (
 const intersectLinearOrFreeDrawWithLineSegment = (
   element: ExcalidrawLinearElement | ExcalidrawFreeDrawElement,
   segment: LineSegment<GlobalPoint>,
-  elementsMap: ElementsMap,
   onlyFirst = false,
 ): GlobalPoint[] => {
   // NOTE: This is the only one which return the decomposed elements
   // rotated! This is due to taking advantage of roughjs definitions.
-  const [lines, curves] = deconstructLinearOrFreeDrawElement(
-    element,
-    elementsMap,
-  );
+  const [lines, curves] = deconstructLinearOrFreeDrawElement(element);
   const intersections: GlobalPoint[] = [];
 
   for (const l of lines) {

packages/element/src/distance.ts

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

packages/element/src/linearElementEditor.ts

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

packages/element/src/shape.ts

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

packages/element/src/textElement.ts

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

packages/element/src/utils.ts

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

packages/element/tests/bounds.test.ts

@@ -135,9 +135,9 @@ describe("getElementBounds", () => {
     } as ExcalidrawLinearElement;
 
     const [x1, y1, x2, y2] = getElementBounds(element, arrayToMap([element]));
-    expect(x1).toEqual(360.9291017525165);
-    expect(y1).toEqual(185.24770129343722);
-    expect(x2).toEqual(481.4815539037601);
-    expect(y2).toEqual(319.8162855827246);
+    expect(x1).toEqual(360.3176068760539);
+    expect(y1).toEqual(185.90654264413516);
+    expect(x2).toEqual(486.6924560404731);
+    expect(y2).toEqual(320.391865303557);
   });
 });

packages/element/tests/linearElementEditor.test.tsx

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

packages/excalidraw/components/App.tsx

@@ -6995,23 +6995,27 @@ class App extends React.Component<AppProps, AppState> {
           },
           { informMutation: false, isDragging: false },
         );
-        const newLastIdx = multiElement.points.length - 1;
         this.setState({
           selectedLinearElement: {
             ...selectedLinearElement,
-            selectedPointsIndices: selectedLinearElement.selectedPointsIndices
-              ? [
-                  ...new Set(
-                    selectedLinearElement.selectedPointsIndices.map((idx) =>
-                      Math.min(idx, newLastIdx),
+            selectedPointsIndices:
+              selectedLinearElement.selectedPointsIndices?.includes(
+                multiElement.points.length,
+              )
+                ? [
+                    ...selectedLinearElement.selectedPointsIndices.filter(
+                      (idx) =>
+                        idx !== multiElement.points.length &&
+                        idx !== multiElement.points.length - 1,
                     ),
-                  ),
-                ]
-              : selectedLinearElement.selectedPointsIndices,
-            lastCommittedPoint: multiElement.points[newLastIdx],
+                    multiElement.points.length - 1,
+                  ]
+                : selectedLinearElement.selectedPointsIndices,
+            lastCommittedPoint:
+              multiElement.points[multiElement.points.length - 1],
             initialState: {
               ...selectedLinearElement.initialState,
-              lastClickedPoint: newLastIdx,
+              lastClickedPoint: multiElement.points.length - 1,
             },
           },
         });

packages/excalidraw/components/TTDDialog/Chat/Chat.scss

@@ -3,25 +3,7 @@
 $verticalBreakpoint: 861px;
 
 .excalidraw {
-  --ttd-mermaid-token-keyword: #0000ff;
-  --ttd-mermaid-token-string: #a31515;
-  --ttd-mermaid-token-comment: #008000;
-  --ttd-mermaid-token-number: #098658;
-  --ttd-mermaid-token-operator: #1e1e1e;
-  --ttd-mermaid-token-punctuation: #1e1e1e;
-  --ttd-mermaid-token-variable-name: #001080;
-  --ttd-mermaid-token-bracket: #af00db;
-
   &.theme--dark {
-    --ttd-mermaid-token-keyword: #569cd6;
-    --ttd-mermaid-token-string: #ce9178;
-    --ttd-mermaid-token-comment: #6a9955;
-    --ttd-mermaid-token-number: #b5cea8;
-    --ttd-mermaid-token-operator: #d4d4d4;
-    --ttd-mermaid-token-punctuation: #d4d4d4;
-    --ttd-mermaid-token-variable-name: #9cdcfe;
-    --ttd-mermaid-token-bracket: #ffd700;
-
     .chat-message {
       &--assistant {
         .chat-message__content {
@@ -212,7 +194,7 @@ $verticalBreakpoint: 861px;
       align-items: flex-start;
 
       .chat-message__content {
-        background: #f7f7f7;
+        background: var(--color-surface-low);
         color: var(--color-on-surface);
         border-radius: var(--border-radius-md);
         min-width: 6rem;
@@ -310,51 +292,6 @@ $verticalBreakpoint: 861px;
       word-wrap: break-word;
     }
 
-    &__text--error {
-      color: inherit;
-    }
-
-    &__text--mermaid {
-      overflow-x: auto;
-      font-weight: 400;
-    }
-
-    &__token {
-      white-space: inherit;
-    }
-
-    &__token--keyword {
-      color: var(--ttd-mermaid-token-keyword);
-    }
-
-    &__token--string {
-      color: var(--ttd-mermaid-token-string);
-    }
-
-    &__token--comment {
-      color: var(--ttd-mermaid-token-comment);
-    }
-
-    &__token--number {
-      color: var(--ttd-mermaid-token-number);
-    }
-
-    &__token--operator {
-      color: var(--ttd-mermaid-token-operator);
-    }
-
-    &__token--punctuation {
-      color: var(--ttd-mermaid-token-punctuation);
-    }
-
-    &__token--variableName {
-      color: var(--ttd-mermaid-token-variable-name);
-    }
-
-    &__token--bracket {
-      color: var(--ttd-mermaid-token-bracket);
-    }
-
     &__cursor {
       display: inline-block;
       margin-left: 2px;
@@ -395,13 +332,11 @@ $verticalBreakpoint: 861px;
     &__error {
       color: var(--color-danger);
       font-weight: 500;
+      white-space: pre-wrap;
+      word-wrap: break-word;
       display: flex;
       flex-direction: column;
       gap: 0.5rem;
-
-      .chat-message__text--mermaid {
-        color: var(--color-on-surface);
-      }
     }
 
     &__error_message {

packages/excalidraw/components/TTDDialog/Chat/ChatMessage.tsx

@@ -5,49 +5,8 @@ import { t } from "../../../i18n";
 import { FilledButton } from "../../FilledButton";
 import { TrashIcon, codeIcon, stackPushIcon, RetryIcon } from "../../icons";
 
-import { tokenizeMermaid } from "../mermaid-highlighting";
-
 import type { TChat, TTTDDialog } from "../types";
 
-const isMermaidMessage = (message: TChat.ChatMessage) =>
-  message.contentFormat === "mermaid";
-
-const renderMessageContent = (
-  message: TChat.ChatMessage,
-  className: string,
-) => {
-  const content = message.content ?? "";
-
-  console.log("@", message);
-
-  if (!isMermaidMessage(message)) {
-    return (
-      <div className={className}>
-        {content}
-        {message.isGenerating && (
-          <span className="chat-message__cursor">▋</span>
-        )}
-      </div>
-    );
-  }
-
-  return (
-    <div className={clsx(className, "chat-message__text--mermaid")}>
-      {tokenizeMermaid(content).map((token, index) => (
-        <span
-          key={`${index}-${token.type ?? "text"}-${token.value}`}
-          className={clsx("chat-message__token", {
-            [`chat-message__token--${token.type}`]: token.type,
-          })}
-        >
-          {token.value}
-        </span>
-      ))}
-      {message.isGenerating && <span className="chat-message__cursor">▋</span>}
-    </div>
-  );
-};
-
 export const ChatMessage: React.FC<{
   message: TChat.ChatMessage;
   onMermaidTabClick?: (message: TChat.ChatMessage) => void;
@@ -163,14 +122,7 @@ export const ChatMessage: React.FC<{
         <div className="chat-message__body">
           {message.error ? (
             <>
-              <div className="chat-message__error">
-                {renderMessageContent(
-                  message,
-                  clsx("chat-message__text", {
-                    "chat-message__text--error": !isMermaidMessage(message),
-                  }),
-                )}
-              </div>
+              <div className="chat-message__error">{message.content}</div>
               {message.errorType !== "parse" && (
                 <div className="chat-message__error_message">
                   Error: {message.error || t("chat.errors.generationFailed")}
@@ -180,7 +132,7 @@ export const ChatMessage: React.FC<{
                 <div className="chat-message__error_message">
                   <p>{t("chat.errors.invalidDiagram")}</p>
                   <div className="chat-message__error-actions">
-                    {onMermaidTabClick && isMermaidMessage(message) && (
+                    {onMermaidTabClick && (
                       <button
                         className="chat-message__error-link"
                         onClick={() => onMermaidTabClick(message)}
@@ -204,13 +156,18 @@ export const ChatMessage: React.FC<{
               )}
             </>
           ) : (
-            renderMessageContent(message, "chat-message__text")
+            <div className="chat-message__text">
+              {message.content}
+              {message.isGenerating && (
+                <span className="chat-message__cursor">▋</span>
+              )}
+            </div>
           )}
         </div>
       </div>
       {message.type === "assistant" && !message.isGenerating && (
         <div className="chat-message__actions">
-          {!message.error && onInsertMessage && isMermaidMessage(message) && (
+          {!message.error && onInsertMessage && (
             <button
               className="chat-message__action"
               onClick={() => onInsertMessage(message)}
@@ -221,7 +178,7 @@ export const ChatMessage: React.FC<{
               {stackPushIcon}
             </button>
           )}
-          {onMermaidTabClick && isMermaidMessage(message) && message.content && (
+          {onMermaidTabClick && message.content && (
             <button
               className="chat-message__action"
               onClick={() => onMermaidTabClick(message)}

packages/excalidraw/components/TTDDialog/Chat/TTDChatPanel.tsx

@@ -25,7 +25,6 @@ export const TTDChatPanel = ({
   onGenerate,
   isGenerating,
   generatedResponse,
-  generatedResponseFormat,
   isMenuOpen,
   onMenuToggle,
   onMenuClose,
@@ -51,7 +50,6 @@ export const TTDChatPanel = ({
   onGenerate: TTTDDialog.OnGenerate;
   isGenerating: boolean;
   generatedResponse: string | null | undefined;
-  generatedResponseFormat?: TChat.ChatMessage["contentFormat"];
 
   isMenuOpen: boolean;
   onMenuToggle: () => void;
@@ -91,7 +89,7 @@ export const TTDChatPanel = ({
       });
     }
 
-    if (generatedResponse && generatedResponseFormat === "mermaid") {
+    if (generatedResponse) {
       actions.push({
         action: onViewAsMermaid,
         label: t("chat.viewAsMermaid"),

packages/excalidraw/components/TTDDialog/Chat/useChatAgent.ts

@@ -25,7 +25,6 @@ export const useChatAgent = () => {
         {
           type: "assistant",
           content: "",
-          contentFormat: "mermaid",
           isGenerating: true,
         },
       ]),

packages/excalidraw/components/TTDDialog/CodeMirrorEditor.tsx

@@ -1,21 +1,13 @@
 import { useEffect, useRef } from "react";
 import {
   Decoration,
-  type DecorationSet,
   EditorView,
-  ViewPlugin,
-  type ViewUpdate,
   keymap,
   lineNumbers,
   placeholder as cmPlaceholder,
   drawSelection,
 } from "@codemirror/view";
-import {
-  Compartment,
-  EditorState,
-  type Extension,
-  type Range,
-} from "@codemirror/state";
+import { Compartment, EditorState, type Extension } from "@codemirror/state";
 import {
   defaultKeymap,
   history,
@@ -48,13 +40,6 @@ const darkTheme = EditorView.theme(
     },
     ".cm-content": { caretColor: "#fff" },
     ".cm-cursor": { borderLeftColor: "#fff" },
-    ".cm-selectionBackground": {
-      backgroundColor: "rgba(86, 156, 214, 0.3)",
-    },
-    "&.cm-focused > .cm-scroller > .cm-selectionLayer .cm-selectionBackground":
-      {
-        backgroundColor: "rgba(86, 156, 214, 0.42)",
-      },
     ".cm-gutters": {
       backgroundColor: "#1e1e1e",
       color: "#858585",
@@ -63,10 +48,6 @@ const darkTheme = EditorView.theme(
     ".cm-activeLineGutter": { backgroundColor: "#2a2a2a" },
     ".cm-activeLine": { backgroundColor: "#2a2a2a" },
     ".cm-errorLine": { backgroundColor: "rgba(255, 0, 0, 0.15)" },
-    ".cm-selectedWordMatch": {
-      backgroundColor: "rgba(255, 209, 102, 0.22)",
-      borderRadius: "2px",
-    },
   },
   { dark: true },
 );
@@ -99,10 +80,6 @@ const lightTheme = EditorView.theme({
   ".cm-activeLineGutter": { backgroundColor: "#e8e8e8" },
   ".cm-activeLine": { backgroundColor: "#e8e8e8" },
   ".cm-errorLine": { backgroundColor: "rgba(255, 0, 0, 0.1)" },
-  ".cm-selectedWordMatch": {
-    backgroundColor: "rgba(255, 209, 102, 0.35)",
-    borderRadius: "2px",
-  },
 });
 
 const lightHighlight = HighlightStyle.define([
@@ -119,79 +96,6 @@ const lightHighlight = HighlightStyle.define([
 // ---- Error line decoration ----
 
 const errorLineDeco = Decoration.line({ class: "cm-errorLine" });
-const selectedWordMatchDeco = Decoration.mark({
-  class: "cm-selectedWordMatch",
-});
-
-const getSelectedWordMatchText = (state: EditorState) => {
-  const mainSelection = state.selection.main;
-  if (state.selection.ranges.length !== 1 || mainSelection.empty) {
-    return null;
-  }
-
-  const selectedWord = state.wordAt(mainSelection.from);
-  if (
-    !selectedWord ||
-    selectedWord.from !== mainSelection.from ||
-    selectedWord.to !== mainSelection.to
-  ) {
-    return null;
-  }
-
-  return state.sliceDoc(mainSelection.from, mainSelection.to);
-};
-
-const getSelectedWordMatchDecorations = (view: EditorView): DecorationSet => {
-  const selectedWord = getSelectedWordMatchText(view.state);
-  if (!selectedWord) {
-    return Decoration.none;
-  }
-
-  const selection = view.state.selection.main;
-  const ranges: Range<Decoration>[] = [];
-  const doc = view.state.doc.toString();
-  let searchFrom = 0;
-
-  while (searchFrom <= doc.length - selectedWord.length) {
-    const matchFrom = doc.indexOf(selectedWord, searchFrom);
-    if (matchFrom === -1) {
-      break;
-    }
-
-    const matchTo = matchFrom + selectedWord.length;
-    const matchWord = view.state.wordAt(matchFrom);
-    if (
-      matchWord?.from === matchFrom &&
-      matchWord.to === matchTo &&
-      (matchFrom !== selection.from || matchTo !== selection.to)
-    ) {
-      ranges.push(selectedWordMatchDeco.range(matchFrom, matchTo));
-    }
-
-    searchFrom = matchTo;
-  }
-
-  return ranges.length ? Decoration.set(ranges) : Decoration.none;
-};
-
-const selectedWordMatchExtension = ViewPlugin.fromClass(
-  class {
-    decorations: DecorationSet;
-
-    constructor(view: EditorView) {
-      this.decorations = getSelectedWordMatchDecorations(view);
-    }
-
-    update(update: ViewUpdate) {
-      if (update.docChanged || update.selectionSet) {
-        this.decorations = getSelectedWordMatchDecorations(update.view);
-      }
-    }
-  },
-  {
-    decorations: (value) => value.decorations,
-  },
-);
 
 const getErrorLineExtension = (
   errorLine: number | null | undefined,
@@ -268,7 +172,6 @@ const CodeMirrorEditor = ({
           errorLineCompartmentRef.current.of([]),
           mermaidLite(),
           drawSelection({ drawRangeCursor: true }),
-          selectedWordMatchExtension,
           ...(placeholder ? [cmPlaceholder(placeholder)] : []),
         ],
       }),

packages/excalidraw/components/TTDDialog/TextToDiagram.tsx

@@ -80,10 +80,7 @@ const TextToDiagramContent = ({
   } = useChatManagement({ persistenceAdapter });
 
   const onViewAsMermaid = () => {
-    if (
-      lastAssistantMessage?.contentFormat === "mermaid" &&
-      typeof lastAssistantMessage.content === "string"
-    ) {
+    if (typeof lastAssistantMessage?.content === "string") {
       saveMermaidDataToStorage(lastAssistantMessage.content);
       setAppState({
         openDialog: { name: "ttd", tab: "mermaid" },
@@ -209,7 +206,6 @@ const TextToDiagramContent = ({
         onGenerate={onGenerate}
         isGenerating={lastAssistantMessage?.isGenerating ?? false}
         generatedResponse={lastAssistantMessage?.content}
-        generatedResponseFormat={lastAssistantMessage?.contentFormat}
         isMenuOpen={isMenuOpen}
         onMenuToggle={handleMenuToggle}
         onMenuClose={handleMenuClose}

packages/excalidraw/components/TTDDialog/hooks/useTextGeneration.ts

@@ -88,7 +88,6 @@ export const useTextGeneration = ({
         updateAssistantContent(prev, {
           isGenerating: true,
           content: "",
-          contentFormat: "mermaid",
           error: undefined,
           errorType: undefined,
           errorDetails: undefined,

packages/excalidraw/components/TTDDialog/mermaid-highlighting.test.ts

@@ -1,40 +0,0 @@
-import {
-  getMermaidHighlightToken,
-  tokenizeMermaid,
-} from "./mermaid-highlighting";
-
-describe("mermaid highlighting", () => {
-  it("tokenizes mermaid syntax with shared token types", () => {
-    const tokens = tokenizeMermaid('flowchart LR\nA["Hello"] --> B');
-
-    expect(tokens).toEqual([
-      { type: "keyword", value: "flowchart" },
-      { type: null, value: " " },
-      { type: "keyword", value: "LR" },
-      { type: null, value: "\n" },
-      { type: "variableName", value: "A" },
-      { type: "bracket", value: "[" },
-      { type: "string", value: '"Hello"' },
-      { type: "bracket", value: "]" },
-      { type: null, value: " " },
-      { type: "operator", value: "-->" },
-      { type: null, value: " " },
-      { type: "variableName", value: "B" },
-    ]);
-  });
-
-  it("limits comment tokens to a single line", () => {
-    const tokens = tokenizeMermaid("%% comment\nflowchart TD");
-
-    expect(tokens[0]).toEqual({ type: "comment", value: "%% comment" });
-    expect(tokens[1]).toEqual({ type: null, value: "\n" });
-    expect(tokens[2]).toEqual({ type: "keyword", value: "flowchart" });
-  });
-
-  it("falls back to plain text for unsupported characters", () => {
-    expect(getMermaidHighlightToken("@node")).toEqual({
-      type: null,
-      value: "@",
-    });
-  });
-});

packages/excalidraw/components/TTDDialog/mermaid-highlighting.ts

@@ -1,79 +0,0 @@
-export type MermaidHighlightTokenType =
-  | "bracket"
-  | "comment"
-  | "keyword"
-  | "number"
-  | "operator"
-  | "punctuation"
-  | "string"
-  | "variableName";
-
-export type MermaidHighlightToken = {
-  type: MermaidHighlightTokenType | null;
-  value: string;
-};
-
-const DIAGRAM_TYPE_PATTERN =
-  /^(flowchart|graph|sequenceDiagram|classDiagram|stateDiagram|erDiagram|gantt|pie|mindmap|journey|gitGraph|timeline|quadrantChart|sankey|xychart)\b/i;
-const DIRECTION_PATTERN = /^(TB|TD|BT|RL|LR)\b/;
-const KEYWORD_PATTERN =
-  /^(subgraph|end|participant|actor|loop|alt|else|opt|par|critical|break|rect|note|over|activate|deactivate|title|section|class|style|linkStyle|classDef|click)\b/i;
-
-const MERMAID_TOKEN_RULES: ReadonlyArray<{
-  pattern: RegExp;
-  type: MermaidHighlightTokenType | null;
-}> = [
-  { pattern: /^%%[^\n]*/, type: "comment" },
-  { pattern: /^"(?:[^"\\]|\\.)*"/, type: "string" },
-  { pattern: DIAGRAM_TYPE_PATTERN, type: "keyword" },
-  { pattern: DIRECTION_PATTERN, type: "keyword" },
-  { pattern: KEYWORD_PATTERN, type: "keyword" },
-  { pattern: /^[-.=<>|ox]+>/, type: "operator" },
-  { pattern: /^<[-.=<>|ox]+/, type: "operator" },
-  { pattern: /^(--+|\.\.+|==+)/, type: "operator" },
-  { pattern: /^[[\](){}|<>]/, type: "bracket" },
-  { pattern: /^[A-Za-z_][A-Za-z0-9_]*/, type: "variableName" },
-  { pattern: /^\d+(\.\d+)?/, type: "number" },
-  { pattern: /^[,:;]/, type: "punctuation" },
-  { pattern: /^\s+/, type: null },
-];
-
-export const getMermaidHighlightToken = (
-  input: string,
-): MermaidHighlightToken | null => {
-  if (!input) {
-    return null;
-  }
-
-  for (const rule of MERMAID_TOKEN_RULES) {
-    const match = input.match(rule.pattern);
-    if (match) {
-      return {
-        type: rule.type,
-        value: match[0],
-      };
-    }
-  }
-
-  return {
-    type: null,
-    value: input[0],
-  };
-};
-
-export const tokenizeMermaid = (input: string): MermaidHighlightToken[] => {
-  const tokens: MermaidHighlightToken[] = [];
-  let remaining = input;
-
-  while (remaining) {
-    const token = getMermaidHighlightToken(remaining);
-    if (!token) {
-      break;
-    }
-
-    tokens.push(token);
-    remaining = remaining.slice(token.value.length);
-  }
-
-  return tokens;
-};

packages/excalidraw/components/TTDDialog/mermaid-lang-lite.ts

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

packages/excalidraw/components/TTDDialog/types.ts

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

packages/excalidraw/components/TTDDialog/useTTDChatStorage.ts

@@ -7,17 +7,6 @@ import { chatHistoryAtom } from "./TTDContext";
 
 import type { SavedChat, SavedChats, TTDPersistenceAdapter } from "./types";
 
-const normalizePersistedChat = (chat: SavedChat): SavedChat => ({
-  ...chat,
-  messages: chat.messages.map((message) => ({
-    ...message,
-    // Legacy TTD chats predate explicit content format metadata.
-    contentFormat:
-      message.contentFormat ??
-      (message.type === "assistant" ? "mermaid" : undefined),
-  })),
-});
-
 interface UseTTDChatStorageProps {
   persistenceAdapter: TTDPersistenceAdapter;
 }
@@ -67,7 +56,7 @@ export const useTTDChatStorage = ({
     setIsLoading(true);
     try {
       const chats = await persistenceAdapter.loadChats();
-      setSavedChats(chats.map(normalizePersistedChat));
+      setSavedChats(chats);
       setChatsLoaded(true);
     } catch (error) {
       console.warn("Failed to load chats:", error);

packages/excalidraw/components/TTDDialog/utils/chat.test.ts

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

packages/excalidraw/data/restore.ts

@@ -251,9 +251,7 @@ const repairBinding = <T extends ExcalidrawArrowElement>(
       };
     }
 
-    console.error(
-      `Could not repair binding for element "${boundElement?.id}" out of (${elementsMap?.size}) elements`,
-    );
+    console.error(`could not repair binding for element`);
   } catch (error) {
     console.error("Error repairing binding:", error);
   }

packages/excalidraw/global.d.ts

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

packages/excalidraw/index.tsx

@@ -382,8 +382,6 @@ export { DiagramToCodePlugin } from "./components/DiagramToCodePlugin/DiagramToC
 export { getDataURL } from "./data/blob";
 export { isElementLink } from "@excalidraw/element";
 
-export { Fonts } from "./fonts/Fonts";
-
 export { setCustomTextMetricsProvider } from "@excalidraw/element";
 
 export { CommandPalette } from "./components/CommandPalette/CommandPalette";

packages/excalidraw/renderer/interactiveScene.ts

@@ -42,6 +42,7 @@ import {
   isTextElement,
   LinearElementEditor,
   getActiveTextElement,
+  getSimpleArrowCurveDebugData,
 } from "@excalidraw/element";
 
 import { renderSelectionElement } from "@excalidraw/element";
@@ -1156,7 +1157,6 @@ const renderLinearPointHandles = (
           points[idx],
           idx,
           appState.zoom,
-          elementsMap,
         )
       ) {
         renderSingleLinearPoint(
@@ -1202,6 +1202,105 @@ const renderLinearPointHandles = (
   context.restore();
 };
 
+const isSimpleArrowTangentDebugEnabled = () =>
+  window.EXCALIDRAW_DEBUG_LINEAR_ARROW_TANGENTS === true;
+
+const renderSimpleArrowTangentOverlay = (
+  context: CanvasRenderingContext2D,
+  appState: InteractiveCanvasAppState,
+  element: NonDeleted<ExcalidrawArrowElement>,
+  elementsMap: RenderableElementsMap,
+) => {
+  const points = LinearElementEditor.getPointsGlobalCoordinates(
+    element,
+    elementsMap,
+  );
+  const debugData = getSimpleArrowCurveDebugData(points);
+
+  window.EXCALIDRAW_DEBUG_SELECTED_LINEAR_ARROW = debugData;
+
+  context.save();
+  context.translate(appState.scrollX, appState.scrollY);
+  context.lineWidth = 1 / appState.zoom.value;
+
+  context.setLineDash([6 / appState.zoom.value, 4 / appState.zoom.value]);
+  context.strokeStyle = "rgba(134, 142, 150, 0.75)";
+
+  for (const segment of debugData.segments) {
+    context.beginPath();
+    context.moveTo(segment.start[0], segment.start[1]);
+    context.lineTo(segment.baseCp1[0], segment.baseCp1[1]);
+    context.lineTo(segment.baseCp2[0], segment.baseCp2[1]);
+    context.lineTo(segment.end[0], segment.end[1]);
+    context.stroke();
+  }
+
+  context.setLineDash([]);
+
+  for (const segment of debugData.segments) {
+    const strokeStyle = segment.overshootsBaseline
+      ? "rgba(245, 159, 0, 0.9)"
+      : "rgba(94, 90, 216, 0.85)";
+
+    context.strokeStyle = strokeStyle;
+    context.fillStyle = "rgba(255, 255, 255, 0.95)";
+
+    context.beginPath();
+    context.moveTo(segment.start[0], segment.start[1]);
+    context.lineTo(segment.cp1[0], segment.cp1[1]);
+    context.lineTo(segment.cp2[0], segment.cp2[1]);
+    context.lineTo(segment.end[0], segment.end[1]);
+    context.stroke();
+
+    fillCircle(
+      context,
+      segment.cp1[0],
+      segment.cp1[1],
+      4 / appState.zoom.value,
+      true,
+      true,
+    );
+    fillCircle(
+      context,
+      segment.cp2[0],
+      segment.cp2[1],
+      4 / appState.zoom.value,
+      true,
+      true,
+    );
+  }
+
+  context.strokeStyle = "rgba(201, 42, 42, 0.85)";
+  context.fillStyle = "rgba(201, 42, 42, 0.95)";
+
+  for (const tangent of debugData.tangents) {
+    if (!tangent.isAdjusted) {
+      continue;
+    }
+
+    const handle = pointFrom<GlobalPoint>(
+      tangent.point[0] + tangent.scaled[0] / 3,
+      tangent.point[1] + tangent.scaled[1] / 3,
+    );
+
+    context.beginPath();
+    context.moveTo(tangent.point[0], tangent.point[1]);
+    context.lineTo(handle[0], handle[1]);
+    context.stroke();
+
+    fillCircle(
+      context,
+      tangent.point[0],
+      tangent.point[1],
+      3 / appState.zoom.value,
+      true,
+      true,
+    );
+  }
+
+  context.restore();
+};
+
 const renderFocusPointConnectionLine = (
   context: CanvasRenderingContext2D,
   appState: InteractiveCanvasAppState,
@@ -1723,6 +1822,13 @@ const _renderInteractiveScene = ({
   const selectedLinearElement =
     linearState &&
     LinearElementEditor.getElement(linearState.elementId, allElementsMap);
+  const selectedRoundedArrow =
+    selectedElements.length === 1 &&
+    isArrowElement(selectedElements[0]) &&
+    !isElbowArrow(selectedElements[0]) &&
+    !!selectedElements[0].roundness
+      ? (selectedElements[0] as NonDeleted<ExcalidrawArrowElement>)
+      : null;
   // Arrows have a different highlight behavior when
   // they are the only selected element
   if (selectedLinearElement) {
@@ -1759,6 +1865,17 @@ const _renderInteractiveScene = ({
     }
   }
 
+  if (selectedRoundedArrow && isSimpleArrowTangentDebugEnabled()) {
+    renderSimpleArrowTangentOverlay(
+      context,
+      appState,
+      selectedRoundedArrow,
+      elementsMap,
+    );
+  } else {
+    window.EXCALIDRAW_DEBUG_SELECTED_LINEAR_ARROW = undefined;
+  }
+
   // Paint selected elements
   if (
     !appState.multiElement &&

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

@@ -224,7 +224,7 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
   "strokeWidth": 2,
   "type": "arrow",
   "updated": 1,
-  "version": 22,
+  "version": 28,
   "width": "94.00000",
   "x": 0,
   "y": 0,
@@ -350,9 +350,8 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
               ],
               "mode": "orbit",
             },
-            "version": 21,
+            "version": 27,
             "width": "88.00000",
-            "y": "7.20923",
           },
           "inserted": {
             "endBinding": {
@@ -382,9 +381,8 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
               ],
               "mode": "orbit",
             },
-            "version": 20,
+            "version": 24,
             "width": "88.00000",
-            "y": "0.01000",
           },
         },
       },
@@ -439,7 +437,7 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
               ],
             ],
             "startBinding": null,
-            "version": 22,
+            "version": 28,
             "width": "94.00000",
             "x": 0,
             "y": 0,
@@ -464,7 +462,7 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
               ],
               "mode": "orbit",
             },
-            "version": 21,
+            "version": 27,
             "width": "88.00000",
             "x": 6,
             "y": "7.20923",
@@ -16256,7 +16254,7 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
   "strokeWidth": 2,
   "type": "arrow",
   "updated": 1,
-  "version": 10,
+  "version": 11,
   "width": "88.00000",
   "x": 6,
   "y": "0.01000",
@@ -16309,7 +16307,7 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
               ],
               "mode": "orbit",
             },
-            "version": 10,
+            "version": 11,
           },
           "inserted": {
             "endBinding": {
@@ -16329,7 +16327,7 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
               ],
               "mode": "orbit",
             },
-            "version": 8,
+            "version": 9,
           },
         },
       },
@@ -16638,7 +16636,7 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
             "fillStyle": "solid",
             "frameId": null,
             "groupIds": [],
-            "height": 0,
+            "height": "0.00120",
             "index": "a3",
             "isDeleted": false,
             "link": null,
@@ -16651,7 +16649,7 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
               ],
               [
                 "88.00000",
-                0,
+                "0.00120",
               ],
             ],
             "roughness": 1,
@@ -16671,14 +16669,14 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
             "strokeStyle": "solid",
             "strokeWidth": 2,
             "type": "arrow",
-            "version": 7,
+            "version": 8,
             "width": "88.00000",
             "x": 6,
-            "y": "0.01000",
+            "y": "0.00880",
           },
           "inserted": {
             "isDeleted": true,
-            "version": 6,
+            "version": 7,
           },
         },
       },
@@ -17004,7 +17002,7 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
   "strokeWidth": 2,
   "type": "arrow",
   "updated": 1,
-  "version": 10,
+  "version": 11,
   "width": "88.00000",
   "x": 6,
   "y": "0.01000",
@@ -17309,14 +17307,14 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
             "strokeStyle": "solid",
             "strokeWidth": 2,
             "type": "arrow",
-            "version": 10,
+            "version": 11,
             "width": "88.00000",
             "x": 6,
             "y": "0.01000",
           },
           "inserted": {
             "isDeleted": true,
-            "version": 8,
+            "version": 9,
           },
         },
       },
@@ -17650,7 +17648,7 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
   "strokeWidth": 2,
   "type": "arrow",
   "updated": 1,
-  "version": 10,
+  "version": 11,
   "width": "88.00000",
   "x": 6,
   "y": "0.01000",
@@ -17955,14 +17953,14 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
             "strokeStyle": "solid",
             "strokeWidth": 2,
             "type": "arrow",
-            "version": 10,
+            "version": 11,
             "width": "88.00000",
             "x": 6,
             "y": "0.01000",
           },
           "inserted": {
             "isDeleted": true,
-            "version": 8,
+            "version": 9,
           },
         },
       },
@@ -18294,7 +18292,7 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
   "strokeWidth": 2,
   "type": "arrow",
   "updated": 1,
-  "version": 10,
+  "version": 11,
   "width": "88.00000",
   "x": 6,
   "y": "0.01000",
@@ -18363,7 +18361,7 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
               ],
               "mode": "orbit",
             },
-            "version": 10,
+            "version": 11,
           },
           "inserted": {
             "endBinding": {
@@ -18375,7 +18373,7 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
               "mode": "orbit",
             },
             "startBinding": null,
-            "version": 8,
+            "version": 9,
           },
         },
         "id2": {
@@ -18652,7 +18650,7 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
             "fillStyle": "solid",
             "frameId": null,
             "groupIds": [],
-            "height": 0,
+            "height": "0.00120",
             "index": "a3",
             "isDeleted": false,
             "link": null,
@@ -18665,7 +18663,7 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
               ],
               [
                 "88.00000",
-                0,
+                "0.00120",
               ],
             ],
             "roughness": 1,
@@ -18685,14 +18683,14 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
             "strokeStyle": "solid",
             "strokeWidth": 2,
             "type": "arrow",
-            "version": 7,
+            "version": 8,
             "width": "88.00000",
             "x": 6,
-            "y": "0.01000",
+            "y": "0.00880",
           },
           "inserted": {
             "isDeleted": true,
-            "version": 6,
+            "version": 7,
           },
         },
       },
@@ -19046,7 +19044,7 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
   "strokeWidth": 2,
   "type": "arrow",
   "updated": 1,
-  "version": 11,
+  "version": 12,
   "width": "88.00000",
   "x": 6,
   "y": "0.01000",
@@ -19126,12 +19124,12 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
               ],
               "mode": "orbit",
             },
-            "version": 11,
+            "version": 12,
           },
           "inserted": {
             "endBinding": null,
             "startBinding": null,
-            "version": 9,
+            "version": 10,
           },
         },
       },
@@ -19400,7 +19398,7 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
             "fillStyle": "solid",
             "frameId": null,
             "groupIds": [],
-            "height": 0,
+            "height": "0.00120",
             "index": "a3",
             "isDeleted": false,
             "link": null,
@@ -19413,7 +19411,7 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
               ],
               [
                 "88.00000",
-                0,
+                "0.00120",
               ],
             ],
             "roughness": 1,
@@ -19433,14 +19431,14 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
             "strokeStyle": "solid",
             "strokeWidth": 2,
             "type": "arrow",
-            "version": 7,
+            "version": 8,
             "width": "88.00000",
             "x": 6,
-            "y": "0.01000",
+            "y": "0.00880",
           },
           "inserted": {
             "isDeleted": true,
-            "version": 6,
+            "version": 7,
           },
         },
       },

packages/utils/src/shape.ts

@@ -196,7 +196,7 @@ export const getEllipseShape = <Point extends GlobalPoint | LocalPoint>(
 
 export const getCurvePathOps = (shape: Drawable): Op[] => {
   // NOTE (mtolmacs): Temporary fix for extremely large elements
-  if (!shape) {
+  if (!shape || shape.sets.length === 0) {
     return [];
   }
 
@@ -205,6 +205,7 @@ export const getCurvePathOps = (shape: Drawable): Op[] => {
       return set.ops;
     }
   }
+
   return shape.sets[0].ops;
 };
 
@@ -316,26 +317,29 @@ export const getClosedCurveShape = <Point extends GlobalPoint | LocalPoint>(
     };
   }
 
-  const ops = getCurvePathOps(roughShape);
+  // Prefer the fillPath set
+  const fillPathSet = roughShape.sets.find((s) => s.type === "fillPath");
+  const ops = fillPathSet ? fillPathSet.ops : getCurvePathOps(roughShape);
 
   const points: Point[] = [];
   let odd = false;
   for (const operation of ops) {
     if (operation.op === "move") {
-      odd = !odd;
-      if (odd) {
+      if (fillPathSet) {
+        // fillPath is always a single run — no odd/even skipping needed
         points.push(pointFrom(operation.data[0], operation.data[1]));
+      } else {
+        odd = !odd;
+        if (odd) {
+          points.push(pointFrom(operation.data[0], operation.data[1]));
+        }
       }
     } else if (operation.op === "bcurveTo") {
-      if (odd) {
+      if (fillPathSet || odd) {
         points.push(pointFrom(operation.data[0], operation.data[1]));
         points.push(pointFrom(operation.data[2], operation.data[3]));
         points.push(pointFrom(operation.data[4], operation.data[5]));
       }
-    } else if (operation.op === "lineTo") {
-      if (odd) {
-        points.push(pointFrom(operation.data[0], operation.data[1]));
-      }
     }
   }
 

yarn.lock

@@ -1531,10 +1531,10 @@
   resolved "https://registry.yarnpkg.com/@excalidraw/markdown-to-text/-/markdown-to-text-0.1.2.tgz#1703705e7da608cf478f17bfe96fb295f55a23eb"
   integrity sha512-1nDXBNAojfi3oSFwJswKREkFm5wrSjqay81QlyRv2pkITG/XYB5v+oChENVBQLcxQwX4IUATWvXM5BcaNhPiIg==
 
-"@excalidraw/mermaid-to-excalidraw@2.1.1":
-  version "2.1.1"
-  resolved "https://registry.yarnpkg.com/@excalidraw/mermaid-to-excalidraw/-/mermaid-to-excalidraw-2.1.1.tgz#659c934a607dd2cf57f2a69282588ee2b0722959"
-  integrity sha512-jU+frqcxazsY+t5yOBf2mgrQy+WUrbrzA36if3SQB/Vwaf2qOJjnWxucNafgZZk/3+9xGmRotUeOviSOJG+wYA==
+"@excalidraw/mermaid-to-excalidraw@2.1.0":
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/@excalidraw/mermaid-to-excalidraw/-/mermaid-to-excalidraw-2.1.0.tgz#a5b9cf87c3185558cda7f9687d87b9937f452358"
+  integrity sha512-RMd+c2b7WzzUjhERMpKwp8PhF2/XlHDjr/zK+Gxfp8K9sVlafPYJ5OEa/GkN6edi2rBUXRfW+41WdO6L56b6Kw==
   dependencies:
     "@excalidraw/markdown-to-text" "0.1.2"
     "@mermaid-js/parser" "^0.6.3"