feat(editor): highlight duplicate matches in mermaid editor

feat(editor): highlight TTD assistant responses
fix: Rotated rounded arrow center point (#10962 )
2026-03-24 16:16:44 +01:00 · 2026-03-24 16:14:26 +01:00 · 2026-03-23 15:54:59 +01:00 · 2026-03-23 14:54:44 +00:00 · 2026-03-21 22:44:27 +01:00 · 2026-03-21 19:26:47 +01:00
32 changed files with 632 additions and 1755 deletions
@@ -3,41 +3,24 @@ 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 {
+import { arrayToMap, throttleRAF } from "@excalidraw/common";
-  arrayToMap,
+import { useCallback } from "react";
  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";
@@ -53,260 +36,11 @@ 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,
@@ -625,13 +359,6 @@ 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 &&
@@ -648,14 +375,6 @@ const _debugRenderer = (
    });
  }
  if (selectedSimpleArrowDebugState) {
    renderSelectedSimpleArrowTangentOverlay(
      context,
      appState.zoom.value,
      selectedSimpleArrowDebugState,
    );
  }
  if (window.visualDebug) {
    window.visualDebug!.data =
      window.visualDebug?.data.map((frame) =>
@@ -823,324 +542,23 @@ interface DebugCanvasProps {
 const DebugCanvas = React.forwardRef<HTMLCanvasElement, DebugCanvasProps>(
  ({ appState, scale }, ref) => {
-    const excalidrawAPI = useExcalidrawAPI();
+    const { width, height } = appState;
    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
-        <canvas
+        style={{
-          style={{
+          width,
-            width,
+          height,
-            height,
+          position: "absolute",
-            position: "absolute",
+          zIndex: 2,
-            inset: 0,
+          pointerEvents: "none",
-            zIndex: 2,
+        }}
-            pointerEvents: "none",
+        width={width * scale}
-          }}
+        height={height * scale}
-          width={width * scale}
+        ref={ref}
-          height={height * scale}
+      >
-          ref={ref}
+        Debug Canvas
-        >
+      </canvas>
          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",
              }}
            />
          );
        })}
      </>
    );
  },
 );
@@ -1822,7 +1822,7 @@ exports[`Test Transform > should transform the elements correctly when linear el
  "versionNonce": Any<Number>,
  "verticalAlign": "middle",
  "width": 120,
-  "x": 187.7545,
+  "x": 187.75450000000004,
  "y": 44.5,
 }
 `;
@@ -789,41 +789,27 @@ export const getArrowheadPoints = (
    p0 = pointFrom(prevOp.data[4], prevOp.data[5]);
  }
-  // We know the last point of the arrow (or the first, if start arrowhead).
+  // 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).
  const [x2, y2] = position === "start" ? p0 : p3;
-  // Use the analytic tangent at the Bézier endpoint for a precise arrowhead
+  // By using cubic bezier equation (B(t)) and the given parameters,
-  // direction. For a cubic Bézier B(t) with control points p0p3:
+  // we calculate a point that is closer to the last point.
-  //   B'(1): (p3 − p2) tangent at the end
+  // The value 0.3 is chosen arbitrarily and it works best for all
-  //   B'(0): (p1 − p0) for start arrowhead, arrow points away: (p0 − p1)
+  // the tested cases.
-  let dx: number;
+  const [x1, y1] = [equation(0.3, 0), equation(0.3, 1)];
-  let dy: number;
+
-  if (position === "end") {
+  // Find the normalized direction vector based on the
-    dx = p3[0] - p2[0];
+  // previously calculated points.
-    dy = p3[1] - p2[1];
+  const distance = Math.hypot(x2 - x1, y2 - y1);
-    if (Math.hypot(dx, dy) < 1e-6) {
+  const nx = (x2 - x1) / distance;
-      dx = p3[0] - p1[0];
+  const ny = (y2 - y1) / distance;
      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);
@@ -465,7 +465,12 @@ export const intersectElementWithLineSegment = (
    case "line":
    case "freedraw":
    case "arrow":
-      return intersectLinearOrFreeDrawWithLineSegment(element, line, onlyFirst);
+      return intersectLinearOrFreeDrawWithLineSegment(
        element,
        line,
        elementsMap,
        onlyFirst,
      );
  }
 };
@@ -532,11 +537,15 @@ const lineIntersections = (
 const intersectLinearOrFreeDrawWithLineSegment = (
  element: ExcalidrawLinearElement | ExcalidrawFreeDrawElement,
  segment: LineSegment<GlobalPoint>,
  elementsMap: ElementsMap,
  onlyFirst = false,
 ): GlobalPoint[] => {
  // NOTE: This is the only one which return the decomposed elements
  // rotated! This is due to taking advantage of roughjs definitions.
-  const [lines, curves] = deconstructLinearOrFreeDrawElement(element);
+  const [lines, curves] = deconstructLinearOrFreeDrawElement(
    element,
    elementsMap,
  );
  const intersections: GlobalPoint[] = [];
  for (const l of lines) {
@@ -48,7 +48,7 @@ export const distanceToElement = (
    case "line":
    case "arrow":
    case "freedraw":
-      return distanceToLinearOrFreeDraElement(element, p);
+      return distanceToLinearOrFreeDraElement(element, elementsMap, p);
  }
 };
@@ -133,9 +133,13 @@ const distanceToEllipseElement = (
 const distanceToLinearOrFreeDraElement = (
  element: ExcalidrawLinearElement | ExcalidrawFreeDrawElement,
  elementsMap: ElementsMap,
  p: GlobalPoint,
 ) => {
-  const [lines, curves] = deconstructLinearOrFreeDrawElement(element);
+  const [lines, curves] = deconstructLinearOrFreeDrawElement(
    element,
    elementsMap,
  );
  return Math.min(
    ...lines.map((s) => distanceToLineSegment(p, s)),
    ...curves.map((a) => curvePointDistance(a, p)),
@@ -476,16 +476,22 @@ export class LinearElementEditor {
      });
    }
-    invariant(
+    if (
-      lastClickedPoint > -1 &&
+      lastClickedPoint < 0 ||
-        selectedPointsIndices.includes(lastClickedPoint) &&
+      !selectedPointsIndices.includes(lastClickedPoint) ||
-        element.points[lastClickedPoint],
+      !element.points[lastClickedPoint]
-      `There must be a valid lastClickedPoint in order to drag it. selectedPointsIndices(${JSON.stringify(
+    ) {
-        selectedPointsIndices,
+      console.error(
-      )}) points(0..${
+        `There must be a valid lastClickedPoint in order to drag it. selectedPointsIndices(${JSON.stringify(
-        element.points.length - 1
+          selectedPointsIndices,
-      }) lastClickedPoint(${lastClickedPoint})`,
+        )}) points(0..${
-    );
+          element.points.length - 1
        }) lastClickedPoint(${lastClickedPoint})`,
      );
      // Fall back to the actual last point as a last resort.
      lastClickedPoint = element.points.length - 1;
    }
    // point that's being dragged (out of all selected points)
    const draggingPoint = element.points[lastClickedPoint];
@@ -784,20 +790,9 @@ 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,
@@ -805,6 +800,7 @@ export class LinearElementEditor {
          element.points[index + 1],
          index,
          appState.zoom,
          elementsMap,
        )
      ) {
        midpoints.push(null);
@@ -814,6 +810,7 @@ export class LinearElementEditor {
      const segmentMidPoint = LinearElementEditor.getSegmentMidPoint(
        element,
        index + 1,
        elementsMap,
      );
      midpoints.push(segmentMidPoint);
      index++;
@@ -901,6 +898,7 @@ export class LinearElementEditor {
    endPoint: P,
    index: number,
    zoom: Zoom,
    elementsMap: ElementsMap,
  ) {
    if (isElbowArrow(element)) {
      if (index >= 0 && index < element.points.length) {
@@ -915,7 +913,10 @@ export class LinearElementEditor {
    let distance = pointDistance(startPoint, endPoint);
    if (element.points.length > 2 && element.roundness) {
-      const [lines, curves] = deconstructLinearOrFreeDrawElement(element);
+      const [lines, curves] = deconstructLinearOrFreeDrawElement(
        element,
        elementsMap,
      );
      invariant(
        lines.length === 0 && curves.length > 0,
@@ -935,6 +936,7 @@ export class LinearElementEditor {
  static getSegmentMidPoint(
    element: NonDeleted<ExcalidrawLinearElement>,
    index: number,
    elementsMap: ElementsMap,
  ): GlobalPoint {
    if (isElbowArrow(element)) {
      invariant(
@@ -947,7 +949,10 @@ export class LinearElementEditor {
      return pointFrom<GlobalPoint>(element.x + p[0], element.y + p[1]);
    }
-    const [lines, curves] = deconstructLinearOrFreeDrawElement(element);
+    const [lines, curves] = deconstructLinearOrFreeDrawElement(
      element,
      elementsMap,
    );
    invariant(
      (lines.length === 0 && curves.length > 0) ||
@@ -1862,6 +1867,7 @@ export class LinearElementEditor {
      const midSegmentMidpoint = LinearElementEditor.getSegmentMidPoint(
        element,
        index + 1,
        elementsMap,
      );
      x = midSegmentMidpoint[0] - boundTextElement.width / 2;
@@ -2411,7 +2417,7 @@ const pointDraggingUpdates = (
    ? nextArrow.points[0]
    : endBindable
    ? updateBoundPoint(
-        element,
+        nextArrow,
        "endBinding",
        nextArrow.endBinding,
        endBindable,
@@ -2442,7 +2448,7 @@ const pointDraggingUpdates = (
      ? endLocalPoint
      : startBindable
      ? updateBoundPoint(
-          element,
+          nextArrow,
          "startBinding",
          nextArrow.startBinding,
          startBindable,
@@ -57,8 +57,8 @@ import { headingForPointIsHorizontal } from "./heading";
 import { canChangeRoundness } from "./comparisons";
 import {
  elementCenterPoint,
  getArrowheadPoints,
  getCenterForBounds,
  getDiamondPoints,
  getElementAbsoluteCoords,
 } from "./bounds";
@@ -583,7 +583,11 @@ const getArrowheadShapes = (
 export const generateLinearCollisionShape = (
  element: ExcalidrawLinearElement | ExcalidrawFreeDrawElement,
-) => {
+  elementsMap: ElementsMap,
 ): {
  op: string;
  data: number[];
 }[] => {
  const generator = new RoughGenerator();
  const options: Options = {
    seed: element.seed,
@@ -592,20 +596,7 @@ export const generateLinearCollisionShape = (
    roughness: 0,
    preserveVertices: true,
  };
-  const center = getCenterForBounds(
+  const center = elementCenterPoint(element, elementsMap);
    // Need a non-rotated center point
    element.points.reduce(
      (acc, point) => {
        return [
          Math.min(element.x + point[0], acc[0]),
          Math.min(element.y + point[1], acc[1]),
          Math.max(element.x + point[0], acc[2]),
          Math.max(element.y + point[1], acc[3]),
        ];
      },
      [Infinity, Infinity, -Infinity, -Infinity],
    ),
  );
  switch (element.type) {
    case "line":
@@ -634,34 +625,60 @@ export const generateLinearCollisionShape = (
        });
      }
-      // Rotate the same cubic ops used for rendering so hit-testing matches the
+      return generator
-      // visible arrow path.
+        .curve(points as unknown as RoughPoint[], options)
-      const rotateLocal = (lx: number, ly: number): LocalPoint => {
+        .sets[0].ops.slice(0, element.points.length)
-        const g = pointRotateRads<GlobalPoint>(
+        .map((op, i) => {
-          pointFrom<GlobalPoint>(element.x + lx, element.y + ly),
+          if (i === 0) {
-          center,
+            const p = pointRotateRads<GlobalPoint>(
-          element.angle,
+              pointFrom<GlobalPoint>(
-        );
+                element.x + op.data[0],
-        return pointFrom<LocalPoint>(g[0] - element.x, g[1] - element.y);
+                element.y + op.data[1],
-      };
+              ),
              center,
              element.angle,
            );
-      return generateSimpleArrowPathOps(points, 0.5, element.id).map((op) => {
+            return {
-        if (op.op === "bcurveTo") {
+              op: "move",
-          const rcp1 = rotateLocal(op.data[0], op.data[1]);
+              data: pointFrom<LocalPoint>(p[0] - element.x, p[1] - element.y),
-          const rcp2 = rotateLocal(op.data[2], op.data[3]);
+            };
-          const rend = rotateLocal(op.data[4], op.data[5]);
+          }
          return {
            op: "bcurveTo",
-            data: [rcp1[0], rcp1[1], rcp2[0], rcp2[1], rend[0], rend[1]],
+            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(),
          };
-        }
+        });
        return {
          op: op.op,
          data: rotateLocal(op.data[0], op.data[1]),
        };
      });
    }
    case "freedraw": {
      if (element.points.length < 2) {
@@ -903,12 +920,7 @@ const _generateElementShape = (
          ];
        }
      } else {
-        shape = [
+        shape = [generator.curve(points as unknown as RoughPoint[], options)];
          generator.path(
            generateSimpleArrowShape(points, 0.5, element.id),
            generateRoughOptions(element, true, isDarkMode),
          ),
        ];
      }
      // add lines only in arrow
@@ -992,754 +1004,10 @@ 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];
@@ -347,6 +347,7 @@ export const getContainerCenter = (
    midSegmentMidpoint = LinearElementEditor.getSegmentMidPoint(
      container,
      index + 1,
      elementsMap,
    );
  }
  return { x: midSegmentMidpoint[0], y: midSegmentMidpoint[1] };
@@ -124,6 +124,7 @@ const setElementShapesCacheEntry = <T extends ExcalidrawElement>(
 */
 export function deconstructLinearOrFreeDrawElement(
  element: ExcalidrawLinearElement | ExcalidrawFreeDrawElement,
  elementsMap: ElementsMap,
 ): [LineSegment<GlobalPoint>[], Curve<GlobalPoint>[]] {
  const cachedShape = getElementShapesCacheEntry(element, 0);
@@ -131,10 +132,7 @@ export function deconstructLinearOrFreeDrawElement(
    return cachedShape;
  }
-  const ops = generateLinearCollisionShape(element) as {
+  const ops = generateLinearCollisionShape(element, elementsMap);
    op: string;
    data: number[];
  }[];
  const lines = [];
  const curves = [];
@@ -135,9 +135,9 @@ describe("getElementBounds", () => {
    } as ExcalidrawLinearElement;
    const [x1, y1, x2, y2] = getElementBounds(element, arrayToMap([element]));
-    expect(x1).toEqual(360.3176068760539);
+    expect(x1).toEqual(360.9291017525165);
-    expect(y1).toEqual(185.90654264413516);
+    expect(y1).toEqual(185.24770129343722);
-    expect(x2).toEqual(486.6924560404731);
+    expect(x2).toEqual(481.4815539037601);
-    expect(y2).toEqual(320.391865303557);
+    expect(y2).toEqual(319.8162855827246);
  });
 });
@@ -434,12 +434,12 @@ describe("Test Linear Elements", () => {
      expect(midPointsWithRoundEdge).toMatchInlineSnapshot(`
        [
          [
-            "53.63967",
+            "54.27552",
-            "47.15774",
+            "46.16120",
          ],
          [
-            "78.65236",
+            "76.95494",
-            "44.31886",
+            "44.56052",
          ],
        ]
      `);
@@ -499,12 +499,12 @@ describe("Test Linear Elements", () => {
      expect(newMidPoints).toMatchInlineSnapshot(`
        [
          [
-            "103.63967",
+            "104.27552",
-            "67.15774",
+            "66.16120",
          ],
          [
-            "128.65236",
+            "126.95494",
-            "64.31886",
+            "64.56052",
          ],
        ]
      `);
@@ -815,12 +815,12 @@ describe("Test Linear Elements", () => {
        expect(newMidPoints).toMatchInlineSnapshot(`
          [
            [
-              "28.64089",
+              "29.28349",
-              "21.69997",
+              "20.91105",
            ],
            [
-              "82.34322",
+              "78.86048",
-              "47.57759",
+              "46.12277",
            ],
          ]
        `);
@@ -904,12 +904,12 @@ describe("Test Linear Elements", () => {
        expect(newMidPoints).toMatchInlineSnapshot(`
          [
            [
-              "53.63967",
+              "54.27552",
-              "47.15774",
+              "46.16120",
            ],
            [
-              "78.65236",
+              "76.95494",
-              "44.31886",
+              "44.56052",
            ],
          ]
        `);
@@ -1191,7 +1191,7 @@ describe("Test Linear Elements", () => {
          20,
          105,
          80,
-          "56.00000",
+          "55.45894",
          45,
        ]
      `);
@@ -1202,7 +1202,7 @@ describe("Test Linear Elements", () => {
        .toMatchInlineSnapshot(`
          {
            "height": 130,
-            "width": "367.18528",
+            "width": "366.11716",
          }
        `);
@@ -1214,7 +1214,7 @@ describe("Test Linear Elements", () => {
        ),
      ).toMatchInlineSnapshot(`
        {
-          "x": "272.18528",
+          "x": "271.11716",
          "y": 45,
        }
      `);
@@ -1231,9 +1231,9 @@ describe("Test Linear Elements", () => {
        [
          20,
          35,
-          "502.18528",
+          "501.11716",
          95,
-          "208.69244",
+          "205.45894",
          "52.50000",
        ]
      `);
@@ -6995,27 +6995,23 @@ class App extends React.Component<AppProps, AppState> {
          },
          { informMutation: false, isDragging: false },
        );
        const newLastIdx = multiElement.points.length - 1;
        this.setState({
          selectedLinearElement: {
            ...selectedLinearElement,
-            selectedPointsIndices:
+            selectedPointsIndices: selectedLinearElement.selectedPointsIndices
-              selectedLinearElement.selectedPointsIndices?.includes(
+              ? [
-                multiElement.points.length,
+                  ...new Set(
-              )
+                    selectedLinearElement.selectedPointsIndices.map((idx) =>
-                ? [
+                      Math.min(idx, newLastIdx),
                    ...selectedLinearElement.selectedPointsIndices.filter(
                      (idx) =>
                        idx !== multiElement.points.length &&
                        idx !== multiElement.points.length - 1,
                    ),
-                    multiElement.points.length - 1,
+                  ),
-                  ]
+                ]
-                : selectedLinearElement.selectedPointsIndices,
+              : selectedLinearElement.selectedPointsIndices,
-            lastCommittedPoint:
+            lastCommittedPoint: multiElement.points[newLastIdx],
              multiElement.points[multiElement.points.length - 1],
            initialState: {
              ...selectedLinearElement.initialState,
-              lastClickedPoint: multiElement.points.length - 1,
+              lastClickedPoint: newLastIdx,
            },
          },
        });
@@ -3,7 +3,25 @@
 $verticalBreakpoint: 861px;
 .excalidraw {
  --ttd-mermaid-token-keyword: #0000ff;
  --ttd-mermaid-token-string: #a31515;
  --ttd-mermaid-token-comment: #008000;
  --ttd-mermaid-token-number: #098658;
  --ttd-mermaid-token-operator: #1e1e1e;
  --ttd-mermaid-token-punctuation: #1e1e1e;
  --ttd-mermaid-token-variable-name: #001080;
  --ttd-mermaid-token-bracket: #af00db;
  &.theme--dark {
    --ttd-mermaid-token-keyword: #569cd6;
    --ttd-mermaid-token-string: #ce9178;
    --ttd-mermaid-token-comment: #6a9955;
    --ttd-mermaid-token-number: #b5cea8;
    --ttd-mermaid-token-operator: #d4d4d4;
    --ttd-mermaid-token-punctuation: #d4d4d4;
    --ttd-mermaid-token-variable-name: #9cdcfe;
    --ttd-mermaid-token-bracket: #ffd700;
    .chat-message {
      &--assistant {
        .chat-message__content {
@@ -194,7 +212,7 @@ $verticalBreakpoint: 861px;
      align-items: flex-start;
      .chat-message__content {
-        background: var(--color-surface-low);
+        background: #f7f7f7;
        color: var(--color-on-surface);
        border-radius: var(--border-radius-md);
        min-width: 6rem;
@@ -292,6 +310,51 @@ $verticalBreakpoint: 861px;
      word-wrap: break-word;
    }
    &__text--error {
      color: inherit;
    }
    &__text--mermaid {
      overflow-x: auto;
      font-weight: 400;
    }
    &__token {
      white-space: inherit;
    }
    &__token--keyword {
      color: var(--ttd-mermaid-token-keyword);
    }
    &__token--string {
      color: var(--ttd-mermaid-token-string);
    }
    &__token--comment {
      color: var(--ttd-mermaid-token-comment);
    }
    &__token--number {
      color: var(--ttd-mermaid-token-number);
    }
    &__token--operator {
      color: var(--ttd-mermaid-token-operator);
    }
    &__token--punctuation {
      color: var(--ttd-mermaid-token-punctuation);
    }
    &__token--variableName {
      color: var(--ttd-mermaid-token-variable-name);
    }
    &__token--bracket {
      color: var(--ttd-mermaid-token-bracket);
    }
    &__cursor {
      display: inline-block;
      margin-left: 2px;
@@ -332,11 +395,13 @@ $verticalBreakpoint: 861px;
    &__error {
      color: var(--color-danger);
      font-weight: 500;
      white-space: pre-wrap;
      word-wrap: break-word;
      display: flex;
      flex-direction: column;
      gap: 0.5rem;
      .chat-message__text--mermaid {
        color: var(--color-on-surface);
      }
    }
    &__error_message {
@@ -5,8 +5,49 @@ import { t } from "../../../i18n";
 import { FilledButton } from "../../FilledButton";
 import { TrashIcon, codeIcon, stackPushIcon, RetryIcon } from "../../icons";
 import { tokenizeMermaid } from "../mermaid-highlighting";
 import type { TChat, TTTDDialog } from "../types";
 const isMermaidMessage = (message: TChat.ChatMessage) =>
  message.contentFormat === "mermaid";
 const renderMessageContent = (
  message: TChat.ChatMessage,
  className: string,
 ) => {
  const content = message.content ?? "";
  console.log("@", message);
  if (!isMermaidMessage(message)) {
    return (
      <div className={className}>
        {content}
        {message.isGenerating && (
          <span className="chat-message__cursor">▋</span>
        )}
      </div>
    );
  }
  return (
    <div className={clsx(className, "chat-message__text--mermaid")}>
      {tokenizeMermaid(content).map((token, index) => (
        <span
          key={`${index}-${token.type ?? "text"}-${token.value}`}
          className={clsx("chat-message__token", {
            [`chat-message__token--${token.type}`]: token.type,
          })}
        >
          {token.value}
        </span>
      ))}
      {message.isGenerating && <span className="chat-message__cursor">▋</span>}
    </div>
  );
 };
 export const ChatMessage: React.FC<{
  message: TChat.ChatMessage;
  onMermaidTabClick?: (message: TChat.ChatMessage) => void;
@@ -122,7 +163,14 @@ export const ChatMessage: React.FC<{
        <div className="chat-message__body">
          {message.error ? (
            <>
-              <div className="chat-message__error">{message.content}</div>
+              <div className="chat-message__error">
                {renderMessageContent(
                  message,
                  clsx("chat-message__text", {
                    "chat-message__text--error": !isMermaidMessage(message),
                  }),
                )}
              </div>
              {message.errorType !== "parse" && (
                <div className="chat-message__error_message">
                  Error: {message.error || t("chat.errors.generationFailed")}
@@ -132,7 +180,7 @@ export const ChatMessage: React.FC<{
                <div className="chat-message__error_message">
                  <p>{t("chat.errors.invalidDiagram")}</p>
                  <div className="chat-message__error-actions">
-                    {onMermaidTabClick && (
+                    {onMermaidTabClick && isMermaidMessage(message) && (
                      <button
                        className="chat-message__error-link"
                        onClick={() => onMermaidTabClick(message)}
@@ -156,18 +204,13 @@ export const ChatMessage: React.FC<{
              )}
            </>
          ) : (
-            <div className="chat-message__text">
+            renderMessageContent(message, "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 && (
+          {!message.error && onInsertMessage && isMermaidMessage(message) && (
            <button
              className="chat-message__action"
              onClick={() => onInsertMessage(message)}
@@ -178,7 +221,7 @@ export const ChatMessage: React.FC<{
              {stackPushIcon}
            </button>
          )}
-          {onMermaidTabClick && message.content && (
+          {onMermaidTabClick && isMermaidMessage(message) && message.content && (
            <button
              className="chat-message__action"
              onClick={() => onMermaidTabClick(message)}
@@ -25,6 +25,7 @@ export const TTDChatPanel = ({
  onGenerate,
  isGenerating,
  generatedResponse,
  generatedResponseFormat,
  isMenuOpen,
  onMenuToggle,
  onMenuClose,
@@ -50,6 +51,7 @@ export const TTDChatPanel = ({
  onGenerate: TTTDDialog.OnGenerate;
  isGenerating: boolean;
  generatedResponse: string | null | undefined;
  generatedResponseFormat?: TChat.ChatMessage["contentFormat"];
  isMenuOpen: boolean;
  onMenuToggle: () => void;
@@ -89,7 +91,7 @@ export const TTDChatPanel = ({
      });
    }
-    if (generatedResponse) {
+    if (generatedResponse && generatedResponseFormat === "mermaid") {
      actions.push({
        action: onViewAsMermaid,
        label: t("chat.viewAsMermaid"),
@@ -25,6 +25,7 @@ export const useChatAgent = () => {
        {
          type: "assistant",
          content: "",
          contentFormat: "mermaid",
          isGenerating: true,
        },
      ]),
@@ -1,13 +1,21 @@
 import { useEffect, useRef } from "react";
 import {
  Decoration,
  type DecorationSet,
  EditorView,
  ViewPlugin,
  type ViewUpdate,
  keymap,
  lineNumbers,
  placeholder as cmPlaceholder,
  drawSelection,
 } from "@codemirror/view";
-import { Compartment, EditorState, type Extension } from "@codemirror/state";
+import {
  Compartment,
  EditorState,
  type Extension,
  type Range,
 } from "@codemirror/state";
 import {
  defaultKeymap,
  history,
@@ -40,6 +48,13 @@ const darkTheme = EditorView.theme(
    },
    ".cm-content": { caretColor: "#fff" },
    ".cm-cursor": { borderLeftColor: "#fff" },
    ".cm-selectionBackground": {
      backgroundColor: "rgba(86, 156, 214, 0.3)",
    },
    "&.cm-focused > .cm-scroller > .cm-selectionLayer .cm-selectionBackground":
      {
        backgroundColor: "rgba(86, 156, 214, 0.42)",
      },
    ".cm-gutters": {
      backgroundColor: "#1e1e1e",
      color: "#858585",
@@ -48,6 +63,10 @@ const darkTheme = EditorView.theme(
    ".cm-activeLineGutter": { backgroundColor: "#2a2a2a" },
    ".cm-activeLine": { backgroundColor: "#2a2a2a" },
    ".cm-errorLine": { backgroundColor: "rgba(255, 0, 0, 0.15)" },
    ".cm-selectedWordMatch": {
      backgroundColor: "rgba(255, 209, 102, 0.22)",
      borderRadius: "2px",
    },
  },
  { dark: true },
 );
@@ -80,6 +99,10 @@ const lightTheme = EditorView.theme({
  ".cm-activeLineGutter": { backgroundColor: "#e8e8e8" },
  ".cm-activeLine": { backgroundColor: "#e8e8e8" },
  ".cm-errorLine": { backgroundColor: "rgba(255, 0, 0, 0.1)" },
  ".cm-selectedWordMatch": {
    backgroundColor: "rgba(255, 209, 102, 0.35)",
    borderRadius: "2px",
  },
 });
 const lightHighlight = HighlightStyle.define([
@@ -96,6 +119,79 @@ const lightHighlight = HighlightStyle.define([
 // ---- Error line decoration ----
 const errorLineDeco = Decoration.line({ class: "cm-errorLine" });
 const selectedWordMatchDeco = Decoration.mark({
  class: "cm-selectedWordMatch",
 });
 const getSelectedWordMatchText = (state: EditorState) => {
  const mainSelection = state.selection.main;
  if (state.selection.ranges.length !== 1 || mainSelection.empty) {
    return null;
  }
  const selectedWord = state.wordAt(mainSelection.from);
  if (
    !selectedWord ||
    selectedWord.from !== mainSelection.from ||
    selectedWord.to !== mainSelection.to
  ) {
    return null;
  }
  return state.sliceDoc(mainSelection.from, mainSelection.to);
 };
 const getSelectedWordMatchDecorations = (view: EditorView): DecorationSet => {
  const selectedWord = getSelectedWordMatchText(view.state);
  if (!selectedWord) {
    return Decoration.none;
  }
  const selection = view.state.selection.main;
  const ranges: Range<Decoration>[] = [];
  const doc = view.state.doc.toString();
  let searchFrom = 0;
  while (searchFrom <= doc.length - selectedWord.length) {
    const matchFrom = doc.indexOf(selectedWord, searchFrom);
    if (matchFrom === -1) {
      break;
    }
    const matchTo = matchFrom + selectedWord.length;
    const matchWord = view.state.wordAt(matchFrom);
    if (
      matchWord?.from === matchFrom &&
      matchWord.to === matchTo &&
      (matchFrom !== selection.from || matchTo !== selection.to)
    ) {
      ranges.push(selectedWordMatchDeco.range(matchFrom, matchTo));
    }
    searchFrom = matchTo;
  }
  return ranges.length ? Decoration.set(ranges) : Decoration.none;
 };
 const selectedWordMatchExtension = ViewPlugin.fromClass(
  class {
    decorations: DecorationSet;
    constructor(view: EditorView) {
      this.decorations = getSelectedWordMatchDecorations(view);
    }
    update(update: ViewUpdate) {
      if (update.docChanged || update.selectionSet) {
        this.decorations = getSelectedWordMatchDecorations(update.view);
      }
    }
  },
  {
    decorations: (value) => value.decorations,
  },
 );
 const getErrorLineExtension = (
  errorLine: number | null | undefined,
@@ -172,6 +268,7 @@ const CodeMirrorEditor = ({
          errorLineCompartmentRef.current.of([]),
          mermaidLite(),
          drawSelection({ drawRangeCursor: true }),
          selectedWordMatchExtension,
          ...(placeholder ? [cmPlaceholder(placeholder)] : []),
        ],
      }),
@@ -80,7 +80,10 @@ const TextToDiagramContent = ({
  } = useChatManagement({ persistenceAdapter });
  const onViewAsMermaid = () => {
-    if (typeof lastAssistantMessage?.content === "string") {
+    if (
      lastAssistantMessage?.contentFormat === "mermaid" &&
      typeof lastAssistantMessage.content === "string"
    ) {
      saveMermaidDataToStorage(lastAssistantMessage.content);
      setAppState({
        openDialog: { name: "ttd", tab: "mermaid" },
@@ -206,6 +209,7 @@ const TextToDiagramContent = ({
        onGenerate={onGenerate}
        isGenerating={lastAssistantMessage?.isGenerating ?? false}
        generatedResponse={lastAssistantMessage?.content}
        generatedResponseFormat={lastAssistantMessage?.contentFormat}
        isMenuOpen={isMenuOpen}
        onMenuToggle={handleMenuToggle}
        onMenuClose={handleMenuClose}
@@ -88,6 +88,7 @@ export const useTextGeneration = ({
        updateAssistantContent(prev, {
          isGenerating: true,
          content: "",
          contentFormat: "mermaid",
          error: undefined,
          errorType: undefined,
          errorDetails: undefined,
@@ -0,0 +1,40 @@
 import {
  getMermaidHighlightToken,
  tokenizeMermaid,
 } from "./mermaid-highlighting";
 describe("mermaid highlighting", () => {
  it("tokenizes mermaid syntax with shared token types", () => {
    const tokens = tokenizeMermaid('flowchart LR\nA["Hello"] --> B');
    expect(tokens).toEqual([
      { type: "keyword", value: "flowchart" },
      { type: null, value: " " },
      { type: "keyword", value: "LR" },
      { type: null, value: "\n" },
      { type: "variableName", value: "A" },
      { type: "bracket", value: "[" },
      { type: "string", value: '"Hello"' },
      { type: "bracket", value: "]" },
      { type: null, value: " " },
      { type: "operator", value: "-->" },
      { type: null, value: " " },
      { type: "variableName", value: "B" },
    ]);
  });
  it("limits comment tokens to a single line", () => {
    const tokens = tokenizeMermaid("%% comment\nflowchart TD");
    expect(tokens[0]).toEqual({ type: "comment", value: "%% comment" });
    expect(tokens[1]).toEqual({ type: null, value: "\n" });
    expect(tokens[2]).toEqual({ type: "keyword", value: "flowchart" });
  });
  it("falls back to plain text for unsupported characters", () => {
    expect(getMermaidHighlightToken("@node")).toEqual({
      type: null,
      value: "@",
    });
  });
 });
@@ -0,0 +1,79 @@
 export type MermaidHighlightTokenType =
  | "bracket"
  | "comment"
  | "keyword"
  | "number"
  | "operator"
  | "punctuation"
  | "string"
  | "variableName";
 export type MermaidHighlightToken = {
  type: MermaidHighlightTokenType | null;
  value: string;
 };
 const DIAGRAM_TYPE_PATTERN =
  /^(flowchart|graph|sequenceDiagram|classDiagram|stateDiagram|erDiagram|gantt|pie|mindmap|journey|gitGraph|timeline|quadrantChart|sankey|xychart)\b/i;
 const DIRECTION_PATTERN = /^(TB|TD|BT|RL|LR)\b/;
 const KEYWORD_PATTERN =
  /^(subgraph|end|participant|actor|loop|alt|else|opt|par|critical|break|rect|note|over|activate|deactivate|title|section|class|style|linkStyle|classDef|click)\b/i;
 const MERMAID_TOKEN_RULES: ReadonlyArray<{
  pattern: RegExp;
  type: MermaidHighlightTokenType | null;
 }> = [
  { pattern: /^%%[^\n]*/, type: "comment" },
  { pattern: /^"(?:[^"\\]|\\.)*"/, type: "string" },
  { pattern: DIAGRAM_TYPE_PATTERN, type: "keyword" },
  { pattern: DIRECTION_PATTERN, type: "keyword" },
  { pattern: KEYWORD_PATTERN, type: "keyword" },
  { pattern: /^[-.=<>|ox]+>/, type: "operator" },
  { pattern: /^<[-.=<>|ox]+/, type: "operator" },
  { pattern: /^(--+|\.\.+|==+)/, type: "operator" },
  { pattern: /^[[\](){}|<>]/, type: "bracket" },
  { pattern: /^[A-Za-z_][A-Za-z0-9_]*/, type: "variableName" },
  { pattern: /^\d+(\.\d+)?/, type: "number" },
  { pattern: /^[,:;]/, type: "punctuation" },
  { pattern: /^\s+/, type: null },
 ];
 export const getMermaidHighlightToken = (
  input: string,
 ): MermaidHighlightToken | null => {
  if (!input) {
    return null;
  }
  for (const rule of MERMAID_TOKEN_RULES) {
    const match = input.match(rule.pattern);
    if (match) {
      return {
        type: rule.type,
        value: match[0],
      };
    }
  }
  return {
    type: null,
    value: input[0],
  };
 };
 export const tokenizeMermaid = (input: string): MermaidHighlightToken[] => {
  const tokens: MermaidHighlightToken[] = [];
  let remaining = input;
  while (remaining) {
    const token = getMermaidHighlightToken(remaining);
    if (!token) {
      break;
    }
    tokens.push(token);
    remaining = remaining.slice(token.value.length);
  }
  return tokens;
 };
@@ -1,79 +1,17 @@
 import { StreamLanguage } from "@codemirror/language";
 import { getMermaidHighlightToken } from "./mermaid-highlighting";
 const mermaidStreamParser = StreamLanguage.define({
  token(stream) {
-    // Comments: %%...
+    const token = getMermaidHighlightToken(stream.string.slice(stream.pos));
-    if (stream.match(/^%%.*$/)) {
+    if (!token) {
-      return "comment";
+      stream.skipToEnd();
    }
    // 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;
    }
-    // Skip any other character
+    stream.pos += token.value.length;
-    stream.next();
+    return token.type;
    return null;
  },
 });
@@ -18,6 +18,8 @@ export type MermaidData = {
  files: BinaryFiles | null;
 };
 export type ChatMessageContentFormat = "text" | "mermaid";
 export interface RateLimits {
  rateLimit: number;
  rateLimitRemaining: number;
@@ -33,6 +35,7 @@ export namespace TChat {
    errorType?: "parse" | "network" | "other";
    lastAttemptAt?: number;
    type: "user" | "assistant" | "warning";
    contentFormat?: ChatMessageContentFormat;
    warningType?: /* daily rate limit */
    "messageLimitExceeded" | /* general 429 */ "rateLimitExceeded";
    content?: string;
@@ -7,6 +7,17 @@ import { chatHistoryAtom } from "./TTDContext";
 import type { SavedChat, SavedChats, TTDPersistenceAdapter } from "./types";
 const normalizePersistedChat = (chat: SavedChat): SavedChat => ({
  ...chat,
  messages: chat.messages.map((message) => ({
    ...message,
    // Legacy TTD chats predate explicit content format metadata.
    contentFormat:
      message.contentFormat ??
      (message.type === "assistant" ? "mermaid" : undefined),
  })),
 });
 interface UseTTDChatStorageProps {
  persistenceAdapter: TTDPersistenceAdapter;
 }
@@ -56,7 +67,7 @@ export const useTTDChatStorage = ({
    setIsLoading(true);
    try {
      const chats = await persistenceAdapter.loadChats();
-      setSavedChats(chats);
+      setSavedChats(chats.map(normalizePersistedChat));
      setChatsLoaded(true);
    } catch (error) {
      console.warn("Failed to load chats:", error);
@@ -117,6 +117,28 @@ describe("chat utils", () => {
      expect(result.messages[0].errorType).toBe("network");
    });
    it("should update content format when provided", () => {
      const chatHistory: TChat.ChatHistory = {
        id: "chat-1",
        currentPrompt: "",
        messages: [
          {
            id: "1",
            type: "assistant",
            content: "graph TD",
            timestamp: new Date("2024-01-01"),
            contentFormat: "text",
          },
        ],
      };
      const result = updateAssistantContent(chatHistory, {
        contentFormat: "mermaid",
      });
      expect(result.messages[0].contentFormat).toBe("mermaid");
    });
    it("should return unchanged chatHistory if no assistant message exists", () => {
      const chatHistory: TChat.ChatHistory = {
        id: "chat-1",
@@ -357,6 +379,7 @@ describe("chat utils", () => {
        {
          type: "assistant",
          content: "Message",
          contentFormat: "mermaid",
          isGenerating: true,
          error: "Error text",
          errorType: "parse",
@@ -364,6 +387,7 @@ describe("chat utils", () => {
      ]);
      expect(result.messages[0].isGenerating).toBe(true);
      expect(result.messages[0].contentFormat).toBe("mermaid");
      expect(result.messages[0].error).toBe("Error text");
      expect(result.messages[0].errorType).toBe("parse");
    });
@@ -251,7 +251,9 @@ const repairBinding = <T extends ExcalidrawArrowElement>(
      };
    }
-    console.error(`could not repair binding for element`);
+    console.error(
      `Could not repair binding for element "${boundElement?.id}" out of (${elementsMap?.size}) elements`,
    );
  } catch (error) {
    console.error("Error repairing binding:", error);
  }
@@ -4,8 +4,6 @@ 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;
@@ -382,6 +382,8 @@ export { DiagramToCodePlugin } from "./components/DiagramToCodePlugin/DiagramToC
 export { getDataURL } from "./data/blob";
 export { isElementLink } from "@excalidraw/element";
 export { Fonts } from "./fonts/Fonts";
 export { setCustomTextMetricsProvider } from "@excalidraw/element";
 export { CommandPalette } from "./components/CommandPalette/CommandPalette";
@@ -42,7 +42,6 @@ import {
  isTextElement,
  LinearElementEditor,
  getActiveTextElement,
  getSimpleArrowCurveDebugData,
 } from "@excalidraw/element";
 import { renderSelectionElement } from "@excalidraw/element";
@@ -1157,6 +1156,7 @@ const renderLinearPointHandles = (
          points[idx],
          idx,
          appState.zoom,
          elementsMap,
        )
      ) {
        renderSingleLinearPoint(
@@ -1202,105 +1202,6 @@ 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,
@@ -1822,13 +1723,6 @@ 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) {
@@ -1865,17 +1759,6 @@ const _renderInteractiveScene = ({
    }
  }
  if (selectedRoundedArrow && isSimpleArrowTangentDebugEnabled()) {
    renderSimpleArrowTangentOverlay(
      context,
      appState,
      selectedRoundedArrow,
      elementsMap,
    );
  } else {
    window.EXCALIDRAW_DEBUG_SELECTED_LINEAR_ARROW = undefined;
  }
  // Paint selected elements
  if (
    !appState.multiElement &&
@@ -224,7 +224,7 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
  "strokeWidth": 2,
  "type": "arrow",
  "updated": 1,
-  "version": 28,
+  "version": 22,
  "width": "94.00000",
  "x": 0,
  "y": 0,
@@ -350,8 +350,9 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
              ],
              "mode": "orbit",
            },
-            "version": 27,
+            "version": 21,
            "width": "88.00000",
            "y": "7.20923",
          },
          "inserted": {
            "endBinding": {
@@ -381,8 +382,9 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
              ],
              "mode": "orbit",
            },
-            "version": 24,
+            "version": 20,
            "width": "88.00000",
            "y": "0.01000",
          },
        },
      },
@@ -437,7 +439,7 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
              ],
            ],
            "startBinding": null,
-            "version": 28,
+            "version": 22,
            "width": "94.00000",
            "x": 0,
            "y": 0,
@@ -462,7 +464,7 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
              ],
              "mode": "orbit",
            },
-            "version": 27,
+            "version": 21,
            "width": "88.00000",
            "x": 6,
            "y": "7.20923",
@@ -16254,7 +16256,7 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
  "strokeWidth": 2,
  "type": "arrow",
  "updated": 1,
-  "version": 11,
+  "version": 10,
  "width": "88.00000",
  "x": 6,
  "y": "0.01000",
@@ -16307,7 +16309,7 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
              ],
              "mode": "orbit",
            },
-            "version": 11,
+            "version": 10,
          },
          "inserted": {
            "endBinding": {
@@ -16327,7 +16329,7 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
              ],
              "mode": "orbit",
            },
-            "version": 9,
+            "version": 8,
          },
        },
      },
@@ -16636,7 +16638,7 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
            "fillStyle": "solid",
            "frameId": null,
            "groupIds": [],
-            "height": "0.00120",
+            "height": 0,
            "index": "a3",
            "isDeleted": false,
            "link": null,
@@ -16649,7 +16651,7 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
              ],
              [
                "88.00000",
-                "0.00120",
+                0,
              ],
            ],
            "roughness": 1,
@@ -16669,14 +16671,14 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
            "strokeStyle": "solid",
            "strokeWidth": 2,
            "type": "arrow",
-            "version": 8,
+            "version": 7,
            "width": "88.00000",
            "x": 6,
-            "y": "0.00880",
+            "y": "0.01000",
          },
          "inserted": {
            "isDeleted": true,
-            "version": 7,
+            "version": 6,
          },
        },
      },
@@ -17002,7 +17004,7 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
  "strokeWidth": 2,
  "type": "arrow",
  "updated": 1,
-  "version": 11,
+  "version": 10,
  "width": "88.00000",
  "x": 6,
  "y": "0.01000",
@@ -17307,14 +17309,14 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
            "strokeStyle": "solid",
            "strokeWidth": 2,
            "type": "arrow",
-            "version": 11,
+            "version": 10,
            "width": "88.00000",
            "x": 6,
            "y": "0.01000",
          },
          "inserted": {
            "isDeleted": true,
-            "version": 9,
+            "version": 8,
          },
        },
      },
@@ -17648,7 +17650,7 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
  "strokeWidth": 2,
  "type": "arrow",
  "updated": 1,
-  "version": 11,
+  "version": 10,
  "width": "88.00000",
  "x": 6,
  "y": "0.01000",
@@ -17953,14 +17955,14 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
            "strokeStyle": "solid",
            "strokeWidth": 2,
            "type": "arrow",
-            "version": 11,
+            "version": 10,
            "width": "88.00000",
            "x": 6,
            "y": "0.01000",
          },
          "inserted": {
            "isDeleted": true,
-            "version": 9,
+            "version": 8,
          },
        },
      },
@@ -18292,7 +18294,7 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
  "strokeWidth": 2,
  "type": "arrow",
  "updated": 1,
-  "version": 11,
+  "version": 10,
  "width": "88.00000",
  "x": 6,
  "y": "0.01000",
@@ -18361,7 +18363,7 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
              ],
              "mode": "orbit",
            },
-            "version": 11,
+            "version": 10,
          },
          "inserted": {
            "endBinding": {
@@ -18373,7 +18375,7 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
              "mode": "orbit",
            },
            "startBinding": null,
-            "version": 9,
+            "version": 8,
          },
        },
        "id2": {
@@ -18650,7 +18652,7 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
            "fillStyle": "solid",
            "frameId": null,
            "groupIds": [],
-            "height": "0.00120",
+            "height": 0,
            "index": "a3",
            "isDeleted": false,
            "link": null,
@@ -18663,7 +18665,7 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
              ],
              [
                "88.00000",
-                "0.00120",
+                0,
              ],
            ],
            "roughness": 1,
@@ -18683,14 +18685,14 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
            "strokeStyle": "solid",
            "strokeWidth": 2,
            "type": "arrow",
-            "version": 8,
+            "version": 7,
            "width": "88.00000",
            "x": 6,
-            "y": "0.00880",
+            "y": "0.01000",
          },
          "inserted": {
            "isDeleted": true,
-            "version": 7,
+            "version": 6,
          },
        },
      },
@@ -19044,7 +19046,7 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
  "strokeWidth": 2,
  "type": "arrow",
  "updated": 1,
-  "version": 12,
+  "version": 11,
  "width": "88.00000",
  "x": 6,
  "y": "0.01000",
@@ -19124,12 +19126,12 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
              ],
              "mode": "orbit",
            },
-            "version": 12,
+            "version": 11,
          },
          "inserted": {
            "endBinding": null,
            "startBinding": null,
-            "version": 10,
+            "version": 9,
          },
        },
      },
@@ -19398,7 +19400,7 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
            "fillStyle": "solid",
            "frameId": null,
            "groupIds": [],
-            "height": "0.00120",
+            "height": 0,
            "index": "a3",
            "isDeleted": false,
            "link": null,
@@ -19411,7 +19413,7 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
              ],
              [
                "88.00000",
-                "0.00120",
+                0,
              ],
            ],
            "roughness": 1,
@@ -19431,14 +19433,14 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
            "strokeStyle": "solid",
            "strokeWidth": 2,
            "type": "arrow",
-            "version": 8,
+            "version": 7,
            "width": "88.00000",
            "x": 6,
-            "y": "0.00880",
+            "y": "0.01000",
          },
          "inserted": {
            "isDeleted": true,
-            "version": 7,
+            "version": 6,
          },
        },
      },
@@ -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 || shape.sets.length === 0) {
+  if (!shape) {
    return [];
  }
@@ -205,7 +205,6 @@ export const getCurvePathOps = (shape: Drawable): Op[] => {
      return set.ops;
    }
  }
  return shape.sets[0].ops;
 };
@@ -317,29 +316,26 @@ export const getClosedCurveShape = <Point extends GlobalPoint | LocalPoint>(
    };
  }
-  // Prefer the fillPath set
+  const ops = getCurvePathOps(roughShape);
  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") {
-      if (fillPathSet) {
+      odd = !odd;
-        // fillPath is always a single run — no odd/even skipping needed
+      if (odd) {
        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 (fillPathSet || odd) {
+      if (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]));
      }
    }
  }
@@ -1531,10 +1531,10 @@
  resolved "https://registry.yarnpkg.com/@excalidraw/markdown-to-text/-/markdown-to-text-0.1.2.tgz#1703705e7da608cf478f17bfe96fb295f55a23eb"
  integrity sha512-1nDXBNAojfi3oSFwJswKREkFm5wrSjqay81QlyRv2pkITG/XYB5v+oChENVBQLcxQwX4IUATWvXM5BcaNhPiIg==
-"@excalidraw/mermaid-to-excalidraw@2.1.0":
+"@excalidraw/mermaid-to-excalidraw@2.1.1":
-  version "2.1.0"
+  version "2.1.1"
-  resolved "https://registry.yarnpkg.com/@excalidraw/mermaid-to-excalidraw/-/mermaid-to-excalidraw-2.1.0.tgz#a5b9cf87c3185558cda7f9687d87b9937f452358"
+  resolved "https://registry.yarnpkg.com/@excalidraw/mermaid-to-excalidraw/-/mermaid-to-excalidraw-2.1.1.tgz#659c934a607dd2cf57f2a69282588ee2b0722959"
-  integrity sha512-RMd+c2b7WzzUjhERMpKwp8PhF2/XlHDjr/zK+Gxfp8K9sVlafPYJ5OEa/GkN6edi2rBUXRfW+41WdO6L56b6Kw==
+  integrity sha512-jU+frqcxazsY+t5yOBf2mgrQy+WUrbrzA36if3SQB/Vwaf2qOJjnWxucNafgZZk/3+9xGmRotUeOviSOJG+wYA==
  dependencies:
    "@excalidraw/markdown-to-text" "0.1.2"
    "@mermaid-js/parser" "^0.6.3"
Author	SHA1	Message	Date
dwelle	9448cca81d	feat(editor): highlight duplicate matches in mermaid editor	2026-03-24 16:16:44 +01:00
dwelle	217c59a13a	feat(editor): highlight TTD assistant responses	2026-03-24 16:14:26 +01:00
Márk TolmácsandGitHub	d6f0f34fe9	fix: Rotated rounded arrow center point (#10962 )	2026-03-23 15:54:59 +01:00
Márk Tolmács GitHub dwelle	75789f620d	fix: Other endpoint is not immediately updated on midpoint snap (#10933 ) Co-authored-by: dwelle <5153846+dwelle@users.noreply.github.com>	2026-03-23 14:54:44 +00:00
David LuzarandGitHub	a9ca16eb42	chore(packages/excalidraw): export Fonts helper class (#11008 )	2026-03-21 22:44:27 +01:00
Márk TolmácsandGitHub	987173b52f	fix: Arrow point index Out-of-Bounds (#10922 ) * fix: Make OOB not fatal Signed-off-by: Mark Tolmacs <mark@lazycat.hu> * fix: More conservative temp arrow state update Signed-off-by: Mark Tolmacs <mark@lazycat.hu> * chore: Capture condition variables in binding restoration failure Signed-off-by: Mark Tolmacs <mark@lazycat.hu> --------- Signed-off-by: Mark Tolmacs <mark@lazycat.hu>	2026-03-21 19:26:47 +01:00