lint

- Move TransactionLedger + types from @excalidraw/element into
  packages/excalidraw/transaction.ts (no external consumers)
- Move commitSyntheticIncrement from App passthrough to Store directly,
  fix didAppStateChange to use Delta.isRightDifferent instead of
  presence-check, and replace isolated increments queue with direct
  scheduleMicroAction + flushMicroActions
- Remove commitSyntheticHistoryEntry from App, expose store and
  createTransaction on AppClassProperties instead
- Replace O(N) deep-copy snapshot in updateScene with shallow map copy
  (element refs are safe — ledger ignores index, the only in-place
  mutated prop, and deep-copies only recorded elements)
- Merge ledger + manager tests into single transaction.test.tsx
- Update dev-docs to reflect new file structure

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

.codesandbox/Dockerfile

@@ -1,4 +1,4 @@
-FROM node:24-bullseye
+FROM node:18-bullseye
 
 # Vite wants to open the browser using `open`, so we
 # need to install those utils.

Dockerfile

@@ -1,4 +1,4 @@
-FROM --platform=${BUILDPLATFORM} node:24 AS build
+FROM --platform=${BUILDPLATFORM} node:18 AS build
 
 WORKDIR /opt/node_app
 
@@ -13,7 +13,7 @@ ARG NODE_ENV=production
 
 RUN npm_config_target_arch=${TARGETARCH} yarn build:app:docker
 
-FROM nginx:1.27-alpine
+FROM --platform=${TARGETPLATFORM} nginx:1.27-alpine
 
 COPY --from=build /opt/node_app/excalidraw-app/build /usr/share/nginx/html
 

dev-docs/docs/codebase/transactions.mdx

@@ -0,0 +1,125 @@
+# Transactions
+
+Transactions let many live scene updates render immediately while still committing a single durable history entry.
+
+Typical use case:
+
+- AI streaming emits many `NEVER` updates for real-time feedback.
+- Those updates advance the live scene and store snapshot, but do not create undo history.
+- A transaction records the intended logical delta separately, then commits one synthetic durable increment at the end.
+
+## Key Files
+
+### `packages/excalidraw/transaction/`
+
+- `transaction.ts`
+  - `Transaction` is the per-tx instance.
+  - `updateScene()` applies live updates with `captureUpdate: NEVER`.
+  - `updateElements()` is a typed partial-patch helper over `updateScene()`.
+  - `commit()` builds synthetic snapshots and commits one durable entry.
+  - `cancel()` ends the tx without committing history.
+- `ledger.ts`
+  - `TransactionLedger` keeps per-element baseline, target, and touched props across tx steps.
+  - `buildSyntheticSnapshots()` reconciles tx intent with the live scene using `live-wins-per-prop`.
+- `undoOverridePlanner.ts`
+  - Tracks tx intermediate values.
+  - Produces undo override candidates for regular user history entries that were recorded while a tx was active.
+- `manager.ts`
+  - Owns tx lifecycle state and active-tx priority.
+  - Injects tx undo markers into durable deltas at record time.
+  - Resolves effective history deltas at undo/redo time.
+- `diff.ts` / `types.ts`
+  - Shared diff helpers and transaction-specific types.
+
+### `packages/element/src/store.ts`
+
+- `store.commitSyntheticIncrement()`
+  - Builds `StoreSnapshot -> StoreChange -> StoreDelta` from logical before/after snapshots.
+  - Commits the synthetic durable increment immediately through an isolated path.
+  - Does not flush unrelated pending micro actions.
+- `StoreDelta.markers`
+  - Carries extra history markers such as `txUndoOverrides`.
+
+### `packages/excalidraw/history.ts`
+
+- `onBeforeRecord()`
+  - Lets the transaction manager attach markers before a durable delta becomes a history entry.
+- `setEffectiveDeltaResolver()`
+  - Lets the transaction manager rewrite a history delta at undo/redo time before it is applied.
+
+## Flow
+
+1. Caller creates a transaction.
+2. `tx.updateScene()` applies live updates with `NEVER`.
+3. The ledger records net element changes; appState intent is accumulated separately.
+4. Regular user durable edits that happen while the tx is active may receive tx undo markers.
+5. `tx.commit()` asks the ledger for logical before/after snapshots and calls `store.commitSyntheticIncrement()`.
+6. Undo/redo later uses the manager's effective-delta resolver to decide whether ended tx markers should patch the baseline of a regular history entry.
+
+Result:
+
+- live rendering stays immediate;
+- one tx still produces one durable history entry;
+- interleaved regular edits can undo back to the correct pre-tx baseline.
+
+## Undo Examples
+
+### Interleaved Regular Edit
+
+1. Baseline: `rect = (x: 0, stroke: black)`
+2. Tx updates it live to `(x: 200, stroke: red)` with `NEVER`
+3. User makes a regular durable edit: `(x: 200, stroke: purple)`
+4. Tx commits; live stays purple
+
+The user history entry was recorded while the tx was active, so its local baseline is `red`.
+If undo later runs after the tx has ended, restoring `red` is wrong: the correct pre-tx baseline is `black`.
+
+To fix this:
+
+- record-time attaches a tx undo marker to the user history entry
+- perform-time checks whether the tx has already ended
+- if ended, the effective delta is patched so undo restores `black` instead of `red`
+
+### Active Tx vs Ended Tx
+
+Using the same example:
+
+- if the user undoes while the tx is still active, the marker stays inactive and undo restores the tx intermediate value (`red`)
+- if the user undoes after the tx has ended, the marker becomes active and undo restores the pre-tx baseline (`black`)
+
+So markers are recorded early, but applied conditionally.
+
+## AppState
+
+Elements use ledger snapshots. AppState does not.
+
+The transaction instead keeps:
+
+- `initialAppState`: observed appState at tx start
+- `accumulatedAppState`: merged caller intent from `tx.updateScene({ appState })`
+
+At commit, the transaction computes the final appState patch and passes it into `store.commitSyntheticIncrement()`.
+
+## Example
+
+```ts
+const tx = app.transactionManager.create();
+
+tx.updateScene({ elements: updatedElementsA });
+tx.updateScene({ elements: updatedElementsB });
+tx.updateElements({
+  elements: [
+    { id: "rect-1", type: "rectangle", updates: { strokeColor: "#f00" } },
+    { id: "rect-2", type: "rectangle", updates: { x: 120 } },
+  ],
+});
+
+tx.commit();
+```
+
+## Notes
+
+- `commit()` and `cancel()` are idempotent.
+- `updateScene()` and `updateElements()` throw after the tx has ended.
+- Conflict handling inside synthetic snapshots is fixed to `live-wins-per-prop`.
+- Multi-tx interleaving is supported through manager-owned lifecycle tracking and active-tx priority.

packages/element/src/binding.ts

@@ -1943,9 +1943,9 @@ export const calculateFixedPointForElbowArrowBinding = (
   return {
     fixedPoint: normalizeFixedPoint([
       (nonRotatedSnappedGlobalPoint[0] - hoveredElement.x) /
-        Math.max(hoveredElement.width, PRECISION),
+        hoveredElement.width,
       (nonRotatedSnappedGlobalPoint[1] - hoveredElement.y) /
-        Math.max(hoveredElement.height, PRECISION),
+        hoveredElement.height,
     ]),
   };
 };
@@ -1976,11 +1976,9 @@ export const calculateFixedPointForNonElbowArrowBinding = (
 
   // Calculate the ratio relative to the element's bounds
   const fixedPointX =
-    (nonRotatedPoint[0] - hoveredElement.x) /
-    Math.max(hoveredElement.width, PRECISION);
+    (nonRotatedPoint[0] - hoveredElement.x) / hoveredElement.width;
   const fixedPointY =
-    (nonRotatedPoint[1] - hoveredElement.y) /
-    Math.max(hoveredElement.height, PRECISION);
+    (nonRotatedPoint[1] - hoveredElement.y) / hoveredElement.height;
 
   return {
     fixedPoint: normalizeFixedPoint([fixedPointX, fixedPointY]),

packages/element/src/duplicate.ts

@@ -250,9 +250,6 @@ export const duplicateElements = (
     elementsWithDuplicates.splice(index + 1, 0, ...castArray(elements));
   };
 
-  // main
-  // ---------------------------------------------------------------------------
-
   const frameIdsToDuplicate = new Set(
     elements
       .filter(

packages/element/src/elbowArrow.ts

@@ -2124,8 +2124,8 @@ const normalizeArrowElementUpdate = (
     offsetY < -MAX_POS ||
     offsetY > MAX_POS ||
     offsetX + points[points.length - 1][0] < -MAX_POS ||
-    offsetX + points[points.length - 1][0] > MAX_POS ||
-    offsetY + points[points.length - 1][1] < -MAX_POS ||
+    offsetY + points[points.length - 1][0] > MAX_POS ||
+    offsetX + points[points.length - 1][1] < -MAX_POS ||
     offsetY + points[points.length - 1][1] > MAX_POS
   ) {
     console.error(

packages/element/src/frame.ts

@@ -19,7 +19,6 @@ import {
   getElementAbsoluteCoords,
   doBoundsIntersect,
   getElementBounds,
-  boundsContainBounds,
 } from "./bounds";
 import { mutateElement } from "./mutateElement";
 import { getBoundTextElement, getContainerElement } from "./textElement";
@@ -102,9 +101,8 @@ export const isElementContainingFrame = (
   frame: ExcalidrawFrameLikeElement,
   elementsMap: ElementsMap,
 ) => {
-  return boundsContainBounds(
-    getElementBounds(element, elementsMap),
-    getElementBounds(frame, elementsMap),
+  return getElementsWithinSelection([frame], element, elementsMap).some(
+    (e) => e.id === frame.id,
   );
 };
 

packages/element/src/selection.ts

@@ -34,6 +34,7 @@ import {
   elementOverlapsWithFrame,
   getContainingFrame,
   getFrameChildren,
+  isElementIntersectingFrame,
 } from "./frame";
 
 import { LinearElementEditor } from "./linearElementEditor";
@@ -169,7 +170,7 @@ export const getElementsWithinSelection = (
     const associatedFrame = getContainingFrame(element, elementsMap);
     if (
       associatedFrame &&
-      elementOverlapsWithFrame(element, associatedFrame, elementsMap)
+      isElementIntersectingFrame(element, associatedFrame, elementsMap)
     ) {
       const frameAABB = getElementBounds(associatedFrame, elementsMap);
       elementAABB = [
@@ -208,9 +209,10 @@ export const getElementsWithinSelection = (
     if (boundsContainBounds(selectionBounds, commonAABB)) {
       if (framesInSelection && isFrameLikeElement(element)) {
         framesInSelection.add(element.id);
+      } else {
+        elementsInSelection.push(element);
+        continue;
       }
-      elementsInSelection.push(element);
-      continue;
     }
 
     // 2. Handle the case where the label is overlapped by the selection box

packages/element/src/sortElements.ts

@@ -1,56 +1,59 @@
-import { arrayToMap } from "@excalidraw/common";
+import { arrayToMapWithIndex } from "@excalidraw/common";
 
 import type { ExcalidrawElement } from "./types";
 
-const defragmentGroups = (elements: readonly ExcalidrawElement[]) => {
-  const groupIdAtLevel = (element: ExcalidrawElement, level: number) => {
-    return element.groupIds[element.groupIds.length - level - 1];
-  };
+const normalizeGroupElementOrder = (elements: readonly ExcalidrawElement[]) => {
+  const origElements: ExcalidrawElement[] = elements.slice();
+  const sortedElements = new Set<ExcalidrawElement>();
 
-  const orderLevel = (
-    levelElements: readonly ExcalidrawElement[],
-    level: number,
+  const orderInnerGroups = (
+    elements: readonly ExcalidrawElement[],
   ): ExcalidrawElement[] => {
-    const buckets = new Map<string, ExcalidrawElement[]>();
-    // Slots preserve first-occurrence order: a groupId reserves its slot
-    // the first time one of its members is seen; loose elements occupy
-    // their own slot. Groups are then expanded (and recursed into) in place.
-    const slots: (ExcalidrawElement | string)[] = [];
-
-    for (const element of levelElements) {
-      const groupId = groupIdAtLevel(element, level);
-      if (groupId === undefined) {
-        slots.push(element);
-        continue;
+    const firstGroupSig = elements[0]?.groupIds?.join("");
+    const aGroup: ExcalidrawElement[] = [elements[0]];
+    const bGroup: ExcalidrawElement[] = [];
+    for (const element of elements.slice(1)) {
+      if (element.groupIds?.join("") === firstGroupSig) {
+        aGroup.push(element);
+      } else {
+        bGroup.push(element);
       }
-      let bucket = buckets.get(groupId);
-      if (!bucket) {
-        bucket = [];
-        buckets.set(groupId, bucket);
-        slots.push(groupId);
-      }
-      bucket.push(element);
     }
-
-    return slots.flatMap((slot) =>
-      typeof slot === "string"
-        ? orderLevel(buckets.get(slot)!, level + 1)
-        : [slot],
-    );
+    return bGroup.length ? [...aGroup, ...orderInnerGroups(bGroup)] : aGroup;
   };
 
-  // `groupIds` is stored innermost-first, so the outermost group is the
-  // last entry. We recurse from level 0 (outermost) inward.
-  const sortedElements = orderLevel(elements, 0);
+  const groupHandledElements = new Map<string, true>();
+
+  origElements.forEach((element, idx) => {
+    if (groupHandledElements.has(element.id)) {
+      return;
+    }
+    if (element.groupIds?.length) {
+      const topGroup = element.groupIds[element.groupIds.length - 1];
+      const groupElements = origElements.slice(idx).filter((element) => {
+        const ret = element?.groupIds?.some((id) => id === topGroup);
+        if (ret) {
+          groupHandledElements.set(element!.id, true);
+        }
+        return ret;
+      });
+
+      for (const elem of orderInnerGroups(groupElements)) {
+        sortedElements.add(elem);
+      }
+    } else {
+      sortedElements.add(element);
+    }
+  });
 
   // if there's a bug which resulted in losing some of the elements, return
   // original instead as that's better than losing data
-  if (sortedElements.length !== elements.length) {
-    console.error("defragmentGroups: lost some elements... bailing!");
+  if (sortedElements.size !== elements.length) {
+    console.error("normalizeGroupElementOrder: lost some elements... bailing!");
     return elements;
   }
 
-  return sortedElements;
+  return [...sortedElements];
 };
 
 /**
@@ -65,40 +68,39 @@ const defragmentGroups = (elements: readonly ExcalidrawElement[]) => {
 const normalizeBoundElementsOrder = (
   elements: readonly ExcalidrawElement[],
 ) => {
-  const elementsMap = arrayToMap(elements);
+  const elementsMap = arrayToMapWithIndex(elements);
 
+  const origElements: (ExcalidrawElement | null)[] = elements.slice();
   const sortedElements = new Set<ExcalidrawElement>();
 
-  for (const element of elements) {
-    if (sortedElements.has(element)) {
-      continue;
+  origElements.forEach((element, idx) => {
+    if (!element) {
+      return;
     }
-
     if (element.boundElements?.length) {
       sortedElements.add(element);
-      for (const boundElement of element.boundElements) {
+      origElements[idx] = null;
+      element.boundElements.forEach((boundElement) => {
         const child = elementsMap.get(boundElement.id);
         if (child && boundElement.type === "text") {
-          sortedElements.add(child);
+          sortedElements.add(child[0]);
+          origElements[child[1]] = null;
         }
+      });
+    } else if (element.type === "text" && element.containerId) {
+      const parent = elementsMap.get(element.containerId);
+      if (!parent?.[0].boundElements?.find((x) => x.id === element.id)) {
+        sortedElements.add(element);
+        origElements[idx] = null;
+
+        // if element has a container and container lists it, skip this element
+        // as it'll be taken care of by the container
       }
-      continue;
+    } else {
+      sortedElements.add(element);
+      origElements[idx] = null;
     }
-
-    // if element has a container and container lists it, skip this element
-    // as it'll be taken care of by the container
-    if (
-      element.type === "text" &&
-      element.containerId &&
-      elementsMap
-        .get(element.containerId)
-        ?.boundElements?.some((el) => el.id === element.id)
-    ) {
-      continue;
-    }
-
-    sortedElements.add(element);
-  }
+  });
 
   // if there's a bug which resulted in losing some of the elements, return
   // original instead as that's better than losing data
@@ -115,5 +117,5 @@ const normalizeBoundElementsOrder = (
 export const normalizeElementOrder = (
   elements: readonly ExcalidrawElement[],
 ) => {
-  return normalizeBoundElementsOrder(defragmentGroups(elements));
+  return normalizeBoundElementsOrder(normalizeGroupElementOrder(elements));
 };

packages/element/src/store.ts

@@ -111,6 +111,67 @@ export class Store {
     this.scheduleAction(CaptureUpdateAction.IMMEDIATELY);
   }
 
+  /**
+   * Commits a synthetic durable history entry without changing the live scene.
+   *
+   * Builds StoreSnapshot → StoreChange → StoreDelta from the provided
+   * logical before/after element maps and optional appState patches, then
+   * emits the resulting durable increment immediately through an isolated
+   * path that does not flush pending micro actions.
+   *
+   * appState patches are merged on top of the current observed appState
+   * baseline so only the provided keys participate in the synthetic diff.
+   */
+  public commitSyntheticIncrement(params: {
+    logicalBefore: {
+      elements: SceneElementsMap;
+      appState?: Partial<ObservedAppState>;
+    };
+    logicalAfter: {
+      elements: SceneElementsMap;
+      appState?: Partial<ObservedAppState>;
+    };
+  }): boolean {
+    const { logicalBefore, logicalAfter } = params;
+    const observedAppStateBaseline = this.snapshot.appState;
+    const syntheticAppStateBefore = logicalBefore.appState
+      ? { ...observedAppStateBaseline, ...logicalBefore.appState }
+      : observedAppStateBaseline;
+    const syntheticAppStateAfter = logicalAfter.appState
+      ? { ...observedAppStateBaseline, ...logicalAfter.appState }
+      : observedAppStateBaseline;
+    const didAppStateChange = Delta.isRightDifferent(
+      syntheticAppStateBefore,
+      syntheticAppStateAfter,
+    );
+    const prevSnapshot = StoreSnapshot.create(
+      logicalBefore.elements,
+      syntheticAppStateBefore,
+      {
+        didElementsChange: true,
+        didAppStateChange,
+      },
+    );
+    const nextSnapshot = StoreSnapshot.create(
+      logicalAfter.elements,
+      syntheticAppStateAfter,
+      {
+        didElementsChange: true,
+        didAppStateChange,
+      },
+    );
+    const change = StoreChange.create(prevSnapshot, nextSnapshot);
+    const delta = StoreDelta.calculate(prevSnapshot, nextSnapshot);
+
+    if (delta.isEmpty()) {
+      return false;
+    }
+
+    this.emitIsolatedDurableIncrement(change, delta);
+
+    return true;
+  }
+
   /**
    * Schedule special "micro" actions, to-be executed before the next commit, before it executes a scheduled "macro" action.
    */
@@ -206,6 +267,7 @@ export class Store {
   public clear(): void {
     this.snapshot = StoreSnapshot.empty();
     this.scheduledMacroActions = new Set();
+    this.scheduledMicroActions = [];
   }
 
   /**
@@ -245,6 +307,24 @@ export class Store {
     }
   }
 
+  /**
+   * Emits a synthetic durable increment immediately without draining the
+   * regular micro-action queue.
+   */
+  private emitIsolatedDurableIncrement(change: StoreChange, delta: StoreDelta) {
+    const nextSnapshot = this.applyChangeToSnapshot(change);
+
+    if (!nextSnapshot) {
+      return;
+    }
+
+    try {
+      this.emitDurableIncrement(nextSnapshot, change, delta);
+    } finally {
+      this.snapshot = nextSnapshot;
+    }
+  }
+
   /**
    * Performs change calculation and emits an ephemeral increment.
    *
@@ -491,6 +571,89 @@ export class EphemeralIncrement extends StoreIncrement {
   }
 }
 
+/**
+ * Serializable delta marker used to recover pre-tx undo baselines
+ * without rewriting history stack entries.
+ */
+export type TxUndoOverride = {
+  txId: string;
+  elementId: string;
+  prop: string;
+  expectedInsertedValue: unknown;
+  preTxBaselineValue: unknown;
+  consumedKey: string;
+};
+
+export type StoreDeltaMarkers = {
+  txUndoOverrides?: TxUndoOverride[];
+};
+
+const cloneTxUndoOverride = (override: TxUndoOverride): TxUndoOverride => ({
+  ...override,
+});
+
+const cloneStoreDeltaMarkers = (
+  markers: StoreDeltaMarkers | undefined,
+): StoreDeltaMarkers | undefined =>
+  markers
+    ? {
+        ...markers,
+        txUndoOverrides: markers.txUndoOverrides?.map(cloneTxUndoOverride),
+      }
+    : undefined;
+
+const pruneStoreDeltaMarkers = (delta: StoreDelta) => {
+  const txUndoOverrides = delta.markers?.txUndoOverrides;
+  if (!txUndoOverrides || txUndoOverrides.length === 0) {
+    return;
+  }
+
+  const updatedEntries = delta.elements.updated as Record<
+    string,
+    Delta<Record<string, unknown>>
+  >;
+  const nextTxUndoOverrides = txUndoOverrides.filter((override) => {
+    const updatedEntry = updatedEntries[override.elementId];
+    return (
+      !!updatedEntry &&
+      Object.prototype.hasOwnProperty.call(updatedEntry.inserted, override.prop)
+    );
+  });
+
+  if (nextTxUndoOverrides.length === txUndoOverrides.length) {
+    return;
+  }
+
+  if (nextTxUndoOverrides.length === 0) {
+    delta.markers = undefined;
+    return;
+  }
+
+  delta.markers = {
+    ...delta.markers,
+    txUndoOverrides: nextTxUndoOverrides.map(cloneTxUndoOverride),
+  };
+};
+
+export const mergeStoreDeltaMarkers = (
+  delta: StoreDelta,
+  markers: StoreDeltaMarkers,
+) => {
+  const txUndoOverrides = markers.txUndoOverrides ?? [];
+  if (txUndoOverrides.length === 0) {
+    return;
+  }
+
+  const existing = delta.markers?.txUndoOverrides ?? [];
+  delta.markers = {
+    ...delta.markers,
+    txUndoOverrides: [
+      ...existing.map(cloneTxUndoOverride),
+      ...txUndoOverrides.map(cloneTxUndoOverride),
+    ],
+  };
+};
+
 /**
  * Represents a captured delta by the Store.
  */
@@ -499,6 +662,7 @@ export class StoreDelta {
     public readonly id: string,
     public readonly elements: ElementsDelta,
     public readonly appState: AppStateDelta,
+    public markers?: StoreDeltaMarkers,
   ) {}
 
   /**
@@ -508,12 +672,16 @@ export class StoreDelta {
     elements: ElementsDelta,
     appState: AppStateDelta,
     opts: {
-      id: string;
-    } = {
-      id: randomId(),
-    },
+      id?: string;
+      markers?: StoreDeltaMarkers;
+    } = {},
   ) {
-    return new this(opts.id, elements, appState);
+    return new this(
+      opts.id ?? randomId(),
+      elements,
+      appState,
+      cloneStoreDeltaMarkers(opts.markers),
+    );
   }
 
   /**
@@ -538,11 +706,12 @@ export class StoreDelta {
    * Restore a store delta instance from a DTO.
    */
   public static restore(storeDeltaDTO: DTO<StoreDelta>) {
-    const { id, elements, appState } = storeDeltaDTO;
+    const { id, elements, appState, markers } = storeDeltaDTO;
     return new this(
       id,
       ElementsDelta.restore(elements),
       AppStateDelta.restore(appState),
+      cloneStoreDeltaMarkers(markers),
     );
   }
 
@@ -553,11 +722,12 @@ export class StoreDelta {
     id,
     elements: { added, removed, updated },
     appState: { delta: appStateDelta },
+    markers,
   }: DTO<StoreDelta>) {
     const elements = ElementsDelta.create(added, removed, updated);
     const appState = AppStateDelta.create(appStateDelta);
 
-    return new this(id, elements, appState);
+    return new this(id, elements, appState, cloneStoreDeltaMarkers(markers));
   }
 
   /**
@@ -569,8 +739,10 @@ export class StoreDelta {
     for (const delta of deltas) {
       aggregatedDelta.elements.squash(delta.elements);
       aggregatedDelta.appState.squash(delta.appState);
+      mergeStoreDeltaMarkers(aggregatedDelta, delta.markers ?? {});
     }
 
+    pruneStoreDeltaMarkers(aggregatedDelta);
     return aggregatedDelta;
   }
 
@@ -578,7 +750,12 @@ export class StoreDelta {
    * Inverse store delta, creates new instance of `StoreDelta`.
    */
   public static inverse(delta: StoreDelta) {
-    return this.create(delta.elements.inverse(), delta.appState.inverse());
+    const inversed = this.create(
+      delta.elements.inverse(),
+      delta.appState.inverse(),
+      { markers: delta.markers },
+    );
+    return inversed;
   }
 
   /**
@@ -614,7 +791,7 @@ export class StoreDelta {
     nextElements: SceneElementsMap,
     modifierOptions?: "deleted" | "inserted",
   ): StoreDelta {
-    return this.create(
+    const nextDelta = this.create(
       delta.elements.applyLatestChanges(
         prevElements,
         nextElements,
@@ -623,8 +800,11 @@ export class StoreDelta {
       delta.appState,
       {
         id: delta.id,
+        markers: delta.markers,
       },
     );
+    pruneStoreDeltaMarkers(nextDelta);
+    return nextDelta;
   }
 
   public static empty() {

packages/element/tests/frame.test.tsx

@@ -2,7 +2,6 @@ import {
   convertToExcalidrawElements,
   Excalidraw,
 } from "@excalidraw/excalidraw";
-import { arrayToMap } from "@excalidraw/common";
 
 import { API } from "@excalidraw/excalidraw/tests/helpers/api";
 import { Keyboard, Pointer } from "@excalidraw/excalidraw/tests/helpers/ui";
@@ -11,12 +10,7 @@ import {
   render,
 } from "@excalidraw/excalidraw/tests/test-utils";
 
-import { elementOverlapsWithFrame } from "../src/frame";
-
-import type {
-  ExcalidrawElement,
-  ExcalidrawFrameLikeElement,
-} from "../src/types";
+import type { ExcalidrawElement } from "../src/types";
 
 const { h } = window;
 const mouse = new Pointer("mouse");
@@ -131,26 +125,6 @@ describe("adding elements to frames", () => {
     });
   });
 
-  it("should treat an element fully containing a frame as overlapping the frame", () => {
-    const containingRect = API.createElement({
-      type: "rectangle",
-      x: -50,
-      y: -50,
-      width: 250,
-      height: 250,
-    });
-
-    API.setElements([containingRect, frame]);
-
-    expect(
-      elementOverlapsWithFrame(
-        containingRect,
-        frame as ExcalidrawFrameLikeElement,
-        arrayToMap(h.elements),
-      ),
-    ).toBe(true);
-  });
-
   const commonTestCases = async (
     func: typeof resizeFrameOverElement | typeof dragElementIntoFrame,
   ) => {
@@ -441,22 +415,6 @@ describe("adding elements to frames", () => {
   describe("dragging elements into the frame", async () => {
     await commonTestCases(dragElementIntoFrame);
 
-    it("should add a dragged element fully containing the frame", () => {
-      const containingRect = API.createElement({
-        type: "rectangle",
-        x: 220,
-        y: 20,
-        width: 300,
-        height: 300,
-      });
-
-      API.setElements([frame, containingRect]);
-
-      dragElementIntoFrame(frame, containingRect);
-
-      expect(API.getElement(containingRect).frameId).toBe(frame.id);
-    });
-
     it.skip("should drag element inside, duplicate it and keep it in frame", () => {
       API.setElements([frame, rect2]);
 

packages/element/tests/sortElements.test.ts

@@ -326,59 +326,19 @@ describe("normalizeElementsOrder", () => {
       ]),
       [
         "BA_rect1",
-        "CBA_rect3",
-        "CBA_rect7",
         "BA_rect5",
         "BA_rect6",
         "A_rect2",
         "A_rect5",
+        "CBA_rect3",
+        "CBA_rect7",
         "rect4",
         "X_rect8",
-        "YX_rect10",
         "X_rect11",
+        "YX_rect10",
         "rect9",
       ],
     );
-    assertOrder(
-      normalizeElementOrder([
-        API.createElement({
-          id: "A_rect1",
-          type: "rectangle",
-          groupIds: ["A"],
-        }),
-        API.createElement({
-          id: "CBA_rect2",
-          type: "rectangle",
-          groupIds: ["C", "B", "A"],
-        }),
-        API.createElement({
-          id: "A_rect3",
-          type: "rectangle",
-          groupIds: ["A"],
-        }),
-      ]),
-      ["A_rect1", "CBA_rect2", "A_rect3"],
-    );
-    assertOrder(
-      normalizeElementOrder([
-        API.createElement({
-          id: "abcT_rect1",
-          type: "rectangle",
-          groupIds: ["ab", "c", "T"],
-        }),
-        API.createElement({
-          id: "abcT_rect2",
-          type: "rectangle",
-          groupIds: ["a", "bc", "T"],
-        }),
-        API.createElement({
-          id: "abcT_rect3",
-          type: "rectangle",
-          groupIds: ["ab", "c", "T"],
-        }),
-      ]),
-      ["abcT_rect1", "abcT_rect3", "abcT_rect2"],
-    );
   });
 
   // TODO

packages/element/tests/store.test.ts

@@ -0,0 +1,140 @@
+import { API } from "@excalidraw/excalidraw/tests/helpers/api";
+
+import { arrayToMap } from "@excalidraw/common";
+
+import type App from "@excalidraw/excalidraw/components/App";
+
+import type { ObservedAppState } from "@excalidraw/excalidraw/types";
+import type {
+  ExcalidrawElement,
+  SceneElementsMap,
+} from "@excalidraw/element/types";
+
+import {
+  CaptureUpdateAction,
+  Store,
+  StoreSnapshot,
+  newElementWith,
+} from "../src";
+
+const getScheduledMicroActionCount = (store: Store) =>
+  (
+    store as unknown as {
+      scheduledMicroActions: Array<() => void>;
+    }
+  ).scheduledMicroActions.length;
+
+const flushMicroActions = (store: Store) => {
+  (
+    store as unknown as {
+      flushMicroActions: () => void;
+    }
+  ).flushMicroActions();
+};
+
+const toSceneElementsMap = (
+  elements: readonly ExcalidrawElement[],
+): SceneElementsMap => arrayToMap(elements) as SceneElementsMap;
+
+const createStoreHarness = (elements: SceneElementsMap) => {
+  const appState: ObservedAppState = StoreSnapshot.empty().appState;
+  const app = {
+    scene: {
+      getElementsMapIncludingDeleted: () => elements,
+    },
+    state: appState,
+  } as unknown as App;
+
+  const store = new Store(app);
+  store.snapshot = StoreSnapshot.create(elements, appState);
+
+  return { store, appState };
+};
+
+describe("Store synthetic increment isolation", () => {
+  it("keeps pending immediate micro actions queued across synthetic commit", () => {
+    const element = API.createElement({
+      type: "rectangle",
+      id: "store-isolated-immediate",
+      x: 0,
+      y: 0,
+    });
+    const baselineElements = toSceneElementsMap([element]);
+    const { store } = createStoreHarness(baselineElements);
+
+    const incrementTypes: Array<"durable" | "ephemeral"> = [];
+    const detach = store.onStoreIncrementEmitter.on((increment) => {
+      incrementTypes.push(increment.type);
+    });
+
+    store.scheduleMicroAction({
+      action: CaptureUpdateAction.IMMEDIATELY,
+      elements: [newElementWith(element, { y: 240 })],
+      appState: undefined,
+    });
+
+    expect(getScheduledMicroActionCount(store)).toBe(1);
+
+    const committed = store.commitSyntheticIncrement({
+      logicalBefore: {
+        elements: baselineElements,
+      },
+      logicalAfter: {
+        elements: toSceneElementsMap([newElementWith(element, { x: 120 })]),
+      },
+    });
+
+    expect(committed).toBe(true);
+    expect(incrementTypes).toEqual(["durable"]);
+    expect(getScheduledMicroActionCount(store)).toBe(1);
+
+    flushMicroActions(store);
+
+    expect(incrementTypes).toEqual(["durable", "durable"]);
+    expect(getScheduledMicroActionCount(store)).toBe(0);
+    detach();
+  });
+
+  it("keeps pending eventually micro actions queued across synthetic commit", () => {
+    const element = API.createElement({
+      type: "rectangle",
+      id: "store-isolated-eventually",
+      x: 0,
+      y: 0,
+    });
+    const baselineElements = toSceneElementsMap([element]);
+    const { store } = createStoreHarness(baselineElements);
+
+    const incrementTypes: Array<"durable" | "ephemeral"> = [];
+    const detach = store.onStoreIncrementEmitter.on((increment) => {
+      incrementTypes.push(increment.type);
+    });
+
+    store.scheduleMicroAction({
+      action: CaptureUpdateAction.EVENTUALLY,
+      elements: [newElementWith(element, { y: 240 })],
+      appState: undefined,
+    });
+
+    expect(getScheduledMicroActionCount(store)).toBe(1);
+
+    const committed = store.commitSyntheticIncrement({
+      logicalBefore: {
+        elements: baselineElements,
+      },
+      logicalAfter: {
+        elements: toSceneElementsMap([newElementWith(element, { x: 120 })]),
+      },
+    });
+
+    expect(committed).toBe(true);
+    expect(incrementTypes).toEqual(["durable"]);
+    expect(getScheduledMicroActionCount(store)).toBe(1);
+
+    flushMicroActions(store);
+
+    expect(incrementTypes).toEqual(["durable", "ephemeral"]);
+    expect(getScheduledMicroActionCount(store)).toBe(0);
+    detach();
+  });
+});

packages/excalidraw/actions/actionFinalize.tsx

@@ -329,6 +329,7 @@ export const actionFinalize = register<FormData>({
         selectionElement: null,
         multiElement: null,
         editingTextElement: null,
+        startBoundElement: null,
         suggestedBinding: null,
         selectedElementIds:
           element &&

packages/excalidraw/appState.ts

@@ -99,6 +99,7 @@ export const getDefaultAppState = (): Omit<
       open: false,
       panels: STATS_PANELS.generalStats | STATS_PANELS.elementProperties,
     },
+    startBoundElement: null,
     suggestedBinding: null,
     frameRendering: { enabled: true, clip: true, name: true, outline: true },
     frameToHighlight: null,
@@ -230,6 +231,7 @@ const APP_STATE_STORAGE_CONF = (<
   selectionElement: { browser: false, export: false, server: false },
   shouldCacheIgnoreZoom: { browser: true, export: false, server: false },
   stats: { browser: true, export: false, server: false },
+  startBoundElement: { browser: false, export: false, server: false },
   suggestedBinding: { browser: false, export: false, server: false },
   frameRendering: { browser: false, export: false, server: false },
   frameToHighlight: { browser: false, export: false, server: false },

packages/excalidraw/components/App.tsx

@@ -361,6 +361,7 @@ import { restoreAppState, restoreElements } from "../data/restore";
 import { getCenter, getDistance } from "../gesture";
 import { History } from "../history";
 import { defaultLang, getLanguage, languages, setLanguage, t } from "../i18n";
+import { TransactionManager } from "../transaction";
 
 import {
   calculateScrollCenter,
@@ -603,8 +604,6 @@ const YOUTUBE_VIDEO_STATES = new Map<
   ValueOf<typeof YOUTUBE_STATES>
 >();
 
-const MAX_EMBEDDABLE_VIEWPORT_SCALE = 4;
-
 let IS_PLAIN_PASTE = false;
 let IS_PLAIN_PASTE_TIMER = 0;
 let PLAIN_PASTE_TOAST_SHOWN = false;
@@ -639,7 +638,8 @@ class App extends React.Component<AppProps, AppState> {
   public library: AppClassProperties["library"];
   public libraryItemsFromStorage: LibraryItems | undefined;
   public id: string;
-  private store: Store;
+  public transactionManager: TransactionManager;
+  public store: Store;
   private history: History;
   public excalidrawContainerValue: {
     container: HTMLDivElement | null;
@@ -834,6 +834,8 @@ class App extends React.Component<AppProps, AppState> {
 
     this.store = new Store(this);
     this.history = new History(this.store);
+    this.transactionManager = new TransactionManager(this);
+    this.transactionManager.attachHistory(this.history);
 
     this.excalidrawContainerValue = {
       container: this.excalidrawContainerRef.current,
@@ -841,7 +843,6 @@ class App extends React.Component<AppProps, AppState> {
     };
 
     this.fonts = new Fonts(this.scene);
-    this.history = new History(this.store);
 
     this.actionManager.registerAll(actions);
     this.actionManager.registerAction(createUndoAction(this.history));
@@ -1737,18 +1738,6 @@ class App extends React.Component<AppProps, AppState> {
             this.state.activeEmbeddable?.element === el &&
             this.state.activeEmbeddable?.state === "hover";
 
-          // scale video embeds based on zoom (capped) so that smaller embeds
-          // on canvas when zoomed are still of legible quality
-          // (note: for some embed types like gdrive, the quality is poor when
-          // scaling mid playback and works only when you initially start the
-          // playback at the higher zoom level)
-          const shouldScaleEmbeddableViewport = src?.type === "video";
-          const embeddableViewportScale = clamp(
-            shouldScaleEmbeddableViewport ? scale : 1,
-            0.75,
-            MAX_EMBEDDABLE_VIEWPORT_SCALE,
-          );
-
           return (
             <div
               key={el.id}
@@ -1815,42 +1804,31 @@ class App extends React.Component<AppProps, AppState> {
                     padding: `${el.strokeWidth}px`,
                   }}
                 >
-                  <div
-                    className="excalidraw__embeddable__content"
-                    style={{
-                      width: `${embeddableViewportScale * 100}%`,
-                      height: `${embeddableViewportScale * 100}%`,
-                      transform: `scale(${1 / embeddableViewportScale})`,
-                    }}
-                  >
-                    {(isEmbeddableElement(el)
-                      ? this.props.renderEmbeddable?.(el, this.state)
-                      : null) ?? (
-                      <iframe
-                        ref={(ref) => this.cacheEmbeddableRef(el, ref)}
-                        className="excalidraw__embeddable"
-                        srcDoc={
-                          src?.type === "document"
-                            ? src.srcdoc(this.state.theme)
-                            : undefined
-                        }
-                        src={
-                          src?.type !== "document" ? src?.link ?? "" : undefined
-                        }
-                        // https://stackoverflow.com/q/18470015
-                        scrolling="no"
-                        referrerPolicy="no-referrer-when-downgrade"
-                        title="Excalidraw Embedded Content"
-                        allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture"
-                        allowFullScreen={true}
-                        sandbox={`${
-                          src?.sandbox?.allowSameOrigin
-                            ? "allow-same-origin"
-                            : ""
-                        } allow-scripts allow-forms allow-popups allow-popups-to-escape-sandbox allow-presentation allow-downloads`}
-                      />
-                    )}
-                  </div>
+                  {(isEmbeddableElement(el)
+                    ? this.props.renderEmbeddable?.(el, this.state)
+                    : null) ?? (
+                    <iframe
+                      ref={(ref) => this.cacheEmbeddableRef(el, ref)}
+                      className="excalidraw__embeddable"
+                      srcDoc={
+                        src?.type === "document"
+                          ? src.srcdoc(this.state.theme)
+                          : undefined
+                      }
+                      src={
+                        src?.type !== "document" ? src?.link ?? "" : undefined
+                      }
+                      // https://stackoverflow.com/q/18470015
+                      scrolling="no"
+                      referrerPolicy="no-referrer-when-downgrade"
+                      title="Excalidraw Embedded Content"
+                      allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture"
+                      allowFullScreen={true}
+                      sandbox={`${
+                        src?.sandbox?.allowSameOrigin ? "allow-same-origin" : ""
+                      } allow-scripts allow-forms allow-popups allow-popups-to-escape-sandbox allow-presentation allow-downloads`}
+                    />
+                  )}
                 </div>
               </div>
             </div>
@@ -4627,6 +4605,11 @@ class App extends React.Component<AppProps, AppState> {
     );
   };
 
+  /** Creates a new transaction for batching mutations into a single undo entry. */
+  public createTransaction: TransactionManager["create"] = () => {
+    return this.transactionManager.create();
+  };
+
   public mutateElement = <TElement extends Mutable<ExcalidrawElement>>(
     element: TElement,
     updates: ElementUpdate<TElement>,
@@ -6947,7 +6930,7 @@ class App extends React.Component<AppProps, AppState> {
               y: scenePointerY,
             },
           });
-          this.setState({ suggestedBinding: null });
+          this.setState({ suggestedBinding: null, startBoundElement: null });
           if (!this.state.activeTool.locked) {
             resetCursor(this.interactiveCanvas);
             this.setState((prevState) => ({
@@ -7591,6 +7574,7 @@ class App extends React.Component<AppProps, AppState> {
         appState: {
           newElement: null,
           editingTextElement: null,
+          startBoundElement: null,
           suggestedBinding: null,
           selectedElementIds: makeNextSelectedElementIds(
             Object.keys(this.state.selectedElementIds)
@@ -8878,8 +8862,18 @@ class App extends React.Component<AppProps, AppState> {
       };
     });
 
+    const boundElement = getHoveredElementForBinding(
+      pointFrom<GlobalPoint>(
+        pointerDownState.origin.x,
+        pointerDownState.origin.y,
+      ),
+      this.scene.getNonDeletedElements(),
+      this.scene.getNonDeletedElementsMap(),
+    );
+
     this.setState({
       newElement: element,
+      startBoundElement: boundElement,
       suggestedBinding: null,
     });
   };
@@ -10732,7 +10726,7 @@ class App extends React.Component<AppProps, AppState> {
               sceneCoords,
             });
           }
-          this.setState({ suggestedBinding: null });
+          this.setState({ suggestedBinding: null, startBoundElement: null });
           if (!activeTool.locked) {
             resetCursor(this.interactiveCanvas);
             this.setState((prevState) => ({
@@ -10753,9 +10747,9 @@ class App extends React.Component<AppProps, AppState> {
               ),
             }));
           } else {
-            this.setState({
+            this.setState((prevState) => ({
               newElement: null,
-            });
+            }));
           }
           // so that the scene gets rendered again to display the newly drawn linear as well
           this.scene.triggerUpdate();

packages/excalidraw/components/LayerUI.tsx

@@ -650,7 +650,8 @@ const LayerUI = ({
 };
 
 const stripIrrelevantAppStateProps = (appState: AppState): UIAppState => {
-  const { cursorButton, scrollX, scrollY, ...ret } = appState;
+  const { startBoundElement, cursorButton, scrollX, scrollY, ...ret } =
+    appState;
   return ret;
 };
 

packages/excalidraw/css/styles.scss

@@ -814,14 +814,6 @@ body.excalidraw-cursor-resize * {
   .excalidraw__embeddable__outer {
     width: 100%;
     height: 100%;
-  }
-
-  .excalidraw__embeddable__content {
-    width: 100%;
-    height: 100%;
-    transform-origin: top left;
-
-    &,
     & > * {
       border-radius: var(--embeddable-radius);
     }

packages/excalidraw/data/restore.ts

@@ -96,8 +96,6 @@ type RestoredAppState = Omit<
   "offsetTop" | "offsetLeft" | "width" | "height"
 >;
 
-const MAX_ARROW_PX = 75_000;
-
 export const AllowedExcalidrawActiveTools: Record<
   AppState["activeTool"]["type"],
   boolean
@@ -469,8 +467,8 @@ export const restoreElement = (
         element.endArrowhead === undefined
           ? "arrow"
           : normalizeArrowhead(element.endArrowhead);
-      const x = element.x as number | undefined;
-      const y = element.y as number | undefined;
+      const x: number | undefined = element.x;
+      const y: number | undefined = element.y;
       const points: readonly LocalPoint[] | undefined = // migrate old arrow model to new one
         !Array.isArray(element.points) || element.points.length < 2
           ? [pointFrom(0, 0), pointFrom(element.width, element.height)]
@@ -495,8 +493,8 @@ export const restoreElement = (
         startArrowhead,
         endArrowhead,
         points,
-        x: x ?? 0,
-        y: y ?? 0,
+        x,
+        y,
         elbowed: (element as ExcalidrawArrowElement).elbowed,
         ...getSizeFromPoints(points),
       };
@@ -515,44 +513,12 @@ export const restoreElement = (
           })
         : restoreElementWithProperties(element as ExcalidrawArrowElement, base);
 
-      const normalizedRestoredElement = {
+      return {
         ...restoredElement,
         ...LinearElementEditor.getNormalizeElementPointsAndCoords(
           restoredElement,
         ),
       };
-
-      // Last resort fix for extremely large arrows
-      if (
-        normalizedRestoredElement.width > MAX_ARROW_PX ||
-        normalizedRestoredElement.height > MAX_ARROW_PX
-      ) {
-        console.error(
-          `Removing extremely large arrow ${
-            normalizedRestoredElement.id
-          } (type: ${
-            isElbowArrow(normalizedRestoredElement) ? "elbow" : "simple"
-          }, width: ${normalizedRestoredElement.width}, height: ${
-            normalizedRestoredElement.height
-          }, x: ${normalizedRestoredElement.x}, y: ${
-            normalizedRestoredElement.y
-          })`,
-        );
-        return {
-          ...normalizedRestoredElement,
-          x: 0,
-          y: 0,
-          width: 100,
-          height: 100,
-          points: [
-            pointFrom<LocalPoint>(0, 0),
-            pointFrom<LocalPoint>(100, 100),
-          ],
-          isDeleted: true,
-        };
-      }
-
-      return normalizedRestoredElement;
     }
 
     // generic elements
@@ -700,7 +666,6 @@ export const restoreElements = <T extends ExcalidrawElement>(
   const existingElementsMap = existingElements
     ? arrayToMap(existingElements)
     : null;
-
   const restoredElements = syncInvalidIndices(
     (targetElements || []).reduce((elements, element) => {
       // filtering out selection, which is legacy, no longer kept in elements,
@@ -797,7 +762,7 @@ export const restoreElements = <T extends ExcalidrawElement>(
     }
   }
 
-  // NOTE (mtolmacs): Temporary fix for invalid/self-bound elbow arrows
+  // NOTE (mtolmacs): Temporary fix for extremely large arrows
   // Need to iterate again so we have attached text nodes in elementsMap
   return restoredElements.map((element) => {
     if (

packages/excalidraw/history.ts

@@ -87,10 +87,22 @@ export class HistoryChangedEvent {
   ) {}
 }
 
+export type HistoryBeforeRecordListener = (delta: StoreDelta) => void;
+export type HistoryPerformDirection = "undo" | "redo";
+export type HistoryEffectiveDeltaResolverContext = {
+  direction: HistoryPerformDirection;
+};
+export type HistoryEffectiveDeltaResolver = (
+  delta: HistoryDelta,
+  context: HistoryEffectiveDeltaResolverContext,
+) => HistoryDelta;
+
 export class History {
   public readonly onHistoryChangedEmitter = new Emitter<
     [HistoryChangedEvent]
   >();
+  private readonly onBeforeRecordEmitter = new Emitter<[StoreDelta]>();
+  private effectiveDeltaResolver: HistoryEffectiveDeltaResolver | null = null;
 
   public readonly undoStack: HistoryDelta[] = [];
   public readonly redoStack: HistoryDelta[] = [];
@@ -105,6 +117,20 @@ export class History {
 
   constructor(private readonly store: Store) {}
 
+  /**
+   * Registers a hook that runs before a durable delta is converted
+   * into a history entry.
+   */
+  public onBeforeRecord(callback: HistoryBeforeRecordListener) {
+    return this.onBeforeRecordEmitter.on(callback);
+  }
+
+  public setEffectiveDeltaResolver(
+    resolver: HistoryEffectiveDeltaResolver | null,
+  ) {
+    this.effectiveDeltaResolver = resolver;
+  }
+
   public clear() {
     this.undoStack.length = 0;
     this.redoStack.length = 0;
@@ -119,6 +145,8 @@ export class History {
       return;
     }
 
+    this.onBeforeRecordEmitter.trigger(delta);
+
     // construct history entry, so once it's emitted, it's not recorded again
     const historyDelta = HistoryDelta.inverse(delta);
 
@@ -131,15 +159,14 @@ export class History {
       this.redoStack.length = 0;
     }
 
-    this.onHistoryChangedEmitter.trigger(
-      new HistoryChangedEvent(this.isUndoStackEmpty, this.isRedoStackEmpty),
-    );
+    this.emitHistoryChanged();
   }
 
   public undo(elements: SceneElementsMap, appState: AppState) {
     return this.perform(
       elements,
       appState,
+      "undo",
       () => History.pop(this.undoStack),
       (entry: HistoryDelta) => History.push(this.redoStack, entry),
     );
@@ -149,6 +176,7 @@ export class History {
     return this.perform(
       elements,
       appState,
+      "redo",
       () => History.pop(this.redoStack),
       (entry: HistoryDelta) => History.push(this.undoStack, entry),
     );
@@ -157,6 +185,7 @@ export class History {
   private perform(
     elements: SceneElementsMap,
     appState: AppState,
+    direction: HistoryPerformDirection,
     pop: () => HistoryDelta | null,
     push: (entry: HistoryDelta) => void,
   ): [SceneElementsMap, AppState] | void {
@@ -177,9 +206,15 @@ export class History {
 
       // iterate through the history entries in case they result in no visible changes
       while (historyDelta) {
+        // Roundtrip invariant: whichever delta we execute must be the one that
+        // continues through applyLatestChanges -> inverse -> opposite stack.
+        let entryToPush = historyDelta;
         try {
+          const effectiveDelta = this.resolveEffectiveDelta(historyDelta, {
+            direction,
+          });
           [nextElements, nextAppState, containsVisibleChange] =
-            historyDelta.applyTo(nextElements, nextAppState, prevSnapshot);
+            effectiveDelta.applyTo(nextElements, nextAppState, prevSnapshot);
 
           const prevElements = prevSnapshot.elements;
           const nextSnapshot = prevSnapshot.maybeClone(
@@ -190,7 +225,7 @@ export class History {
 
           const change = StoreChange.create(prevSnapshot, nextSnapshot);
           const delta = HistoryDelta.applyLatestChanges(
-            historyDelta,
+            effectiveDelta,
             prevElements,
             nextElements,
           );
@@ -203,12 +238,12 @@ export class History {
               delta,
             });
 
-            historyDelta = delta;
+            entryToPush = delta;
           }
 
           prevSnapshot = nextSnapshot;
         } finally {
-          push(historyDelta);
+          push(entryToPush);
         }
 
         if (containsVisibleChange) {
@@ -222,12 +257,16 @@ export class History {
     } finally {
       // trigger the history change event before returning completely
       // also trigger it just once, no need doing so on each entry
-      this.onHistoryChangedEmitter.trigger(
-        new HistoryChangedEvent(this.isUndoStackEmpty, this.isRedoStackEmpty),
-      );
+      this.emitHistoryChanged();
     }
   }
 
+  private emitHistoryChanged() {
+    this.onHistoryChangedEmitter.trigger(
+      new HistoryChangedEvent(this.isUndoStackEmpty, this.isRedoStackEmpty),
+    );
+  }
+
   private static pop(stack: HistoryDelta[]): HistoryDelta | null {
     if (!stack.length) {
       return null;
@@ -246,4 +285,15 @@ export class History {
     const inversedEntry = HistoryDelta.inverse(entry);
     return stack.push(inversedEntry);
   }
+
+  private resolveEffectiveDelta(
+    delta: HistoryDelta,
+    context: HistoryEffectiveDeltaResolverContext,
+  ): HistoryDelta {
+    if (!this.effectiveDeltaResolver) {
+      return delta;
+    }
+
+    return this.effectiveDeltaResolver(delta, context);
+  }
 }

packages/excalidraw/package.json

@@ -83,13 +83,13 @@
     "@codemirror/language": "^6.0.0",
     "@codemirror/state": "^6.0.0",
     "@codemirror/view": "^6.0.0",
-    "@lezer/highlight": "^1.0.0",
     "@excalidraw/common": "0.18.0",
     "@excalidraw/element": "0.18.0",
     "@excalidraw/laser-pointer": "1.3.1",
     "@excalidraw/math": "0.18.0",
     "@excalidraw/mermaid-to-excalidraw": "2.2.2",
     "@excalidraw/random-username": "1.1.0",
+    "@lezer/highlight": "^1.0.0",
     "browser-fs-access": "0.38.0",
     "canvas-roundrect-polyfill": "0.0.1",
     "clsx": "1.1.1",

packages/excalidraw/renderer/renderSnaps.ts

@@ -19,6 +19,8 @@ export const renderSnaps = (
   }
 
   // in dark mode, we need to adjust the color to account for color inversion.
+  // Don't change if zen mode, because we draw only crosses, we want the
+  // colors to be more visible
   const snapColor =
     appState.theme === THEME.LIGHT || appState.zenModeEnabled
       ? SNAP_COLOR_LIGHT

packages/excalidraw/snapping.ts

@@ -39,14 +39,6 @@ import type {
 } from "./types";
 
 const SNAP_DISTANCE = 8;
-// Keep snap candidates with effectively identical offsets together. This needs
-// to be wider than the 6-decimal rounding quantum to absorb JS floating-point
-// noise around values like 4 and 4.000001.
-const SNAP_OFFSET_TOLERANCE = 0.00001;
-// Point snaps can come from both nearby and distant references within snap
-// distance. If their visual distances have a large break, prefer the nearest
-// cluster before comparing offsets.
-const SNAP_REFERENCE_CLUSTER_BREAK_DISTANCE = 200;
 
 // do not comput more gaps per axis than this limit
 // TODO increase or remove once we optimize
@@ -57,51 +49,16 @@ export const getSnapDistance = (zoomValue: number) => {
   return SNAP_DISTANCE / zoomValue;
 };
 
-/**
- * Keeps the cluster threshold visually stable across zoom levels.
- */
-const getSnapReferenceClusterBreakDistance = (zoomValue: number) => {
-  return SNAP_REFERENCE_CLUSTER_BREAK_DISTANCE / zoomValue;
-};
-
 type Vector2D = {
   x: number;
   y: number;
 };
 
 type PointPair = [GlobalPoint, GlobalPoint];
-type SnapPointType = "outer" | "center";
-type SnapSourceId = string;
-
-const SELECTION_SNAP_SOURCE_ID = "selection";
-
-// Snap source ids let us filter redundant snaplines only within one
-// selection-to-reference relationship, without mixing separate reference groups.
-// For example, "selection->rectA" may collapse to its outermost snaplines,
-// while "selection->rectB" still keeps its own independent snaplines.
-type SnapPoint = {
-  point: GlobalPoint;
-  type: SnapPointType;
-  snapSourceId: SnapSourceId;
-};
-
-const outerSnapPoint = (
-  point: GlobalPoint,
-  snapSourceId = SELECTION_SNAP_SOURCE_ID,
-): SnapPoint => ({
-  point,
-  type: "outer",
-  snapSourceId,
-});
 
 export type PointSnap = {
   type: "point";
   points: PointPair;
-  pointTypes: [SnapPointType, SnapPointType];
-  snapSourceIds: [SnapSourceId, SnapSourceId];
-  // Distance along the rendered snapline, used to group visually nearby
-  // references before choosing which point snaps should win.
-  visualDistance: number;
   offset: number;
 };
 
@@ -163,14 +120,14 @@ export type SnapLine = PointSnapLine | GapSnapLine | PointerSnapLine;
 // -----------------------------------------------------------------------------
 
 export class SnapCache {
-  private static referenceSnapPoints: SnapPoint[] | null = null;
+  private static referenceSnapPoints: GlobalPoint[] | null = null;
 
   private static visibleGaps: {
     verticalGaps: Gap[];
     horizontalGaps: Gap[];
   } | null = null;
 
-  public static setReferenceSnapPoints = (snapPoints: SnapPoint[] | null) => {
+  public static setReferenceSnapPoints = (snapPoints: GlobalPoint[] | null) => {
     SnapCache.referenceSnapPoints = snapPoints;
   };
 
@@ -238,17 +195,6 @@ export const areRoughlyEqual = (a: number, b: number, precision = 0.01) => {
   return Math.abs(a - b) <= precision;
 };
 
-/**
- * Keeps nearly identical snap offsets in the same winner set. This prevents
- * snapline flicker when rounded geometry differs by a tiny floating-point tail.
- */
-const isWithinSnapOffset = (offset: number, minOffset: number) => {
-  return (
-    Math.abs(offset) <= minOffset ||
-    areRoughlyEqual(Math.abs(offset), minOffset, SNAP_OFFSET_TOLERANCE)
-  );
-};
-
 export const getElementsCorners = (
   elements: ExcalidrawElement[],
   elementsMap: ElementsMap,
@@ -366,81 +312,18 @@ export const getElementsCorners = (
   return result.map((p) => pointFrom(round(p[0]), round(p[1])));
 };
 
-const getElementsSnapPoints = (
-  elements: ExcalidrawElement[],
-  elementsMap: ElementsMap,
-  options: Parameters<typeof getElementsCorners>[2] = {},
-  snapSourceId = SELECTION_SNAP_SOURCE_ID,
-): SnapPoint[] => {
-  const points = getElementsCorners(elements, elementsMap, options);
-  // getElementsCorners() appends the center point last unless omitCenter is set.
-  const hasCenterPoint = !options.omitCenter && points.length > 0;
-
-  return points.map((point, index) => ({
-    point,
-    type: hasCenterPoint && index === points.length - 1 ? "center" : "outer",
-    snapSourceId,
-  }));
-};
-
-/**
- * Builds a stable identity for one snap reference group. Sorting keeps grouped
- * elements represented by the same snap source id regardless of element order.
- */
-const getSnapSourceId = (elements: ExcalidrawElement[]) => {
-  return elements
-    .map((element) => element.id)
-    .sort()
-    .join(",");
-};
-
-/**
- * Finds frames that the current selection already belongs to. Their children
- * are still valid snap references; children of unrelated frames are not.
- */
-const getSelectedFrameIdsForSnapping = (
-  selectedElements: readonly ExcalidrawElement[],
-) => {
-  const selectedFrameIds = new Set<ExcalidrawElement["id"]>();
-
-  for (const element of selectedElements) {
-    if (element.frameId) {
-      selectedFrameIds.add(element.frameId);
-    }
-  }
-
-  return selectedFrameIds;
-};
-
-/**
- * Frame children are only snap references when the dragged selection is inside
- * the same frame. This avoids snapping external elements to internals of a
- * framed diagram.
- */
-const canUseElementAsSnapReference = (
-  element: NonDeletedExcalidrawElement,
-  selectedFrameIds: Set<ExcalidrawElement["id"]>,
-) => {
-  return !element.frameId || selectedFrameIds.has(element.frameId);
-};
-
 const getReferenceElements = (
   elements: readonly NonDeletedExcalidrawElement[],
   selectedElements: NonDeletedExcalidrawElement[],
   appState: AppState,
   elementsMap: ElementsMap,
-) => {
-  const selectedFrameIds = getSelectedFrameIdsForSnapping(selectedElements);
-
-  return getVisibleAndNonSelectedElements(
+) =>
+  getVisibleAndNonSelectedElements(
     elements,
     selectedElements,
     appState,
     elementsMap,
-  ).filter((element) => {
-    return canUseElementAsSnapReference(element, selectedFrameIds);
-  });
-};
+  );
 
 export const getVisibleGaps = (
   elements: readonly NonDeletedExcalidrawElement[],
@@ -599,10 +482,7 @@ const getGapSnaps = (
       const centerOffset = round(gapMidX - centerX);
       const gapIsLargerThanSelection = gap.length > maxX - minX;
 
-      if (
-        gapIsLargerThanSelection &&
-        isWithinSnapOffset(centerOffset, minOffset.x)
-      ) {
+      if (gapIsLargerThanSelection && Math.abs(centerOffset) <= minOffset.x) {
         if (Math.abs(centerOffset) < minOffset.x) {
           nearestSnapsX.length = 0;
         }
@@ -624,7 +504,7 @@ const getGapSnaps = (
       const distanceToEndElementX = minX - endMaxX;
       const sideOffsetRight = round(gap.length - distanceToEndElementX);
 
-      if (isWithinSnapOffset(sideOffsetRight, minOffset.x)) {
+      if (Math.abs(sideOffsetRight) <= minOffset.x) {
         if (Math.abs(sideOffsetRight) < minOffset.x) {
           nearestSnapsX.length = 0;
         }
@@ -645,7 +525,7 @@ const getGapSnaps = (
       const distanceToStartElementX = startMinX - maxX;
       const sideOffsetLeft = round(distanceToStartElementX - gap.length);
 
-      if (isWithinSnapOffset(sideOffsetLeft, minOffset.x)) {
+      if (Math.abs(sideOffsetLeft) <= minOffset.x) {
         if (Math.abs(sideOffsetLeft) < minOffset.x) {
           nearestSnapsX.length = 0;
         }
@@ -671,10 +551,7 @@ const getGapSnaps = (
       const centerOffset = round(gapMidY - centerY);
       const gapIsLargerThanSelection = gap.length > maxY - minY;
 
-      if (
-        gapIsLargerThanSelection &&
-        isWithinSnapOffset(centerOffset, minOffset.y)
-      ) {
+      if (gapIsLargerThanSelection && Math.abs(centerOffset) <= minOffset.y) {
         if (Math.abs(centerOffset) < minOffset.y) {
           nearestSnapsY.length = 0;
         }
@@ -696,7 +573,7 @@ const getGapSnaps = (
       const distanceToStartElementY = startMinY - maxY;
       const sideOffsetTop = round(distanceToStartElementY - gap.length);
 
-      if (isWithinSnapOffset(sideOffsetTop, minOffset.y)) {
+      if (Math.abs(sideOffsetTop) <= minOffset.y) {
         if (Math.abs(sideOffsetTop) < minOffset.y) {
           nearestSnapsY.length = 0;
         }
@@ -717,7 +594,7 @@ const getGapSnaps = (
       const distanceToEndElementY = round(minY - endMaxY);
       const sideOffsetBottom = gap.length - distanceToEndElementY;
 
-      if (isWithinSnapOffset(sideOffsetBottom, minOffset.y)) {
+      if (Math.abs(sideOffsetBottom) <= minOffset.y) {
         if (Math.abs(sideOffsetBottom) < minOffset.y) {
           nearestSnapsY.length = 0;
         }
@@ -736,102 +613,6 @@ const getGapSnaps = (
   }
 };
 
-/**
- * Narrows point snaps to the nearest visual cluster, then keeps the best offset
- * inside that cluster. If all references look continuous, this preserves the
- * old smallest-offset behavior.
- */
-const filterPointSnapsToNearestCluster = (
-  snaps: Snaps,
-  clusterBreakDistance: number,
-) => {
-  const pointSnaps = snaps.filter(
-    (snap): snap is PointSnap => snap.type === "point",
-  );
-
-  if (pointSnaps.length < 2) {
-    return;
-  }
-
-  const snapsByOffset = new Map<number, PointSnap[]>();
-
-  for (const snap of pointSnaps) {
-    const offset = round(snap.offset);
-    const offsetSnaps = snapsByOffset.get(offset) ?? [];
-    offsetSnaps.push(snap);
-    snapsByOffset.set(offset, offsetSnaps);
-  }
-
-  const keptPointSnaps = new Set<PointSnap>();
-  const offsetGroups = Array.from(snapsByOffset.entries()).map(
-    ([offset, offsetSnaps]) => ({
-      offset,
-      snaps: offsetSnaps,
-      visualDistance: Math.min(
-        ...offsetSnaps.map((snap) => snap.visualDistance),
-      ),
-    }),
-  );
-  const sortedOffsetGroups = offsetGroups
-    .slice()
-    .sort((a, b) => a.visualDistance - b.visualDistance);
-  let keepOffsetGroupsUntil = sortedOffsetGroups.length;
-
-  // Prefer a nearby reference cluster before comparing offset. If there is no
-  // clear distance break, this keeps all offsets and falls back to the old
-  // smallest-offset behavior.
-  for (let i = 1; i < sortedOffsetGroups.length; i++) {
-    const distanceGap =
-      sortedOffsetGroups[i].visualDistance -
-      sortedOffsetGroups[i - 1].visualDistance;
-
-    if (distanceGap > clusterBreakDistance) {
-      keepOffsetGroupsUntil = i;
-      break;
-    }
-  }
-
-  const nearestOffsetGroups = sortedOffsetGroups.slice(
-    0,
-    keepOffsetGroupsUntil,
-  );
-  const minOffset = Math.min(
-    ...nearestOffsetGroups.map(({ offset }) => Math.abs(offset)),
-  );
-  const selectedOffsets = nearestOffsetGroups
-    .filter(({ offset }) =>
-      areRoughlyEqual(Math.abs(offset), minOffset, SNAP_OFFSET_TOLERANCE),
-    )
-    .map(({ offset }) => offset);
-
-  for (const offsetSnaps of snapsByOffset.values()) {
-    if (
-      !selectedOffsets.some((offset) =>
-        areRoughlyEqual(
-          round(offsetSnaps[0].offset),
-          offset,
-          SNAP_OFFSET_TOLERANCE,
-        ),
-      )
-    ) {
-      continue;
-    }
-
-    offsetSnaps.forEach((snap) => keptPointSnaps.add(snap));
-  }
-
-  let writeIndex = 0;
-
-  for (const snap of snaps) {
-    if (snap.type !== "point" || keptPointSnaps.has(snap)) {
-      snaps[writeIndex] = snap;
-      writeIndex++;
-    }
-  }
-
-  snaps.length = writeIndex;
-};
-
 export const getReferenceSnapPoints = (
   elements: readonly NonDeletedExcalidrawElement[],
   selectedElements: ExcalidrawElement[],
@@ -849,24 +630,12 @@ export const getReferenceSnapPoints = (
       (elementsGroup) =>
         !(elementsGroup.length === 1 && isBoundToContainer(elementsGroup[0])),
     )
-    .flatMap((elementGroup) =>
-      getElementsSnapPoints(
-        elementGroup,
-        elementsMap,
-        {},
-        getSnapSourceId(elementGroup),
-      ),
-    );
+    .flatMap((elementGroup) => getElementsCorners(elementGroup, elementsMap));
 };
 
-/**
- * Collects point snaps within snap distance. Unlike gap snaps, point snaps first
- * go through visual-cluster filtering so a nearby reference can beat a slightly
- * better offset from a far-away reference.
- */
 const getPointSnaps = (
   selectedElements: ExcalidrawElement[],
-  selectionSnapPoints: SnapPoint[],
+  selectionSnapPoints: GlobalPoint[],
   app: AppClassProperties,
   event: KeyboardModifiersObject,
   nearestSnapsX: Snaps,
@@ -885,62 +654,39 @@ const getPointSnaps = (
   if (referenceSnapPoints) {
     for (const thisSnapPoint of selectionSnapPoints) {
       for (const otherSnapPoint of referenceSnapPoints) {
-        const offsetX = otherSnapPoint.point[0] - thisSnapPoint.point[0];
-        const offsetY = otherSnapPoint.point[1] - thisSnapPoint.point[1];
+        const offsetX = otherSnapPoint[0] - thisSnapPoint[0];
+        const offsetY = otherSnapPoint[1] - thisSnapPoint[1];
+
+        if (Math.abs(offsetX) <= minOffset.x) {
+          if (Math.abs(offsetX) < minOffset.x) {
+            nearestSnapsX.length = 0;
+          }
 
-        if (isWithinSnapOffset(offsetX, minOffset.x)) {
           nearestSnapsX.push({
             type: "point",
-            points: [thisSnapPoint.point, otherSnapPoint.point],
-            pointTypes: [thisSnapPoint.type, otherSnapPoint.type],
-            snapSourceIds: [
-              thisSnapPoint.snapSourceId,
-              otherSnapPoint.snapSourceId,
-            ],
-            visualDistance: Math.abs(
-              otherSnapPoint.point[1] - thisSnapPoint.point[1],
-            ),
+            points: [thisSnapPoint, otherSnapPoint],
             offset: offsetX,
           });
+
+          minOffset.x = Math.abs(offsetX);
         }
 
-        if (isWithinSnapOffset(offsetY, minOffset.y)) {
+        if (Math.abs(offsetY) <= minOffset.y) {
+          if (Math.abs(offsetY) < minOffset.y) {
+            nearestSnapsY.length = 0;
+          }
+
           nearestSnapsY.push({
             type: "point",
-            points: [thisSnapPoint.point, otherSnapPoint.point],
-            pointTypes: [thisSnapPoint.type, otherSnapPoint.type],
-            snapSourceIds: [
-              thisSnapPoint.snapSourceId,
-              otherSnapPoint.snapSourceId,
-            ],
-            visualDistance: Math.abs(
-              otherSnapPoint.point[0] - thisSnapPoint.point[0],
-            ),
+            points: [thisSnapPoint, otherSnapPoint],
             offset: offsetY,
           });
+
+          minOffset.y = Math.abs(offsetY);
         }
       }
     }
   }
-
-  const clusterBreakDistance = getSnapReferenceClusterBreakDistance(
-    app.state.zoom.value,
-  );
-
-  filterPointSnapsToNearestCluster(nearestSnapsX, clusterBreakDistance);
-  filterPointSnapsToNearestCluster(nearestSnapsY, clusterBreakDistance);
-
-  if (nearestSnapsX.length > 0) {
-    minOffset.x = Math.min(
-      ...nearestSnapsX.map((snap) => Math.abs(snap.offset)),
-    );
-  }
-
-  if (nearestSnapsY.length > 0) {
-    minOffset.y = Math.min(
-      ...nearestSnapsY.map((snap) => Math.abs(snap.offset)),
-    );
-  }
 };
 
 export const snapDraggedElements = (
@@ -974,7 +720,7 @@ export const snapDraggedElements = (
     y: snapDistance,
   };
 
-  const selectionPoints = getElementsSnapPoints(selectedElements, elementsMap, {
+  const selectionPoints = getElementsCorners(selectedElements, elementsMap, {
     dragOffset,
   });
 
@@ -1024,7 +770,7 @@ export const snapDraggedElements = (
 
   getPointSnaps(
     selectedElements,
-    getElementsSnapPoints(selectedElements, elementsMap, {
+    getElementsCorners(selectedElements, elementsMap, {
       dragOffset: newDragOffset,
     }),
     app,
@@ -1079,185 +825,12 @@ const dedupePoints = (points: GlobalPoint[]): GlobalPoint[] => {
   return Array.from(map.values());
 };
 
-// Point snaplines are collected from every winning point snap first. Multiple
-// snap source pairs can collapse to the same rendered line, so candidates keep
-// source-pair metadata until redundant center and inner outer lines are removed.
-type PointSnapLineSourcePair = {
-  snapSourcePairKey: string;
-  pointType: SnapPointType;
-};
-
-type PointSnapLineCandidate = PointSnapLine & {
-  sourcePairs: PointSnapLineSourcePair[];
-};
-
-type PointSnapLineBucket = {
-  points: GlobalPoint[];
-  sourcePairs: PointSnapLineSourcePair[];
-};
-
-type OuterSnapLineCoordinateRange = {
-  count: number;
-  min: number;
-  max: number;
-};
-
-/**
- * Describes which snap source pair produced a rendered point snapline, so later
- * filtering can reason about redundancy without mixing unrelated references.
- * Only center-to-center snaps count as center snaplines; a center-to-outer snap
- * still explains an outer edge or midpoint alignment.
- */
-const getPointSnapLineSourcePair = (
-  snap: PointSnap,
-): PointSnapLineSourcePair => {
-  return {
-    snapSourcePairKey: snap.snapSourceIds.join("->"),
-    pointType: snap.pointTypes.every((pointType) => pointType === "center")
-      ? "center"
-      : "outer",
-  };
-};
-
-/**
- * Builds each snap source pair's outer coordinate range. Center snaplines use
- * this range to decide whether the surrounding outer lines already explain
- * them, and outer snaplines use it to keep only the two extremes.
- */
-const getOuterCoordinateRangesBySnapSourcePairKey = (
-  snapLines: PointSnapLineCandidate[],
-  getCoordinate: (snapLine: PointSnapLine) => number,
-) => {
-  const ranges = new Map<string, OuterSnapLineCoordinateRange>();
-
-  for (const snapLine of snapLines) {
-    const coordinate = getCoordinate(snapLine);
-
-    for (const sourcePair of snapLine.sourcePairs) {
-      if (sourcePair.pointType === "center") {
-        continue;
-      }
-
-      const range = ranges.get(sourcePair.snapSourcePairKey);
-
-      ranges.set(sourcePair.snapSourcePairKey, {
-        count: (range?.count ?? 0) + 1,
-        min: range ? Math.min(range.min, coordinate) : coordinate,
-        max: range ? Math.max(range.max, coordinate) : coordinate,
-      });
-    }
-  }
-
-  return ranges;
-};
-
-/**
- * A center snapline is redundant when outer snaplines from the same snap source
- * pair exist on both sides, because the outer lines already imply center
- * alignment.
- */
-const isRedundantCenterSnapLine = (
-  coordinate: number,
-  outerCoordinateRange?: OuterSnapLineCoordinateRange,
-) => {
-  if (!outerCoordinateRange) {
-    return false;
-  }
-
-  return (
-    outerCoordinateRange.min < coordinate &&
-    outerCoordinateRange.max > coordinate
-  );
-};
-
-/**
- * When more than two outer snaplines come from the same snap source pair, the
- * inner ones are redundant; the two extremes communicate the same shape
- * alignment.
- */
-const isRedundantOuterSnapLine = (
-  coordinate: number,
-  outerCoordinateRange?: OuterSnapLineCoordinateRange,
-) => {
-  if (!outerCoordinateRange || outerCoordinateRange.count <= 2) {
-    return false;
-  }
-
-  return (
-    coordinate !== outerCoordinateRange.min &&
-    coordinate !== outerCoordinateRange.max
-  );
-};
-
-/**
- * Keeps a visual snapline if at least one snap source pair represented by the
- * line still needs it. This matters when multiple snap source pairs collapse to
- * the same rendered coordinate.
- */
-const isPointSnapLineNeededBySourcePair = (
-  sourcePair: PointSnapLineSourcePair,
-  coordinate: number,
-  outerCoordinateRangesBySnapSourcePairKey: Map<
-    string,
-    OuterSnapLineCoordinateRange
-  >,
-) => {
-  const outerCoordinateRange = outerCoordinateRangesBySnapSourcePairKey.get(
-    sourcePair.snapSourcePairKey,
-  );
-
-  if (sourcePair.pointType === "center") {
-    return !isRedundantCenterSnapLine(coordinate, outerCoordinateRange);
-  }
-
-  return !isRedundantOuterSnapLine(coordinate, outerCoordinateRange);
-};
-
-/**
- * Removes point snaplines that are visually redundant, while preserving any line
- * that is still needed by at least one snap source pair represented on that
- * line.
- */
-const filterRedundantPointSnapLines = (
-  snapLines: PointSnapLineCandidate[],
-  getCoordinate: (snapLine: PointSnapLine) => number,
-): PointSnapLine[] => {
-  if (snapLines.length < 3) {
-    return snapLines.map(({ sourcePairs, ...snapLine }) => snapLine);
-  }
-
-  // Track outer-line ranges per snap source pair. The same visual snapline can
-  // be produced by multiple snap source pairs, so a line is removed only when
-  // every pair represented by that line considers it redundant.
-  const outerCoordinateRangesBySnapSourcePairKey =
-    getOuterCoordinateRangesBySnapSourcePairKey(snapLines, getCoordinate);
-
-  return snapLines
-    .filter((snapLine) => {
-      const coordinate = getCoordinate(snapLine);
-
-      return snapLine.sourcePairs.some((sourcePair) =>
-        isPointSnapLineNeededBySourcePair(
-          sourcePair,
-          coordinate,
-          outerCoordinateRangesBySnapSourcePairKey,
-        ),
-      );
-    })
-    .map(({ sourcePairs, ...snapLine }) => snapLine);
-};
-
-/**
- * Merges point snaps that render on the same x/y coordinate, attaches their
- * snap source pair metadata, then removes redundant center and inner outer
- * lines.
- */
 const createPointSnapLines = (
   nearestSnapsX: Snaps,
   nearestSnapsY: Snaps,
 ): PointSnapLine[] => {
-  const snapsX = {} as { [key: string]: PointSnapLineBucket };
-  const snapsY = {} as { [key: string]: PointSnapLineBucket };
+  const snapsX = {} as { [key: string]: GlobalPoint[] };
+  const snapsY = {} as { [key: string]: GlobalPoint[] };
 
   if (nearestSnapsX.length > 0) {
     for (const snap of nearestSnapsX) {
@@ -1265,14 +838,13 @@ const createPointSnapLines = (
         // key = thisPoint.x
         const key = round(snap.points[0][0]);
         if (!snapsX[key]) {
-          snapsX[key] = { points: [], sourcePairs: [] };
+          snapsX[key] = [];
         }
-        snapsX[key].points.push(
+        snapsX[key].push(
           ...snap.points.map((p) =>
             pointFrom<GlobalPoint>(round(p[0]), round(p[1])),
           ),
         );
-        snapsX[key].sourcePairs.push(getPointSnapLineSourcePair(snap));
       }
     }
   }
@@ -1283,55 +855,44 @@ const createPointSnapLines = (
         // key = thisPoint.y
         const key = round(snap.points[0][1]);
         if (!snapsY[key]) {
-          snapsY[key] = { points: [], sourcePairs: [] };
+          snapsY[key] = [];
         }
-        snapsY[key].points.push(
+        snapsY[key].push(
           ...snap.points.map((p) =>
             pointFrom<GlobalPoint>(round(p[0]), round(p[1])),
           ),
         );
-        snapsY[key].sourcePairs.push(getPointSnapLineSourcePair(snap));
       }
     }
   }
 
-  const snapLinesX = Object.entries(snapsX).map(([key, snap]) => {
-    return {
-      type: "points",
-      points: dedupePoints(
-        snap.points
-          .map((p) => {
-            return pointFrom<GlobalPoint>(Number(key), p[1]);
-          })
-          .sort((a, b) => a[1] - b[1]),
-      ),
-      sourcePairs: snap.sourcePairs,
-    } as PointSnapLineCandidate;
-  });
-
-  const snapLinesY = Object.entries(snapsY).map(([key, snap]) => {
-    return {
-      type: "points",
-      points: dedupePoints(
-        snap.points
-          .map((p) => {
-            return pointFrom<GlobalPoint>(p[0], Number(key));
-          })
-          .sort((a, b) => a[0] - b[0]),
-      ),
-      sourcePairs: snap.sourcePairs,
-    } as PointSnapLineCandidate;
-  });
-
-  return filterRedundantPointSnapLines(
-    snapLinesX,
-    (snapLine) => snapLine.points[0][0],
-  ).concat(
-    filterRedundantPointSnapLines(
-      snapLinesY,
-      (snapLine) => snapLine.points[0][1],
-    ),
-  );
+  return Object.entries(snapsX)
+    .map(([key, points]) => {
+      return {
+        type: "points",
+        points: dedupePoints(
+          points
+            .map((p) => {
+              return pointFrom<GlobalPoint>(Number(key), p[1]);
+            })
+            .sort((a, b) => a[1] - b[1]),
+        ),
+      } as PointSnapLine;
+    })
+    .concat(
+      Object.entries(snapsY).map(([key, points]) => {
+        return {
+          type: "points",
+          points: dedupePoints(
+            points
+              .map((p) => {
+                return pointFrom<GlobalPoint>(p[0], Number(key));
+              })
+              .sort((a, b) => a[0] - b[0]),
+          ),
+        } as PointSnapLine;
+      }),
+    );
 };
 
 const dedupeGapSnapLines = (gapSnapLines: GapSnapLine[]) => {
@@ -1356,13 +917,10 @@ const createGapSnapLines = (
   dragOffset: Vector2D,
   gapSnaps: GapSnap[],
 ): GapSnapLine[] => {
-  // Use the same rounded bounds as getGapSnaps(). Otherwise a gap snap can be
-  // accepted during snapping but skipped here because the raw bounds miss the
-  // reference gap overlap by a tiny floating-point delta.
   const [minX, minY, maxX, maxY] = getDraggedElementsBounds(
     selectedElements,
     dragOffset,
-  ).map((bound) => round(bound));
+  );
 
   const gapSnapLines: GapSnapLine[] = [];
 
@@ -1585,52 +1143,40 @@ export const snapResizingElements = (
     }
   }
 
-  const selectionSnapPoints: SnapPoint[] = [];
+  const selectionSnapPoints: GlobalPoint[] = [];
 
   if (transformHandle) {
     switch (transformHandle) {
       case "e": {
-        selectionSnapPoints.push(
-          outerSnapPoint(pointFrom(maxX, minY)),
-          outerSnapPoint(pointFrom(maxX, maxY)),
-        );
+        selectionSnapPoints.push(pointFrom(maxX, minY), pointFrom(maxX, maxY));
         break;
       }
       case "w": {
-        selectionSnapPoints.push(
-          outerSnapPoint(pointFrom(minX, minY)),
-          outerSnapPoint(pointFrom(minX, maxY)),
-        );
+        selectionSnapPoints.push(pointFrom(minX, minY), pointFrom(minX, maxY));
         break;
       }
       case "n": {
-        selectionSnapPoints.push(
-          outerSnapPoint(pointFrom(minX, minY)),
-          outerSnapPoint(pointFrom(maxX, minY)),
-        );
+        selectionSnapPoints.push(pointFrom(minX, minY), pointFrom(maxX, minY));
         break;
       }
       case "s": {
-        selectionSnapPoints.push(
-          outerSnapPoint(pointFrom(minX, maxY)),
-          outerSnapPoint(pointFrom(maxX, maxY)),
-        );
+        selectionSnapPoints.push(pointFrom(minX, maxY), pointFrom(maxX, maxY));
         break;
       }
       case "ne": {
-        selectionSnapPoints.push(outerSnapPoint(pointFrom(maxX, minY)));
+        selectionSnapPoints.push(pointFrom(maxX, minY));
         break;
       }
       case "nw": {
-        selectionSnapPoints.push(outerSnapPoint(pointFrom(minX, minY)));
+        selectionSnapPoints.push(pointFrom(minX, minY));
         break;
       }
       case "se": {
-        selectionSnapPoints.push(outerSnapPoint(pointFrom(maxX, maxY)));
+        selectionSnapPoints.push(pointFrom(maxX, maxY));
         break;
       }
       case "sw": {
-        selectionSnapPoints.push(outerSnapPoint(pointFrom(minX, maxY)));
+        selectionSnapPoints.push(pointFrom(minX, maxY));
         break;
       }
     }
@@ -1672,11 +1218,11 @@ export const snapResizingElements = (
     round(bound),
   );
 
-  const corners: SnapPoint[] = [
-    outerSnapPoint(pointFrom(x1, y1)),
-    outerSnapPoint(pointFrom(x1, y2)),
-    outerSnapPoint(pointFrom(x2, y1)),
-    outerSnapPoint(pointFrom(x2, y2)),
+  const corners: GlobalPoint[] = [
+    pointFrom(x1, y1),
+    pointFrom(x1, y2),
+    pointFrom(x2, y1),
+    pointFrom(x2, y2),
   ];
 
   getPointSnaps(
@@ -1712,8 +1258,8 @@ export const snapNewElement = (
     };
   }
 
-  const selectionSnapPoints: SnapPoint[] = [
-    outerSnapPoint(pointFrom(origin.x + dragOffset.x, origin.y + dragOffset.y)),
+  const selectionSnapPoints: GlobalPoint[] = [
+    pointFrom(origin.x + dragOffset.x, origin.y + dragOffset.y),
   ];
 
   const snapDistance = getSnapDistance(app.state.zoom.value);
@@ -1746,7 +1292,7 @@ export const snapNewElement = (
   nearestSnapsX.length = 0;
   nearestSnapsY.length = 0;
 
-  const corners = getElementsSnapPoints([newElement], elementsMap, {
+  const corners = getElementsCorners([newElement], elementsMap, {
     boundingBoxCorners: true,
     omitCenter: true,
   });

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

@@ -979,6 +979,7 @@ exports[`contextMenu element > right-clicking on a group should select whole gro
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -1172,6 +1173,7 @@ exports[`contextMenu element > selecting 'Add to library' in context menu adds e
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -1386,6 +1388,7 @@ exports[`contextMenu element > selecting 'Bring forward' in context menu brings
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -1717,6 +1720,7 @@ exports[`contextMenu element > selecting 'Bring to front' in context menu brings
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -2048,6 +2052,7 @@ exports[`contextMenu element > selecting 'Copy styles' in context menu copies st
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -2260,6 +2265,7 @@ exports[`contextMenu element > selecting 'Delete' in context menu deletes elemen
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -2503,6 +2509,7 @@ exports[`contextMenu element > selecting 'Duplicate' in context menu duplicates
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -2806,6 +2813,7 @@ exports[`contextMenu element > selecting 'Group selection' in context menu group
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -3173,6 +3181,7 @@ exports[`contextMenu element > selecting 'Paste styles' in context menu pastes s
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -3666,6 +3675,7 @@ exports[`contextMenu element > selecting 'Send backward' in context menu sends e
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -3989,6 +3999,7 @@ exports[`contextMenu element > selecting 'Send to back' in context menu sends el
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -4315,6 +4326,7 @@ exports[`contextMenu element > selecting 'Ungroup selection' in context menu ung
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -5600,6 +5612,7 @@ exports[`contextMenu element > shows 'Group selection' in context menu for multi
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -6819,6 +6832,7 @@ exports[`contextMenu element > shows 'Ungroup selection' in context menu for gro
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -7772,6 +7786,7 @@ exports[`contextMenu element > shows context menu for canvas > [end of test] app
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -8771,6 +8786,7 @@ exports[`contextMenu element > shows context menu for element > [end of test] ap
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -9765,6 +9781,7 @@ exports[`contextMenu element > shows context menu for element > [end of test] ap
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,

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

@@ -1293,6 +1293,7 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -1653,6 +1654,7 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -2015,6 +2017,7 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -2277,40 +2280,7 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
-  "startBoundElement": {
-    "angle": 0,
-    "backgroundColor": "transparent",
-    "boundElements": [
-      {
-        "id": "id4",
-        "type": "arrow",
-      },
-    ],
-    "customData": undefined,
-    "fillStyle": "solid",
-    "frameId": null,
-    "groupIds": [],
-    "height": 100,
-    "id": "id0",
-    "index": "a0",
-    "isDeleted": false,
-    "link": null,
-    "locked": false,
-    "opacity": 100,
-    "roughness": 1,
-    "roundness": null,
-    "seed": 1,
-    "strokeColor": "#1e1e1e",
-    "strokeStyle": "solid",
-    "strokeWidth": 2,
-    "type": "rectangle",
-    "updated": 1,
-    "version": 3,
-    "versionNonce": 493213705,
-    "width": 100,
-    "x": -100,
-    "y": -50,
-  },
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -2765,6 +2735,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -3068,6 +3039,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -3387,6 +3359,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -3681,6 +3654,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -3967,6 +3941,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -4202,6 +4177,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -4459,6 +4435,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -4730,6 +4707,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -4959,6 +4937,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -5188,6 +5167,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -5435,6 +5415,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -5691,6 +5672,7 @@ exports[`history > multiplayer undo/redo > conflicts in frames and their childre
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -5948,6 +5930,7 @@ exports[`history > multiplayer undo/redo > should iterate through the history wh
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -6277,6 +6260,7 @@ exports[`history > multiplayer undo/redo > should iterate through the history wh
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -6707,6 +6691,7 @@ exports[`history > multiplayer undo/redo > should iterate through the history wh
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -7087,6 +7072,7 @@ exports[`history > multiplayer undo/redo > should iterate through the history wh
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -7681,6 +7667,7 @@ exports[`history > multiplayer undo/redo > should iterate through the history wh
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -7911,6 +7898,7 @@ exports[`history > multiplayer undo/redo > should iterate through the history wh
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -8263,6 +8251,7 @@ exports[`history > multiplayer undo/redo > should iterate through the history wh
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -8621,6 +8610,7 @@ exports[`history > multiplayer undo/redo > should not let remote changes to inte
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -9021,6 +9011,7 @@ exports[`history > multiplayer undo/redo > should not let remote changes to inte
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -9302,6 +9293,7 @@ exports[`history > multiplayer undo/redo > should not let remote changes to inte
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -9566,6 +9558,7 @@ exports[`history > multiplayer undo/redo > should not override remote changes on
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -9831,6 +9824,7 @@ exports[`history > multiplayer undo/redo > should not override remote changes on
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -10064,6 +10058,7 @@ exports[`history > multiplayer undo/redo > should override remotely added groups
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -10676,6 +10671,7 @@ exports[`history > multiplayer undo/redo > should redistribute deltas when eleme
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -10915,6 +10911,7 @@ exports[`history > multiplayer undo/redo > should redraw arrows on undo > [end o
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -11839,6 +11836,7 @@ exports[`history > multiplayer undo/redo > should update history entries after r
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -12097,6 +12095,7 @@ exports[`history > singleplayer undo/redo > remounting undo/redo buttons should
   "showHyperlinkPopup": false,
   "showWelcomeScreen": false,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -12334,6 +12333,7 @@ exports[`history > singleplayer undo/redo > should clear the redo stack on eleme
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -12569,6 +12569,7 @@ exports[`history > singleplayer undo/redo > should create entry when selecting f
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -12965,6 +12966,7 @@ exports[`history > singleplayer undo/redo > should create new history entry on e
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -13172,6 +13174,7 @@ exports[`history > singleplayer undo/redo > should create new history entry on e
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -13383,6 +13386,7 @@ exports[`history > singleplayer undo/redo > should create new history entry on i
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -13681,6 +13685,7 @@ exports[`history > singleplayer undo/redo > should create new history entry on i
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -13979,6 +13984,7 @@ exports[`history > singleplayer undo/redo > should create new history entry on s
   "showHyperlinkPopup": false,
   "showWelcomeScreen": false,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -14223,6 +14229,7 @@ exports[`history > singleplayer undo/redo > should disable undo/redo buttons whe
   "showHyperlinkPopup": false,
   "showWelcomeScreen": false,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -14460,6 +14467,7 @@ exports[`history > singleplayer undo/redo > should end up with no history entry
   "showHyperlinkPopup": false,
   "showWelcomeScreen": false,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -14697,6 +14705,7 @@ exports[`history > singleplayer undo/redo > should iterate through the history w
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -14944,6 +14953,7 @@ exports[`history > singleplayer undo/redo > should not clear the redo stack on s
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -15276,6 +15286,7 @@ exports[`history > singleplayer undo/redo > should not collapse when applying co
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -15448,6 +15459,7 @@ exports[`history > singleplayer undo/redo > should not end up with history entry
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -15730,6 +15742,7 @@ exports[`history > singleplayer undo/redo > should not end up with history entry
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -15993,6 +16006,7 @@ exports[`history > singleplayer undo/redo > should not modify anything on unrela
   "showHyperlinkPopup": false,
   "showWelcomeScreen": false,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -16147,6 +16161,7 @@ exports[`history > singleplayer undo/redo > should not override appstate changes
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -16428,6 +16443,7 @@ exports[`history > singleplayer undo/redo > should support appstate name or view
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -20154,6 +20170,7 @@ exports[`history > singleplayer undo/redo > should support changes in elements'
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -20636,6 +20653,7 @@ exports[`history > singleplayer undo/redo > should support duplication of groups
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -21142,6 +21160,7 @@ exports[`history > singleplayer undo/redo > should support element creation, del
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,

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

@@ -106,6 +106,7 @@ exports[`given element A and group of elements B and given both are selected whe
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -534,6 +535,7 @@ exports[`given element A and group of elements B and given both are selected whe
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -941,6 +943,7 @@ exports[`regression tests > Cmd/Ctrl-click exclusively select element under poin
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -1507,6 +1510,7 @@ exports[`regression tests > Drags selected element when hitting only bounding bo
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -1719,6 +1723,7 @@ exports[`regression tests > adjusts z order when grouping > [end of test] appSta
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -2100,6 +2105,7 @@ exports[`regression tests > alt-drag duplicates an element > [end of test] appSt
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -2343,6 +2349,7 @@ exports[`regression tests > arrow keys > [end of test] appState 1`] = `
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -2525,6 +2532,7 @@ exports[`regression tests > can drag element that covers another element, while
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -2848,6 +2856,7 @@ exports[`regression tests > change the properties of a shape > [end of test] app
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -3105,6 +3114,7 @@ exports[`regression tests > click on an element and drag it > [dragged] appState
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -3346,6 +3356,7 @@ exports[`regression tests > click on an element and drag it > [end of test] appS
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -3582,6 +3593,7 @@ exports[`regression tests > click to select a shape > [end of test] appState 1`]
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -3841,6 +3853,7 @@ exports[`regression tests > click-drag to select a group > [end of test] appStat
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -4154,6 +4167,7 @@ exports[`regression tests > deleting last but one element in editing group shoul
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -4617,6 +4631,7 @@ exports[`regression tests > deselects group of selected elements on pointer down
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -4872,6 +4887,7 @@ exports[`regression tests > deselects group of selected elements on pointer up w
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -5175,6 +5191,7 @@ exports[`regression tests > deselects selected element on pointer down when poin
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -5355,6 +5372,7 @@ exports[`regression tests > deselects selected element, on pointer up, when clic
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -5555,6 +5573,7 @@ exports[`regression tests > double click to edit a group > [end of test] appStat
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -5952,6 +5971,7 @@ exports[`regression tests > drags selected elements from point inside common bou
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -7037,6 +7057,7 @@ exports[`regression tests > given a group of selected elements with an element t
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -7371,6 +7392,7 @@ exports[`regression tests > given a selected element A and a not selected elemen
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -7649,6 +7671,7 @@ exports[`regression tests > given selected element A with lower z-index than uns
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -7884,6 +7907,7 @@ exports[`regression tests > given selected element A with lower z-index than uns
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -8122,6 +8146,7 @@ exports[`regression tests > key 2 selects rectangle tool > [end of test] appStat
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -8302,6 +8327,7 @@ exports[`regression tests > key 3 selects diamond tool > [end of test] appState
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -8482,6 +8508,7 @@ exports[`regression tests > key 4 selects ellipse tool > [end of test] appState
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -9124,6 +9151,7 @@ exports[`regression tests > key 7 selects freedraw tool > [end of test] appState
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -9551,6 +9579,7 @@ exports[`regression tests > key d selects diamond tool > [end of test] appState
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -9962,6 +9991,7 @@ exports[`regression tests > key o selects ellipse tool > [end of test] appState
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -10140,6 +10170,7 @@ exports[`regression tests > key p selects freedraw tool > [end of test] appState
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -10334,6 +10365,7 @@ exports[`regression tests > key r selects rectangle tool > [end of test] appStat
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -10522,6 +10554,7 @@ exports[`regression tests > make a group and duplicate it > [end of test] appSta
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -11047,6 +11080,7 @@ exports[`regression tests > noop interaction after undo shouldn't create history
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -11323,6 +11357,7 @@ exports[`regression tests > pinch-to-zoom works > [end of test] appState 1`] = `
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -11448,6 +11483,7 @@ exports[`regression tests > shift click on selected element should deselect it o
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -11652,6 +11688,7 @@ exports[`regression tests > shift-click to multiselect, then drag > [end of test
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -11973,6 +12010,7 @@ exports[`regression tests > should group elements and ungroup them > [end of tes
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -12406,6 +12444,7 @@ exports[`regression tests > single-clicking on a subgroup of a selected group sh
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -13037,6 +13076,7 @@ exports[`regression tests > spacebar + drag scrolls the canvas > [end of test] a
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -13164,6 +13204,7 @@ exports[`regression tests > supports nested groups > [end of test] appState 1`]
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -13824,6 +13865,7 @@ exports[`regression tests > switches from group of selected elements to another
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -14162,6 +14204,7 @@ exports[`regression tests > switches selected element on pointer down > [end of
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -14394,6 +14437,7 @@ exports[`regression tests > two-finger scroll works > [end of test] appState 1`]
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -14882,6 +14926,7 @@ exports[`regression tests > updates fontSize & fontFamily appState > [end of tes
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -15008,6 +15053,7 @@ exports[`regression tests > zoom hotkeys > [end of test] appState 1`] = `
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,

packages/excalidraw/tests/selection.test.tsx

@@ -615,32 +615,6 @@ describe("box-selection overlap mode", () => {
 
     assertSelectedElements([]);
   });
-
-  it("should not select a framed element when selection only overlaps its clipped-out outline", () => {
-    const frame = API.createElement({
-      type: "frame",
-      x: 100,
-      y: 100,
-      width: 100,
-      height: 100,
-    });
-    const rect1 = API.createElement({
-      type: "rectangle",
-      x: 50,
-      y: 50,
-      width: 200,
-      height: 200,
-      frameId: frame.id,
-      backgroundColor: "red",
-      fillStyle: "solid",
-    });
-
-    API.setElements([frame, rect1]);
-
-    boxSelect(40, 170, 70, 220);
-
-    assertSelectedElements([]);
-  });
 });
 
 describe("inner box-selection", () => {

packages/excalidraw/tests/snapping.test.ts

@@ -1,833 +0,0 @@
-import { arrayToMap } from "@excalidraw/common";
-import {
-  pointFrom,
-  rangeInclusive,
-  type GlobalPoint,
-  type Radians,
-} from "@excalidraw/math";
-
-import type { ExcalidrawElement } from "@excalidraw/element/types";
-
-import { getDefaultAppState } from "../appState";
-import {
-  getElementsCorners,
-  getVisibleGaps,
-  getReferenceSnapPoints,
-  SnapCache,
-  snapDraggedElements,
-} from "../snapping";
-
-import { API } from "./helpers/api";
-
-import type {
-  AppClassProperties,
-  AppState,
-  NormalizedZoomValue,
-} from "../types";
-
-type ReferenceSnapPoints = NonNullable<
-  ReturnType<typeof SnapCache.getReferenceSnapPoints>
->;
-
-const NO_MODIFIER_KEYS = {
-  altKey: false,
-  ctrlKey: false,
-  metaKey: false,
-  shiftKey: false,
-};
-
-const createSnappingApp = (appState: Partial<AppState> = {}) =>
-  ({
-    props: {},
-    state: {
-      ...getDefaultAppState(),
-      objectsSnapModeEnabled: true,
-      width: 1000,
-      height: 1000,
-      offsetLeft: 0,
-      offsetTop: 0,
-      ...appState,
-    },
-  } as AppClassProperties);
-
-const getHorizontalPointSnapLineCoordinates = (
-  snapLines: ReturnType<typeof snapDraggedElements>["snapLines"],
-) => {
-  return snapLines
-    .filter((snapLine) => snapLine.type === "points")
-    .filter((snapLine) => {
-      const [firstPoint, lastPoint] = snapLine.points;
-
-      return firstPoint[1] === lastPoint[1];
-    })
-    .map((snapLine) => {
-      return snapLine.points[0][1];
-    })
-    .sort((a, b) => a - b);
-};
-
-const getVerticalPointSnapLineCoordinates = (
-  snapLines: ReturnType<typeof snapDraggedElements>["snapLines"],
-) => {
-  return snapLines
-    .filter((snapLine) => snapLine.type === "points")
-    .filter((snapLine) => {
-      const [firstPoint, lastPoint] = snapLine.points;
-
-      return firstPoint[0] === lastPoint[0];
-    })
-    .map((snapLine) => {
-      return snapLine.points[0][0];
-    })
-    .sort((a, b) => a - b);
-};
-
-const getHorizontalPointSnapLineMaxX = (
-  snapLines: ReturnType<typeof snapDraggedElements>["snapLines"],
-) => {
-  const horizontalSnapLine = snapLines
-    .filter((snapLine) => snapLine.type === "points")
-    .find((snapLine) => {
-      const [firstPoint, lastPoint] = snapLine.points;
-
-      return firstPoint[1] === lastPoint[1];
-    });
-
-  if (!horizontalSnapLine) {
-    return null;
-  }
-
-  return horizontalSnapLine.points[horizontalSnapLine.points.length - 1][0];
-};
-
-const getHorizontalPointSnapLineXRange = (
-  snapLines: ReturnType<typeof snapDraggedElements>["snapLines"],
-) => {
-  const horizontalSnapLine = snapLines
-    .filter((snapLine) => snapLine.type === "points")
-    .find((snapLine) => {
-      const [firstPoint, lastPoint] = snapLine.points;
-
-      return firstPoint[1] === lastPoint[1];
-    });
-
-  if (!horizontalSnapLine) {
-    return null;
-  }
-
-  return [
-    horizontalSnapLine.points[0][0],
-    horizontalSnapLine.points[horizontalSnapLine.points.length - 1][0],
-  ] as const;
-};
-
-const getHorizontalGapSnapLines = (
-  snapLines: ReturnType<typeof snapDraggedElements>["snapLines"],
-) => {
-  return snapLines.filter(
-    (snapLine) =>
-      snapLine.type === "gap" && snapLine.direction === "horizontal",
-  );
-};
-
-const getVerticalGapSnapLines = (
-  snapLines: ReturnType<typeof snapDraggedElements>["snapLines"],
-) => {
-  return snapLines.filter(
-    (snapLine) => snapLine.type === "gap" && snapLine.direction === "vertical",
-  );
-};
-
-const getPointKeys = (points: ReturnType<typeof getElementsCorners>) => {
-  return points.map((point) => point.join(","));
-};
-
-const getReferenceSnapPointKeys = (
-  elements: ExcalidrawElement[],
-  selectedElements: ExcalidrawElement[],
-  app: AppClassProperties,
-) => {
-  return new Set(
-    getReferenceSnapPoints(
-      elements,
-      selectedElements,
-      app.state,
-      arrayToMap(elements),
-    ).map((snapPoint) => snapPoint.point.join(",")),
-  );
-};
-
-const primeReferenceSnapPoints = (
-  elements: ExcalidrawElement[],
-  selectedElements: ExcalidrawElement[],
-) => {
-  const selectedElementIds = new Set(
-    selectedElements.map((element) => element.id),
-  );
-  const elementsMap = arrayToMap(elements);
-
-  SnapCache.setReferenceSnapPoints(
-    elements
-      .filter((element) => !selectedElementIds.has(element.id))
-      .flatMap((element) => {
-        const corners = getElementsCorners([element], elementsMap);
-
-        return corners.map((point, index) => ({
-          point,
-          type: index === corners.length - 1 ? "center" : "outer",
-          snapSourceId: element.id,
-        }));
-      }) as Parameters<typeof SnapCache.setReferenceSnapPoints>[0],
-  );
-};
-
-describe("snapping", () => {
-  afterEach(() => {
-    SnapCache.destroy();
-  });
-
-  it("does not use frame children as references when snapping outside elements", () => {
-    const frame = API.createElement({
-      type: "frame",
-      id: "frame",
-      x: 0,
-      y: 0,
-      width: 300,
-      height: 300,
-    });
-    const frameChild = API.createElement({
-      type: "rectangle",
-      id: "frameChild",
-      x: 37,
-      y: 53,
-      width: 71,
-      height: 83,
-      frameId: frame.id,
-    });
-    const selected = API.createElement({
-      type: "rectangle",
-      id: "selected",
-      x: 400,
-      y: 50,
-      width: 100,
-      height: 100,
-    });
-    const elements = [frame, frameChild, selected];
-    const app = createSnappingApp({
-      selectedElementIds: { [selected.id]: true },
-    });
-
-    const referenceSnapPointKeys = getReferenceSnapPointKeys(
-      elements,
-      [selected],
-      app,
-    );
-    const frameChildPointKeys = getPointKeys(
-      getElementsCorners([frameChild], arrayToMap(elements)),
-    );
-
-    expect(
-      frameChildPointKeys.some((pointKey) =>
-        referenceSnapPointKeys.has(pointKey),
-      ),
-    ).toBe(false);
-  });
-
-  it("uses frame siblings as references when snapping elements in the same frame", () => {
-    const frame = API.createElement({
-      type: "frame",
-      id: "frame",
-      x: 0,
-      y: 0,
-      width: 300,
-      height: 300,
-    });
-    const sibling = API.createElement({
-      type: "rectangle",
-      id: "sibling",
-      x: 37,
-      y: 53,
-      width: 71,
-      height: 83,
-      frameId: frame.id,
-    });
-    const selected = API.createElement({
-      type: "rectangle",
-      id: "selected",
-      x: 150,
-      y: 50,
-      width: 100,
-      height: 100,
-      frameId: frame.id,
-    });
-    const elements = [frame, sibling, selected];
-    const app = createSnappingApp({
-      selectedElementIds: { [selected.id]: true },
-    });
-
-    const referenceSnapPointKeys = getReferenceSnapPointKeys(
-      elements,
-      [selected],
-      app,
-    );
-    const siblingPointKeys = getPointKeys(
-      getElementsCorners([sibling], arrayToMap(elements)),
-    );
-
-    expect(
-      siblingPointKeys.some((pointKey) => referenceSnapPointKeys.has(pointKey)),
-    ).toBe(true);
-  });
-
-  it("does not use frame children as references when snapping the frame itself", () => {
-    const frame = API.createElement({
-      type: "frame",
-      id: "frame",
-      x: 0,
-      y: 0,
-      width: 300,
-      height: 300,
-    });
-    const frameChild = API.createElement({
-      type: "rectangle",
-      id: "frameChild",
-      x: 37,
-      y: 53,
-      width: 71,
-      height: 83,
-      frameId: frame.id,
-    });
-    const elements = [frame, frameChild];
-    const app = createSnappingApp({
-      selectedElementIds: { [frame.id]: true },
-    });
-
-    const referenceSnapPointKeys = getReferenceSnapPointKeys(
-      elements,
-      [frame],
-      app,
-    );
-    const frameChildPointKeys = getPointKeys(
-      getElementsCorners([frameChild], arrayToMap(elements)),
-    );
-
-    expect(
-      frameChildPointKeys.some((pointKey) =>
-        referenceSnapPointKeys.has(pointKey),
-      ),
-    ).toBe(false);
-  });
-
-  it("does not use frame children as visible gap references when snapping outside elements", () => {
-    const frame = API.createElement({
-      type: "frame",
-      id: "frame",
-      x: 0,
-      y: 0,
-      width: 500,
-      height: 300,
-    });
-    const frameChildA = API.createElement({
-      type: "rectangle",
-      id: "frameChildA",
-      x: 50,
-      y: 50,
-      width: 100,
-      height: 100,
-      frameId: frame.id,
-    });
-    const frameChildB = API.createElement({
-      type: "rectangle",
-      id: "frameChildB",
-      x: 250,
-      y: 50,
-      width: 100,
-      height: 100,
-      frameId: frame.id,
-    });
-    const selected = API.createElement({
-      type: "rectangle",
-      id: "selected",
-      x: 700,
-      y: 50,
-      width: 100,
-      height: 100,
-    });
-    const elements = [frame, frameChildA, frameChildB, selected];
-    const app = createSnappingApp({
-      selectedElementIds: { [selected.id]: true },
-    });
-
-    const visibleGaps = getVisibleGaps(
-      elements,
-      [selected],
-      app.state,
-      arrayToMap(elements),
-    );
-
-    expect(visibleGaps.horizontalGaps).toHaveLength(0);
-    expect(visibleGaps.verticalGaps).toHaveLength(0);
-  });
-
-  it("filters center and inner outer point snaplines for the same reference", () => {
-    const angle = 0.68 as Radians;
-    const reference = API.createElement({
-      type: "rectangle",
-      id: "reference",
-      x: 0,
-      y: 0,
-      width: 140,
-      height: 140,
-      angle,
-    });
-    const selected = API.createElement({
-      type: "rectangle",
-      id: "selected",
-      x: 200,
-      y: 0,
-      width: 140,
-      height: 140,
-      angle,
-    });
-    const elements = [reference, selected];
-    const app = createSnappingApp({
-      selectedElementIds: { [selected.id]: true },
-    });
-
-    primeReferenceSnapPoints(elements, [selected]);
-
-    const { snapLines } = snapDraggedElements(
-      elements,
-      { x: 0, y: 0 },
-      app,
-      NO_MODIFIER_KEYS,
-      arrayToMap(elements),
-    );
-
-    expect(getHorizontalPointSnapLineCoordinates(snapLines)).toHaveLength(2);
-  });
-
-  it("keeps a snapline that is redundant for one reference but needed for another", () => {
-    const angle = 0.68 as Radians;
-    const selected = API.createElement({
-      type: "rectangle",
-      id: "selected",
-      x: 200,
-      y: 0,
-      width: 140,
-      height: 140,
-      angle,
-    });
-    const elements = [selected];
-    const elementsMap = arrayToMap(elements);
-    const selectedSnapPoints = getElementsCorners([selected], elementsMap);
-    const outerSnapPoints = selectedSnapPoints.slice(0, -1);
-    const centerSnapPoint = selectedSnapPoints[selectedSnapPoints.length - 1];
-    const innerOuterSnapPoint = [...outerSnapPoints].sort(
-      (a, b) => a[1] - b[1],
-    )[1];
-    const app = createSnappingApp({
-      selectedElementIds: { [selected.id]: true },
-    });
-
-    const referenceSnapPoints: ReferenceSnapPoints = [
-      ...outerSnapPoints.map((point) => ({
-        point: pointFrom<GlobalPoint>(point[0] - 200, point[1]),
-        type: "outer" as const,
-        snapSourceId: "referenceA",
-      })),
-      {
-        point: pointFrom<GlobalPoint>(
-          centerSnapPoint[0] - 200,
-          centerSnapPoint[1],
-        ),
-        type: "center" as const,
-        snapSourceId: "referenceA",
-      },
-      {
-        point: pointFrom<GlobalPoint>(
-          innerOuterSnapPoint[0] - 300,
-          innerOuterSnapPoint[1],
-        ),
-        type: "outer" as const,
-        snapSourceId: "referenceB",
-      },
-    ];
-
-    SnapCache.setReferenceSnapPoints(referenceSnapPoints);
-
-    const { snapLines } = snapDraggedElements(
-      elements,
-      { x: 0, y: 0 },
-      app,
-      NO_MODIFIER_KEYS,
-      elementsMap,
-    );
-
-    expect(getHorizontalPointSnapLineCoordinates(snapLines)).toHaveLength(3);
-  });
-
-  it("keeps a center snapline when no outer snaplines imply it", () => {
-    const reference = API.createElement({
-      type: "rectangle",
-      id: "reference",
-      x: 0,
-      y: 0,
-      width: 100,
-      height: 100,
-    });
-    const selected = API.createElement({
-      type: "rectangle",
-      id: "selected",
-      x: 200,
-      y: 25,
-      width: 50,
-      height: 50,
-    });
-    const elements = [reference, selected];
-    const app = createSnappingApp({
-      selectedElementIds: { [selected.id]: true },
-    });
-
-    primeReferenceSnapPoints(elements, [selected]);
-
-    const { snapLines } = snapDraggedElements(
-      elements,
-      { x: 0, y: 0 },
-      app,
-      NO_MODIFIER_KEYS,
-      arrayToMap(elements),
-    );
-
-    expect(getHorizontalPointSnapLineCoordinates(snapLines)).toEqual([50]);
-  });
-
-  it("filters center snaplines when matching outer offsets differ by rounding precision", () => {
-    const selected = API.createElement({
-      type: "rectangle",
-      id: "selected",
-      x: 2532.227563984471,
-      y: -1553.9657067952232,
-      width: 140.1015625,
-      height: 140.1015625,
-    });
-    const reference = API.createElement({
-      type: "rectangle",
-      id: "reference",
-      x: 2532.2275640966914,
-      y: -1299.4323092037737,
-      width: 140.1015625,
-      height: 140.1015625,
-    });
-    const elements = [reference, selected];
-    const app = createSnappingApp({
-      selectedElementIds: { [selected.id]: true },
-    });
-
-    primeReferenceSnapPoints(elements, [selected]);
-
-    const { snapLines } = snapDraggedElements(
-      elements,
-      { x: 0, y: 0 },
-      app,
-      NO_MODIFIER_KEYS,
-      arrayToMap(elements),
-    );
-
-    expect(getVerticalPointSnapLineCoordinates(snapLines)).toEqual([
-      2532.227564, 2672.329126,
-    ]);
-  });
-
-  it("keeps outer snaplines stable while dragging a snapped element through rounding-equivalent offsets", () => {
-    const referenceMiddle = API.createElement({
-      type: "rectangle",
-      id: "referenceMiddle",
-      x: 2532.22756398447,
-      y: -1553.9657067952237,
-      width: 140.1015625,
-      height: 140.1015625,
-    });
-    const referenceAbove = API.createElement({
-      type: "rectangle",
-      id: "referenceAbove",
-      x: 2532.2275637826165,
-      y: -1779.7363232531268,
-      width: 140.1015625,
-      height: 140.1015625,
-    });
-    const selected = API.createElement({
-      type: "rectangle",
-      id: "selected",
-      x: 2532.227563096691,
-      y: -1328.1950902037736,
-      width: 140.1015625,
-      height: 140.1015625,
-    });
-    const elements = [referenceAbove, referenceMiddle, selected];
-    const app = createSnappingApp({
-      selectedElementIds: { [selected.id]: true },
-    });
-
-    primeReferenceSnapPoints(elements, [selected]);
-
-    for (const dragOffsetX of [-4, -1, -0.1, 0, 0.1, 1, 4]) {
-      const { snapLines } = snapDraggedElements(
-        elements,
-        { x: dragOffsetX, y: 0 },
-        app,
-        NO_MODIFIER_KEYS,
-        arrayToMap(elements),
-      );
-      const coordinates = getVerticalPointSnapLineCoordinates(snapLines);
-
-      expect(coordinates).toHaveLength(2);
-      expect(coordinates[1] - coordinates[0]).toBeCloseTo(selected.width, 5);
-    }
-  });
-
-  it("keeps same-offset point snaps even across distant references", () => {
-    const selected = API.createElement({
-      type: "rectangle",
-      id: "selected",
-      x: 0,
-      y: 0,
-      width: 100,
-      height: 100,
-    });
-    const elements = [selected];
-    const app = createSnappingApp({
-      selectedElementIds: { [selected.id]: true },
-    });
-
-    SnapCache.setReferenceSnapPoints([
-      {
-        point: pointFrom<GlobalPoint>(220, 50),
-        type: "center",
-        snapSourceId: "near",
-      },
-      {
-        point: pointFrom<GlobalPoint>(900, 50),
-        type: "center",
-        snapSourceId: "far",
-      },
-    ]);
-
-    const { snapLines } = snapDraggedElements(
-      elements,
-      { x: 0, y: 0 },
-      app,
-      NO_MODIFIER_KEYS,
-      arrayToMap(elements),
-    );
-
-    expect(getHorizontalPointSnapLineMaxX(snapLines)).toBe(900);
-  });
-
-  it("prefers a nearby point snap over a slightly better far offset", () => {
-    const selected = API.createElement({
-      type: "rectangle",
-      id: "selected",
-      x: 0,
-      y: 0,
-      width: 100,
-      height: 100,
-    });
-    const elements = [selected];
-    const app = createSnappingApp({
-      selectedElementIds: { [selected.id]: true },
-    });
-
-    SnapCache.setReferenceSnapPoints([
-      {
-        point: pointFrom<GlobalPoint>(220, 54),
-        type: "center",
-        snapSourceId: "near",
-      },
-      {
-        point: pointFrom<GlobalPoint>(900, 50),
-        type: "center",
-        snapSourceId: "far",
-      },
-    ]);
-
-    const { snapOffset, snapLines } = snapDraggedElements(
-      elements,
-      { x: 0, y: 0 },
-      app,
-      NO_MODIFIER_KEYS,
-      arrayToMap(elements),
-    );
-
-    expect(snapOffset.y).toBe(4);
-    expect(getHorizontalPointSnapLineMaxX(snapLines)).toBe(220);
-  });
-
-  it("keeps same-offset point snaps when references form a continuous cluster", () => {
-    const selected = API.createElement({
-      type: "rectangle",
-      id: "selected",
-      x: 0,
-      y: 0,
-      width: 100,
-      height: 100,
-    });
-    const elements = [selected];
-    const app = createSnappingApp({
-      selectedElementIds: { [selected.id]: true },
-    });
-
-    SnapCache.setReferenceSnapPoints([
-      {
-        point: pointFrom<GlobalPoint>(200, 50),
-        type: "center",
-        snapSourceId: "referenceA",
-      },
-      {
-        point: pointFrom<GlobalPoint>(350, 50),
-        type: "center",
-        snapSourceId: "referenceB",
-      },
-      {
-        point: pointFrom<GlobalPoint>(500, 50),
-        type: "center",
-        snapSourceId: "referenceC",
-      },
-    ]);
-
-    const { snapLines } = snapDraggedElements(
-      elements,
-      { x: 0, y: 0 },
-      app,
-      NO_MODIFIER_KEYS,
-      arrayToMap(elements),
-    );
-
-    expect(getHorizontalPointSnapLineMaxX(snapLines)).toBe(500);
-  });
-
-  it("keeps same-source same-offset point snaps across zoom-scaled cluster breaks", () => {
-    const reference = API.createElement({
-      type: "rectangle",
-      id: "reference",
-      x: 0,
-      y: 0,
-      width: 140.1015625,
-      height: 140.1015625,
-    });
-    const selected = API.createElement({
-      type: "rectangle",
-      id: "selected",
-      x: 338.608871112217,
-      y: 0,
-      width: 140.1015625,
-      height: 140.1015625,
-    });
-    const elements = [reference, selected];
-    const app = createSnappingApp({
-      selectedElementIds: { [selected.id]: true },
-      zoom: { value: 1.5 as NormalizedZoomValue },
-    });
-
-    primeReferenceSnapPoints(elements, [selected]);
-
-    const { snapLines } = snapDraggedElements(
-      elements,
-      { x: 0, y: 0 },
-      app,
-      NO_MODIFIER_KEYS,
-      arrayToMap(elements),
-    );
-
-    const range = getHorizontalPointSnapLineXRange(snapLines);
-
-    expect(range).not.toBe(null);
-    expect(range![0]).toBeCloseTo(reference.x, 6);
-    expect(range![1]).toBeCloseTo(selected.x + selected.width, 6);
-  });
-
-  it("renders gap snaplines when rounded bounds touch the reference gap overlap", () => {
-    const selected = API.createElement({
-      type: "rectangle",
-      id: "selected",
-      x: 0,
-      y: 0.0000004,
-      width: 100,
-      height: 100,
-    });
-    const elements = [selected];
-    const app = createSnappingApp({
-      selectedElementIds: { [selected.id]: true },
-    });
-
-    SnapCache.setVisibleGaps({
-      horizontalGaps: [
-        {
-          startBounds: [200, -100, 300, 0],
-          endBounds: [400, -100, 500, 0],
-          startSide: [pointFrom(300, -100), pointFrom(300, 0)],
-          endSide: [pointFrom(400, -100), pointFrom(400, 0)],
-          overlap: rangeInclusive(-100, 0),
-          length: 100,
-        },
-      ],
-      verticalGaps: [],
-    });
-
-    const { snapLines } = snapDraggedElements(
-      elements,
-      { x: 0, y: 0 },
-      app,
-      NO_MODIFIER_KEYS,
-      arrayToMap(elements),
-    );
-
-    expect(getHorizontalGapSnapLines(snapLines)).toHaveLength(2);
-  });
-
-  it("renders gap snaplines when the winning gap offset only differs by rounding precision", () => {
-    const selected = API.createElement({
-      type: "rectangle",
-      id: "selected",
-      x: 0,
-      y: 399.999999,
-      width: 100,
-      height: 100,
-    });
-    const elements = [selected];
-    const app = createSnappingApp({
-      selectedElementIds: { [selected.id]: true },
-    });
-
-    SnapCache.setReferenceSnapPoints([
-      {
-        point: pointFrom<GlobalPoint>(0, 399.999999),
-        type: "outer",
-        snapSourceId: "reference",
-      },
-    ]);
-    SnapCache.setVisibleGaps({
-      horizontalGaps: [],
-      verticalGaps: [
-        {
-          startBounds: [0, 100, 100, 200],
-          endBounds: [0, 250, 100, 350],
-          startSide: [pointFrom(0, 200), pointFrom(100, 200)],
-          endSide: [pointFrom(0, 250), pointFrom(100, 250)],
-          overlap: rangeInclusive(0, 100),
-          length: 50,
-        },
-      ],
-    });
-
-    const { snapLines } = snapDraggedElements(
-      elements,
-      { x: 0, y: 0 },
-      app,
-      NO_MODIFIER_KEYS,
-      arrayToMap(elements),
-    );
-
-    expect(getVerticalGapSnapLines(snapLines)).toHaveLength(2);
-  });
-});

packages/excalidraw/tests/test-utils.ts

@@ -449,29 +449,28 @@ const stripProps = (
   }, {} as Record<string, any>);
 
 export const checkpointHistory = (history: History, name: string) => {
-  expect(
-    history.undoStack.map((x) => ({
-      ...x,
-      elements: {
-        ...x.elements,
-        added: stripProps(x.elements.added, ["seed", "versionNonce"]),
-        removed: stripProps(x.elements.removed, ["seed", "versionNonce"]),
-        updated: stripProps(x.elements.updated, ["seed", "versionNonce"]),
-      },
-    })),
-  ).toMatchSnapshot(`[${name}] undo stack`);
+  const normalizeHistoryEntry = (entry: History["undoStack"][number]) => {
+    const { markers, ...rest } = entry;
 
-  expect(
-    history.redoStack.map((x) => ({
-      ...x,
+    return {
+      ...rest,
+      ...(markers ? { markers } : {}),
       elements: {
-        ...x.elements,
-        added: stripProps(x.elements.added, ["seed", "versionNonce"]),
-        removed: stripProps(x.elements.removed, ["seed", "versionNonce"]),
-        updated: stripProps(x.elements.updated, ["seed", "versionNonce"]),
+        ...entry.elements,
+        added: stripProps(entry.elements.added, ["seed", "versionNonce"]),
+        removed: stripProps(entry.elements.removed, ["seed", "versionNonce"]),
+        updated: stripProps(entry.elements.updated, ["seed", "versionNonce"]),
       },
-    })),
-  ).toMatchSnapshot(`[${name}] redo stack`);
+    };
+  };
+
+  expect(history.undoStack.map(normalizeHistoryEntry)).toMatchSnapshot(
+    `[${name}] undo stack`,
+  );
+
+  expect(history.redoStack.map(normalizeHistoryEntry)).toMatchSnapshot(
+    `[${name}] redo stack`,
+  );
 };
 
 /**

packages/excalidraw/transaction/diff.ts

@@ -0,0 +1,289 @@
+import { type StoreDelta } from "@excalidraw/element";
+
+import type { Delta } from "@excalidraw/element";
+
+import type { Mutable } from "@excalidraw/common/utility-types";
+import type {
+  ExcalidrawElement,
+  OrderedExcalidrawElement,
+  SceneElementsMap,
+} from "@excalidraw/element/types";
+
+import type {
+  ElementChange,
+  ElementPropName,
+  TouchedElementProps,
+} from "./types";
+
+const LEDGER_IGNORED_PROPS = new Set([
+  "version",
+  "versionNonce",
+  "seed",
+  "updated",
+  "index",
+]);
+
+export const TX_UNDO_OVERRIDE_IGNORED_PROPS = new Set([
+  "version",
+  "versionNonce",
+  "isDeleted",
+]);
+
+type ElementRecord = Record<string, unknown>;
+export type ElementUpdatedProps = Omit<
+  Partial<OrderedExcalidrawElement>,
+  "id" | "updated" | "seed"
+>;
+export type ElementUpdatedPropName = Extract<keyof ElementUpdatedProps, string>;
+type ElementPropValueMap = ElementUpdatedProps;
+
+export type ElementUpdatedEntry = Delta<ElementPropValueMap>;
+export type ElementUpdatedEntryMap = Record<string, ElementUpdatedEntry>;
+
+const isPlainObject = (value: unknown): value is Record<string, unknown> =>
+  !!value && typeof value === "object" && !Array.isArray(value);
+
+export const getElementProp = <TProp extends ElementPropName>(
+  element: ExcalidrawElement,
+  prop: TProp,
+): ExcalidrawElement[TProp] =>
+  (element as ElementRecord)[prop] as ExcalidrawElement[TProp];
+
+export const setOrderedElementProp = <TProp extends ElementPropName>(
+  element: Mutable<OrderedExcalidrawElement>,
+  prop: TProp,
+  value: OrderedExcalidrawElement[TProp],
+) => {
+  (element as ElementRecord)[prop] = value;
+};
+
+/** Deep equality used by ledger conflict/touched-prop detection. */
+export const isLedgerValueEqual = (left: unknown, right: unknown): boolean => {
+  if (Object.is(left, right)) {
+    return true;
+  }
+
+  if (Array.isArray(left) && Array.isArray(right)) {
+    if (left.length !== right.length) {
+      return false;
+    }
+    for (let index = 0; index < left.length; index += 1) {
+      if (!isLedgerValueEqual(left[index], right[index])) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  if (isPlainObject(left) && isPlainObject(right)) {
+    const leftKeys = Object.keys(left);
+    const rightKeys = Object.keys(right);
+    if (leftKeys.length !== rightKeys.length) {
+      return false;
+    }
+    for (const key of leftKeys) {
+      if (!Object.prototype.hasOwnProperty.call(right, key)) {
+        return false;
+      }
+      if (!isLedgerValueEqual(left[key], right[key])) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  return false;
+};
+
+/** Shallow-copies a scene map. Entries share references with the original. */
+export const shallowCopySceneElements = (
+  elements: ReadonlyMap<string, ExcalidrawElement>,
+): SceneElementsMap => new Map(elements) as SceneElementsMap;
+
+export const createAllTouchedElementProps = (): TouchedElementProps => ({
+  kind: "all",
+});
+
+export const createPartialTouchedElementProps = (
+  props: Iterable<ElementPropName> = [],
+): TouchedElementProps => ({
+  kind: "partial",
+  props: new Set(props),
+});
+
+export const hasTouchedProps = (touchedProps: TouchedElementProps): boolean =>
+  touchedProps.kind === "all" || touchedProps.props.size > 0;
+
+export const touchesWholeElement = (
+  touchedProps: TouchedElementProps,
+): boolean => touchedProps.kind === "all";
+
+export const isPartialTouchedProps = (
+  touchedProps: TouchedElementProps,
+): touchedProps is Extract<TouchedElementProps, { kind: "partial" }> =>
+  touchedProps.kind === "partial";
+
+export const hasTouchedProp = (
+  touchedProps: TouchedElementProps,
+  prop: ElementPropName,
+): boolean => touchedProps.kind === "all" || touchedProps.props.has(prop);
+
+export const mergeTouchedProps = (
+  left: TouchedElementProps,
+  right: TouchedElementProps,
+): TouchedElementProps => {
+  if (left.kind === "all" || right.kind === "all") {
+    return createAllTouchedElementProps();
+  }
+
+  return createPartialTouchedElementProps([...left.props, ...right.props]);
+};
+
+/** Returns changed property names between two element snapshots. */
+export const collectTouchedProps = (
+  before: ExcalidrawElement | null,
+  after: ExcalidrawElement | null,
+): TouchedElementProps => {
+  if (!before || !after) {
+    return createAllTouchedElementProps();
+  }
+
+  const touchedProps = new Set<ElementPropName>();
+  const keys = new Set<ElementPropName>([
+    ...(Object.keys(before) as ElementPropName[]),
+    ...(Object.keys(after) as ElementPropName[]),
+  ]);
+
+  for (const key of keys) {
+    if (LEDGER_IGNORED_PROPS.has(key)) {
+      continue;
+    }
+    if (
+      !isLedgerValueEqual(
+        getElementProp(before, key),
+        getElementProp(after, key),
+      )
+    ) {
+      touchedProps.add(key);
+    }
+  }
+
+  return createPartialTouchedElementProps(touchedProps);
+};
+
+/** Returns ids whose element snapshot changed between two points in time. */
+export const collectChangedElementIds = (
+  before: ReadonlyMap<string, ExcalidrawElement>,
+  after: ReadonlyMap<string, ExcalidrawElement>,
+) => collectElementChanges(before, after).map((change) => change.id);
+
+export const collectElementChanges = (
+  before: ReadonlyMap<string, ExcalidrawElement>,
+  after: ReadonlyMap<string, ExcalidrawElement>,
+): ElementChange[] => {
+  const changes: ElementChange[] = [];
+  const candidateIds = new Set<string>([...before.keys(), ...after.keys()]);
+
+  for (const id of candidateIds) {
+    const beforeElement = before.get(id) ?? null;
+    const afterElement = after.get(id) ?? null;
+    const touchedProps = collectTouchedProps(beforeElement, afterElement);
+    if (!hasTouchedProps(touchedProps)) {
+      continue;
+    }
+
+    changes.push({
+      id,
+      before: beforeElement,
+      after: afterElement,
+      touchedProps,
+    });
+  }
+
+  return changes;
+};
+
+export const serializeConsumedPropKey = (
+  elementId: string,
+  prop: ElementPropName,
+) => `${elementId}\u0000${prop}`;
+
+export const getUpdatedElementEntries = (delta: StoreDelta) =>
+  delta.elements.updated as ElementUpdatedEntryMap;
+
+export const getElementPropEntries = (props: ElementPropValueMap) =>
+  Object.entries(props) as [
+    ElementUpdatedPropName,
+    ElementUpdatedProps[ElementUpdatedPropName],
+  ][];
+
+export const hasUpdatedElementEntries = (delta: StoreDelta) =>
+  Object.keys(getUpdatedElementEntries(delta)).length > 0;
+
+export const serializeIntermediateValue = (value: unknown): string => {
+  const serialize = (input: unknown, seen: WeakSet<object>): string => {
+    if (input === null) {
+      return "null";
+    }
+
+    switch (typeof input) {
+      case "undefined":
+        return "undefined";
+      case "boolean":
+        return input ? "boolean:true" : "boolean:false";
+      case "number":
+        if (Number.isNaN(input)) {
+          return "number:NaN";
+        }
+        if (Object.is(input, -0)) {
+          return "number:-0";
+        }
+        return `number:${input}`;
+      case "bigint":
+        return `bigint:${input.toString()}`;
+      case "string":
+        return `string:${JSON.stringify(input)}`;
+      case "symbol":
+        return `symbol:${String(input)}`;
+      case "function":
+        return `function:${input.name}`;
+      case "object":
+        break;
+      default:
+        return `unknown:${String(input)}`;
+    }
+
+    if (Array.isArray(input)) {
+      if (seen.has(input)) {
+        return "[CircularArray]";
+      }
+      seen.add(input);
+      const serialized = `[${input
+        .map((item) => serialize(item, seen))
+        .join(",")}]`;
+      seen.delete(input);
+      return serialized;
+    }
+
+    if (isPlainObject(input)) {
+      if (seen.has(input)) {
+        return "{CircularObject}";
+      }
+      seen.add(input);
+      const serialized = `{${Object.keys(input)
+        .sort()
+        .map((key) => `${JSON.stringify(key)}:${serialize(input[key], seen)}`)
+        .join(",")}}`;
+      seen.delete(input);
+      return serialized;
+    }
+
+    try {
+      return `object:${JSON.stringify(input)}`;
+    } catch {
+      return `object:${Object.prototype.toString.call(input)}`;
+    }
+  };
+
+  return serialize(value, new WeakSet<object>());
+};

packages/excalidraw/transaction/index.ts

@@ -0,0 +1,13 @@
+export { collectChangedElementIds } from "./diff";
+export { TransactionLedger } from "./ledger";
+export { Transaction } from "./transaction";
+export { TransactionManager } from "./manager";
+
+export type {
+  AppStateResolver,
+  AppStateResolverContext,
+  TransactionElementUpdate,
+  TransactionLedgerEntry,
+  TransactionStatus,
+  TransactionSummary,
+} from "./types";

packages/excalidraw/transaction/ledger.ts

@@ -0,0 +1,333 @@
+import { deepCopyElement } from "@excalidraw/element";
+
+import type { Mutable } from "@excalidraw/common/utility-types";
+import type {
+  ExcalidrawElement,
+  OrderedExcalidrawElement,
+  SceneElementsMap,
+} from "@excalidraw/element/types";
+
+import {
+  collectElementChanges,
+  collectTouchedProps,
+  getElementProp,
+  hasTouchedProps,
+  isLedgerValueEqual,
+  mergeTouchedProps,
+  setOrderedElementProp,
+  shallowCopySceneElements,
+  touchesWholeElement,
+} from "./diff";
+
+import type { TransactionLedgerEntry } from "./types";
+
+/**
+ * Keeps transaction-level scene mutations and materializes synthetic snapshots
+ * for a single durable history commit.
+ */
+export class TransactionLedger {
+  private readonly entries = new Map<string, TransactionLedgerEntry>();
+
+  /** Whether the transaction has any net element mutations. */
+  hasEntries() {
+    return this.entries.size > 0;
+  }
+
+  /** Returns the ledger entry for an element, if any. */
+  getEntry(elementId: string): TransactionLedgerEntry | undefined {
+    return this.entries.get(elementId);
+  }
+
+  /** Releases all ledger entries. */
+  clear() {
+    this.entries.clear();
+  }
+
+  /** Records one element mutation step into the ledger. */
+  recordStep(
+    before: ReadonlyMap<string, ExcalidrawElement>,
+    after: ReadonlyMap<string, ExcalidrawElement>,
+  ) {
+    for (const change of collectElementChanges(before, after)) {
+      const {
+        id: elementId,
+        before: beforeElement,
+        after: afterElement,
+        touchedProps,
+      } = change;
+
+      const existing = this.entries.get(elementId);
+      if (!existing) {
+        this.entries.set(elementId, {
+          baselineElement: beforeElement
+            ? deepCopyElement(beforeElement)
+            : null,
+          targetElement: afterElement ? deepCopyElement(afterElement) : null,
+          touchedProps,
+        });
+        continue;
+      }
+
+      existing.targetElement = afterElement
+        ? deepCopyElement(afterElement)
+        : null;
+      existing.touchedProps = mergeTouchedProps(
+        existing.touchedProps,
+        touchedProps,
+      );
+
+      // Created then deleted inside one transaction leaves no durable footprint.
+      if (!existing.baselineElement && !existing.targetElement) {
+        this.entries.delete(elementId);
+        continue;
+      }
+      if (!existing.baselineElement && existing.targetElement?.isDeleted) {
+        this.entries.delete(elementId);
+      }
+    }
+  }
+
+  /**
+   * Builds synthetic element before/after snapshots with a fixed
+   * "live-wins-per-prop" strategy.
+   */
+  buildSyntheticSnapshots(live: ReadonlyMap<string, ExcalidrawElement>) {
+    // Shallow copy — untouched elements stay as live references.
+    // Only elements mutated in-place (prop-level updates) are deep-copied below.
+    const elementsBefore = shallowCopySceneElements(live);
+    const elementsAfter = shallowCopySceneElements(live);
+
+    for (const [elementId, entry] of this.entries) {
+      this.reconcileEntrySnapshots(
+        elementId,
+        entry,
+        live,
+        elementsBefore,
+        elementsAfter,
+      );
+    }
+
+    return { elementsBefore, elementsAfter };
+  }
+
+  private reconcileEntrySnapshots(
+    elementId: string,
+    entry: TransactionLedgerEntry,
+    live: ReadonlyMap<string, ExcalidrawElement>,
+    elementsBefore: SceneElementsMap,
+    elementsAfter: SceneElementsMap,
+  ) {
+    if (!entry.baselineElement) {
+      this.applyCreatedElementSnapshots(
+        elementId,
+        entry.targetElement,
+        live,
+        elementsBefore,
+        elementsAfter,
+      );
+      return;
+    }
+
+    if (!entry.targetElement) {
+      this.applyDeletedElementSnapshots(
+        elementId,
+        entry.baselineElement,
+        live,
+        elementsBefore,
+        elementsAfter,
+      );
+      return;
+    }
+
+    this.applyUpdatedElementSnapshots(
+      elementId,
+      entry,
+      live,
+      elementsBefore,
+      elementsAfter,
+    );
+  }
+
+  private applyCreatedElementSnapshots(
+    elementId: string,
+    targetElement: ExcalidrawElement | null,
+    live: ReadonlyMap<string, ExcalidrawElement>,
+    elementsBefore: SceneElementsMap,
+    elementsAfter: SceneElementsMap,
+  ) {
+    if (!targetElement) {
+      return;
+    }
+
+    const liveElement = live.get(elementId) ?? null;
+    if (
+      !liveElement ||
+      liveElement.isDeleted ||
+      hasTouchedProps(collectTouchedProps(targetElement, liveElement))
+    ) {
+      return;
+    }
+
+    elementsBefore.delete(elementId);
+    elementsAfter.set(
+      elementId,
+      deepCopyElement(targetElement) as OrderedExcalidrawElement,
+    );
+  }
+
+  private applyDeletedElementSnapshots(
+    elementId: string,
+    baselineElement: ExcalidrawElement,
+    live: ReadonlyMap<string, ExcalidrawElement>,
+    elementsBefore: SceneElementsMap,
+    elementsAfter: SceneElementsMap,
+  ) {
+    const liveElement = live.get(elementId) ?? null;
+    if (liveElement && !liveElement.isDeleted) {
+      return;
+    }
+
+    elementsBefore.set(
+      elementId,
+      deepCopyElement(baselineElement) as OrderedExcalidrawElement,
+    );
+    elementsAfter.delete(elementId);
+  }
+
+  private applyUpdatedElementSnapshots(
+    elementId: string,
+    entry: TransactionLedgerEntry,
+    live: ReadonlyMap<string, ExcalidrawElement>,
+    elementsBefore: SceneElementsMap,
+    elementsAfter: SceneElementsMap,
+  ) {
+    const liveElement = live.get(elementId) ?? null;
+    const targetElement = entry.targetElement;
+    const baselineElement = entry.baselineElement;
+    const beforeElement = elementsBefore.get(elementId);
+    const afterElement = elementsAfter.get(elementId);
+
+    if (
+      !liveElement ||
+      !baselineElement ||
+      !targetElement ||
+      !beforeElement ||
+      !afterElement
+    ) {
+      return;
+    }
+
+    if (touchesWholeElement(entry.touchedProps)) {
+      this.applyWholeElementSnapshots(
+        elementId,
+        baselineElement,
+        targetElement,
+        liveElement,
+        elementsBefore,
+        elementsAfter,
+      );
+      return;
+    }
+
+    this.applyPerPropSnapshots({
+      entry,
+      liveElement,
+      baselineElement,
+      targetElement,
+      beforeElement,
+      afterElement,
+      elementId,
+      elementsBefore,
+      elementsAfter,
+    });
+  }
+
+  private applyWholeElementSnapshots(
+    elementId: string,
+    baselineElement: ExcalidrawElement,
+    targetElement: ExcalidrawElement,
+    liveElement: ExcalidrawElement,
+    elementsBefore: SceneElementsMap,
+    elementsAfter: SceneElementsMap,
+  ) {
+    const hasLiveConflict = hasTouchedProps(
+      collectTouchedProps(targetElement, liveElement),
+    );
+    if (hasLiveConflict) {
+      return;
+    }
+
+    elementsBefore.set(
+      elementId,
+      deepCopyElement(baselineElement) as OrderedExcalidrawElement,
+    );
+    elementsAfter.set(
+      elementId,
+      deepCopyElement(targetElement) as OrderedExcalidrawElement,
+    );
+  }
+
+  private applyPerPropSnapshots(args: {
+    entry: TransactionLedgerEntry;
+    liveElement: ExcalidrawElement;
+    baselineElement: ExcalidrawElement;
+    targetElement: ExcalidrawElement;
+    beforeElement: ExcalidrawElement;
+    afterElement: ExcalidrawElement;
+    elementId: string;
+    elementsBefore: SceneElementsMap;
+    elementsAfter: SceneElementsMap;
+  }) {
+    const {
+      entry,
+      liveElement,
+      baselineElement,
+      targetElement,
+      beforeElement,
+      afterElement,
+      elementId,
+      elementsBefore,
+      elementsAfter,
+    } = args;
+
+    // Deep-copy before mutating so we never touch live elements.
+    const mutableBefore = deepCopyElement(
+      beforeElement,
+    ) as Mutable<OrderedExcalidrawElement>;
+    const mutableAfter = deepCopyElement(
+      afterElement,
+    ) as Mutable<OrderedExcalidrawElement>;
+    elementsBefore.set(elementId, mutableBefore as OrderedExcalidrawElement);
+    elementsAfter.set(elementId, mutableAfter as OrderedExcalidrawElement);
+
+    if (entry.touchedProps.kind !== "partial") {
+      return;
+    }
+
+    let appliedProps = 0;
+    for (const prop of entry.touchedProps.props) {
+      const liveValue = getElementProp(liveElement, prop);
+      const targetValue = getElementProp(targetElement, prop);
+      if (!isLedgerValueEqual(liveValue, targetValue)) {
+        continue;
+      }
+
+      setOrderedElementProp(
+        mutableBefore,
+        prop,
+        getElementProp(baselineElement, prop),
+      );
+      setOrderedElementProp(mutableAfter, prop, targetValue);
+      appliedProps += 1;
+    }
+
+    if (appliedProps === 0) {
+      return;
+    }
+
+    mutableBefore.version = baselineElement.version;
+    mutableBefore.versionNonce = baselineElement.versionNonce;
+    mutableAfter.version = targetElement.version;
+    mutableAfter.versionNonce = targetElement.versionNonce;
+  }
+}

packages/excalidraw/transaction/manager.ts

@@ -0,0 +1,291 @@
+import {
+  Delta,
+  ElementsDelta,
+  mergeStoreDeltaMarkers,
+  type StoreDelta,
+  type TxUndoOverride,
+} from "@excalidraw/element";
+
+import type { Mutable } from "@excalidraw/common/utility-types";
+
+import {
+  HistoryDelta,
+  type HistoryBeforeRecordListener,
+  type HistoryEffectiveDeltaResolverContext,
+} from "../history";
+
+import {
+  type ElementUpdatedPropName,
+  getUpdatedElementEntries,
+  hasUpdatedElementEntries,
+  isLedgerValueEqual,
+  type ElementUpdatedProps,
+  type ElementUpdatedEntryMap,
+} from "./diff";
+import { Transaction } from "./transaction";
+
+import type { AppClassProperties } from "../types";
+import type { TransactionStatus } from "./types";
+
+type TransactionRecord = {
+  tx: Transaction | null;
+  phase: TransactionStatus;
+};
+type TransactionHistoryBridge = {
+  onBeforeRecord: (callback: HistoryBeforeRecordListener) => () => void;
+  setEffectiveDeltaResolver: (
+    resolver:
+      | ((
+          delta: HistoryDelta,
+          context: HistoryEffectiveDeltaResolverContext,
+        ) => HistoryDelta)
+      | null,
+  ) => void;
+};
+
+type MutableElementUpdatedProps = Mutable<ElementUpdatedProps>;
+
+const setElementUpdatedOverride = (
+  overrides: MutableElementUpdatedProps,
+  prop: ElementUpdatedPropName,
+  value: unknown,
+) => {
+  (overrides as Record<ElementUpdatedPropName, unknown>)[prop] = value;
+};
+
+/**
+ * Thin factory that holds the app reference and creates Transaction instances.
+ */
+export class TransactionManager {
+  private readonly app: AppClassProperties;
+  /**
+   * Single authoritative lifecycle registry for transactions.
+   *
+   * We retain ended/canceled metadata after the tx object is released because
+   * history markers only persist `txId`; undo/redo still needs to resolve
+   * whether a tx was active or already ended when applying effective deltas.
+   */
+  private readonly transactionRecords = new Map<string, TransactionRecord>();
+  /**
+   * Active transaction ids ordered by most-recent registration first.
+   * This preserves deterministic priority when multiple active txs overlap on
+   * the same element+prop and compete to reserve override markers.
+   */
+  private readonly activeTransactionIdsByPriority: string[] = [];
+  private detachBeforeRecordHook: (() => void) | null = null;
+
+  constructor(app: AppClassProperties) {
+    this.app = app;
+  }
+
+  /**
+   * Binds transaction bookkeeping to history lifecycle hooks.
+   * Call once during app initialization.
+   */
+  attachHistory(history: TransactionHistoryBridge) {
+    this.detachBeforeRecordHook?.();
+    history.setEffectiveDeltaResolver((delta, context) =>
+      this.resolveEffectiveDelta(delta, context),
+    );
+    this.detachBeforeRecordHook = history.onBeforeRecord((delta) =>
+      this.onDurableIncrement(delta),
+    );
+  }
+
+  private removeActiveTransactionId(txId: string) {
+    const txIndex = this.activeTransactionIdsByPriority.indexOf(txId);
+    if (txIndex >= 0) {
+      this.activeTransactionIdsByPriority.splice(txIndex, 1);
+    }
+  }
+
+  private getRequiredTransactionRecord(txId: string): TransactionRecord {
+    const record = this.transactionRecords.get(txId);
+    if (!record) {
+      throw new Error(`Unknown transaction: ${txId}`);
+    }
+
+    return record;
+  }
+
+  registerTransaction(tx: Transaction) {
+    this.transactionRecords.set(tx.id, {
+      tx,
+      phase: "active",
+    });
+    this.activeTransactionIdsByPriority.unshift(tx.id);
+  }
+
+  detachTransactionInstance(txId: string) {
+    const record = this.getRequiredTransactionRecord(txId);
+    record.tx = null;
+    this.removeActiveTransactionId(txId);
+  }
+
+  getStatus(txId: string): TransactionStatus {
+    return this.getRequiredTransactionRecord(txId).phase;
+  }
+
+  private markTransactionFinished(
+    txId: string,
+    phase: Exclude<TransactionStatus, "active">,
+  ): TransactionStatus {
+    const record = this.getRequiredTransactionRecord(txId);
+    if (record.phase !== "active") {
+      return record.phase;
+    }
+
+    record.phase = phase;
+    this.removeActiveTransactionId(txId);
+    return record.phase;
+  }
+
+  markTransactionCommitted(txId: string): TransactionStatus {
+    return this.markTransactionFinished(txId, "committed");
+  }
+
+  markTransactionCanceled(txId: string): TransactionStatus {
+    return this.markTransactionFinished(txId, "canceled");
+  }
+
+  onDurableIncrement(delta: StoreDelta) {
+    if (this.activeTransactionIdsByPriority.length === 0) {
+      return;
+    }
+    if (!hasUpdatedElementEntries(delta)) {
+      return;
+    }
+
+    const txUndoOverrides = this.collectUndoOverrides(delta);
+    if (txUndoOverrides.length === 0) {
+      return;
+    }
+
+    mergeStoreDeltaMarkers(delta, { txUndoOverrides });
+  }
+
+  private collectUndoOverrides(delta: StoreDelta): TxUndoOverride[] {
+    const overrides: TxUndoOverride[] = [];
+    const reservedConsumedKeys = new Set<string>();
+
+    for (const txId of this.activeTransactionIdsByPriority) {
+      const record = this.transactionRecords.get(txId);
+      if (!record || record.phase !== "active" || !record.tx) {
+        continue;
+      }
+
+      const txOverrides = record.tx.collectUndoOverridesForDelta(
+        delta,
+        reservedConsumedKeys,
+      );
+
+      for (const override of txOverrides) {
+        if (reservedConsumedKeys.has(override.consumedKey)) {
+          continue;
+        }
+
+        reservedConsumedKeys.add(override.consumedKey);
+        overrides.push(override);
+      }
+    }
+
+    return overrides;
+  }
+
+  private resolveEffectiveDelta(
+    delta: HistoryDelta,
+    _context: HistoryEffectiveDeltaResolverContext,
+  ): HistoryDelta {
+    const txUndoOverrides = delta.markers?.txUndoOverrides;
+    if (!txUndoOverrides || txUndoOverrides.length === 0) {
+      return delta;
+    }
+
+    const updatedEntries = getUpdatedElementEntries(delta);
+    const insertedOverridesByElement = new Map<
+      string,
+      MutableElementUpdatedProps
+    >();
+
+    for (const override of txUndoOverrides) {
+      if (!this.shouldApplyUndoOverride(override.txId)) {
+        continue;
+      }
+
+      const currentEntry = updatedEntries[override.elementId];
+      if (!currentEntry) {
+        continue;
+      }
+
+      const prop = override.prop as ElementUpdatedPropName;
+      const currentInsertedValue = currentEntry.inserted[prop];
+      if (
+        !isLedgerValueEqual(
+          currentInsertedValue,
+          override.expectedInsertedValue,
+        )
+      ) {
+        // Guard against over-applying once the delta has already evolved.
+        continue;
+      }
+
+      const elementOverrides = insertedOverridesByElement.get(
+        override.elementId,
+      );
+      if (elementOverrides) {
+        setElementUpdatedOverride(
+          elementOverrides,
+          prop,
+          override.preTxBaselineValue,
+        );
+      } else {
+        const nextOverrides: MutableElementUpdatedProps = {};
+        setElementUpdatedOverride(
+          nextOverrides,
+          prop,
+          override.preTxBaselineValue,
+        );
+        insertedOverridesByElement.set(override.elementId, nextOverrides);
+      }
+    }
+
+    if (insertedOverridesByElement.size === 0) {
+      return delta;
+    }
+
+    const nextUpdatedEntries: ElementUpdatedEntryMap = {
+      ...updatedEntries,
+    };
+    for (const [elementId, insertedOverrides] of insertedOverridesByElement) {
+      const currentEntry = updatedEntries[elementId];
+      if (!currentEntry) {
+        continue;
+      }
+
+      nextUpdatedEntries[elementId] = Delta.create(
+        { ...currentEntry.deleted },
+        { ...currentEntry.inserted, ...insertedOverrides },
+      );
+    }
+
+    const effectiveElements = ElementsDelta.create(
+      delta.elements.added,
+      delta.elements.removed,
+      nextUpdatedEntries,
+    );
+
+    return HistoryDelta.create(effectiveElements, delta.appState, {
+      id: delta.id,
+      markers: delta.markers,
+    }) as HistoryDelta;
+  }
+
+  private shouldApplyUndoOverride(txId: string): boolean {
+    const record = this.transactionRecords.get(txId);
+    return !!record && record.phase !== "active";
+  }
+
+  create(): Transaction {
+    return new Transaction(this.app, this);
+  }
+}

packages/excalidraw/transaction/transaction.ts

@@ -0,0 +1,286 @@
+import { randomId } from "@excalidraw/common";
+import {
+  CaptureUpdateAction,
+  newElementWith,
+  type ElementUpdate,
+  type StoreDelta,
+  type TxUndoOverride,
+} from "@excalidraw/element";
+
+import { shallowCopySceneElements } from "./diff";
+import { TransactionLedger } from "./ledger";
+
+import {
+  type AppStateResolver,
+  type AppStateResolverContext,
+  type TransactionElementOfType,
+  type TransactionElementUpdate,
+  type TransactionStatus,
+  type TransactionSummary,
+} from "./types";
+import { TxUndoOverridePlanner } from "./undoOverridePlanner";
+
+import type { TransactionManager } from "./manager";
+import type {
+  AppClassProperties,
+  AppState,
+  ObservedAppState,
+  SceneData,
+} from "../types";
+
+type CommitOptions = {
+  resolveAppState?: AppStateResolver;
+};
+
+/**
+ * A transaction that records mutations via `updateScene(NEVER)` and commits
+ * a single synthetic durable history entry at the end.
+ */
+export class Transaction {
+  public readonly id = `tx-${randomId()}`;
+
+  private readonly app: AppClassProperties;
+  private readonly manager: TransactionManager;
+  private readonly ledger = new TransactionLedger();
+  private readonly undoOverridePlanner = new TxUndoOverridePlanner();
+  private readonly initialAppState: Partial<ObservedAppState>;
+
+  private accumulatedAppState: Record<string, unknown> = {};
+  private cachedSummary: TransactionSummary | null = null;
+
+  constructor(app: AppClassProperties, manager: TransactionManager) {
+    this.app = app;
+    this.manager = manager;
+    this.initialAppState = { ...app.store.snapshot.appState };
+    this.manager.registerTransaction(this);
+  }
+
+  get status(): TransactionStatus {
+    return this.manager.getStatus(this.id);
+  }
+
+  private assertActive(action: string): void {
+    const status = this.status;
+    if (status !== "active") {
+      throw new Error(
+        `Cannot ${action} — transaction ${this.id} is already ${status}.`,
+      );
+    }
+  }
+
+  private closeTransaction() {
+    this.manager.detachTransactionInstance(this.id);
+    this.undoOverridePlanner.clear();
+  }
+
+  public collectUndoOverridesForDelta(
+    delta: StoreDelta,
+    reservedConsumedKeys: Set<string>,
+  ): TxUndoOverride[] {
+    if (this.status !== "active") {
+      return [];
+    }
+
+    const candidates =
+      this.undoOverridePlanner.collectCandidatesForDurableDelta(
+        delta,
+        (elementId) => this.ledger.getEntry(elementId),
+        reservedConsumedKeys,
+      );
+
+    if (candidates.length === 0) {
+      return [];
+    }
+
+    const overrides: TxUndoOverride[] = [];
+    for (const candidate of candidates) {
+      this.undoOverridePlanner.markConsumed(candidate.consumedKey);
+      overrides.push({
+        txId: this.id,
+        ...candidate,
+      });
+    }
+
+    return overrides;
+  }
+
+  updateScene<K extends keyof AppState>(data: {
+    elements?: SceneData["elements"];
+    appState?: Pick<AppState, K> | null;
+  }): void {
+    this.assertActive("updateScene");
+
+    // Snapshot before (shallow copy — replaceAllElements mutates the map in-place)
+    const before = shallowCopySceneElements(
+      this.app.scene.getElementsMapIncludingDeleted(),
+    );
+
+    // Apply through the real updateScene with NEVER.
+    this.app.api.updateScene({
+      elements: data.elements,
+      appState: data.appState,
+      captureUpdate: CaptureUpdateAction.NEVER,
+    });
+
+    // Snapshot after
+    const after = this.app.scene.getElementsMapIncludingDeleted();
+
+    this.undoOverridePlanner.recordStep(before, after);
+
+    // Record element diff into ledger
+    this.ledger.recordStep(before, after);
+
+    // Accumulate appState intent
+    if (data.appState) {
+      this.accumulatedAppState = {
+        ...this.accumulatedAppState,
+        ...(data.appState as Record<string, unknown>),
+      };
+    }
+  }
+
+  /**
+   * Partial element updates convenience API.
+   *
+   * Example:
+   * tx.updateElements({
+   *   elements: [
+   *     { id: "a", type: "rectangle", updates: { strokeColor: "#f00" } },
+   *     { id: "b", type: "rectangle", updates: { x: 10, y: 20 } },
+   *   ],
+   * })
+   */
+  updateElements<K extends keyof AppState>(data: {
+    elements: readonly TransactionElementUpdate[];
+    appState?: Pick<AppState, K> | null;
+  }): void {
+    const updatesById = new Map<string, TransactionElementUpdate>();
+
+    for (const update of data.elements) {
+      updatesById.set(update.id, update);
+    }
+
+    if (updatesById.size === 0) {
+      this.updateScene({ appState: data.appState });
+      return;
+    }
+
+    const nextElements = this.app.scene
+      .getElementsIncludingDeleted()
+      .map((element) => {
+        const update = updatesById.get(element.id);
+        if (!update) {
+          return element;
+        }
+        if (element.type !== update.type) {
+          throw new Error(
+            `Cannot apply tx.updateElements update for "${update.id}": expected "${update.type}", got "${element.type}".`,
+          );
+        }
+
+        type MatchingElement = TransactionElementOfType<typeof update.type>;
+        return newElementWith(
+          element as MatchingElement,
+          update.updates as ElementUpdate<MatchingElement>,
+        );
+      });
+
+    this.updateScene({
+      elements: nextElements,
+      appState: data.appState,
+    });
+  }
+
+  commit(options?: CommitOptions): TransactionSummary {
+    if (this.cachedSummary) {
+      return this.cachedSummary;
+    }
+
+    this.manager.markTransactionCommitted(this.id);
+    let historyCommitted = false;
+    try {
+      historyCommitted = this.hasPendingWork()
+        ? this.commitHistoryEntry(options)
+        : false;
+    } finally {
+      this.closeTransaction();
+    }
+
+    const status = this.status;
+    this.cachedSummary = {
+      id: this.id,
+      status,
+      historyCommitted,
+    };
+    this.ledger.clear();
+    return this.cachedSummary;
+  }
+
+  private hasPendingWork() {
+    return this.ledger.hasEntries() || this.hasAccumulatedAppStateIntent();
+  }
+
+  private hasAccumulatedAppStateIntent() {
+    return Object.keys(this.accumulatedAppState).length > 0;
+  }
+
+  private commitHistoryEntry(options?: CommitOptions) {
+    const liveMap = this.app.scene.getElementsMapIncludingDeleted();
+    const { elementsBefore, elementsAfter } =
+      this.ledger.buildSyntheticSnapshots(liveMap);
+
+    const appStateDelta = this.resolveCommitAppStateDelta(options);
+
+    return this.app.store.commitSyntheticIncrement({
+      logicalBefore: { elements: elementsBefore },
+      logicalAfter: {
+        elements: elementsAfter,
+        appState: appStateDelta,
+      },
+    });
+  }
+
+  private resolveCommitAppStateDelta(
+    options?: CommitOptions,
+  ): Partial<ObservedAppState> | undefined {
+    if (!this.hasAccumulatedAppStateIntent()) {
+      return undefined;
+    }
+
+    if (!options?.resolveAppState) {
+      return this.accumulatedAppState as Partial<ObservedAppState>;
+    }
+
+    const context: AppStateResolverContext = {
+      initial: this.initialAppState,
+      accumulated: this.accumulatedAppState as Partial<ObservedAppState>,
+      live: { ...this.app.store.snapshot.appState },
+    };
+    const resolved = options.resolveAppState(context);
+
+    if (!resolved || Object.keys(resolved).length === 0) {
+      return undefined;
+    }
+    return resolved;
+  }
+
+  cancel(): TransactionSummary {
+    if (this.cachedSummary) {
+      return this.cachedSummary;
+    }
+
+    if (this.status === "active") {
+      this.manager.markTransactionCanceled(this.id);
+    }
+
+    this.closeTransaction();
+    const status = this.status;
+    this.cachedSummary = {
+      id: this.id,
+      status,
+      historyCommitted: false,
+    };
+    this.ledger.clear();
+    return this.cachedSummary;
+  }
+}

packages/excalidraw/transaction/types.ts

@@ -0,0 +1,83 @@
+import type { ElementUpdate } from "@excalidraw/element";
+
+import type {
+  ExcalidrawElement,
+  ExcalidrawNonSelectionElement,
+} from "@excalidraw/element/types";
+
+import type { ObservedAppState } from "../types";
+
+export type ElementPropName = Extract<keyof ExcalidrawElement, string>;
+
+export type TouchedElementProps =
+  | { kind: "all" }
+  | { kind: "partial"; props: Set<ElementPropName> };
+
+export type ElementChange = {
+  id: ExcalidrawElement["id"];
+  before: ExcalidrawElement | null;
+  after: ExcalidrawElement | null;
+  touchedProps: TouchedElementProps;
+};
+
+/** Per-element ledger record captured during a transaction session. */
+export type TransactionLedgerEntry = {
+  baselineElement: ExcalidrawElement | null;
+  targetElement: ExcalidrawElement | null;
+  touchedProps: TouchedElementProps;
+};
+
+/** Lifecycle state of a transaction. */
+export type TransactionStatus = "active" | "committed" | "canceled";
+
+/** Per-element partial patch used by tx.updateElements(). */
+export type TransactionUpdatableElementType =
+  ExcalidrawNonSelectionElement["type"];
+
+export type TransactionElementOfType<
+  TType extends TransactionUpdatableElementType,
+> = Extract<ExcalidrawNonSelectionElement, { type: TType }>;
+
+export type TransactionElementUpdate<
+  TType extends TransactionUpdatableElementType = TransactionUpdatableElementType,
+> = TType extends TransactionUpdatableElementType
+  ? {
+      id: ExcalidrawElement["id"];
+      type: TType;
+      updates: ElementUpdate<TransactionElementOfType<TType>>;
+    }
+  : never;
+
+/** Final summary returned when a transaction is committed or canceled. */
+export type TransactionSummary = {
+  id: string;
+  status: TransactionStatus;
+  historyCommitted: boolean;
+};
+
+/** Three-way appState context provided to the resolver at commit time. */
+export type AppStateResolverContext = {
+  /** AppState snapshot captured when the transaction was created. */
+  initial: Partial<ObservedAppState>;
+  /** Merged appState intent from all updateScene calls during the transaction. */
+  accumulated: Partial<ObservedAppState>;
+  /** Current live appState at commit time. */
+  live: Partial<ObservedAppState>;
+};
+
+/**
+ * Caller-provided resolver that determines which appState changes are
+ * recorded in the history entry.
+ *
+ * Unlike elements — where per-property conflict detection works because
+ * element properties are largely independent — appState keys are often
+ * interdependent (e.g. selectedElementIds ↔ selectedGroupIds must stay
+ * consistent). The correct merge strategy therefore depends on the
+ * caller's semantic context, not on a generic policy.
+ *
+ * Return the appState delta to record in history, or undefined to skip
+ * appState changes entirely.
+ */
+export type AppStateResolver = (
+  context: AppStateResolverContext,
+) => Partial<ObservedAppState> | undefined;

packages/excalidraw/transaction/undoOverridePlanner.ts

@@ -0,0 +1,283 @@
+import type { StoreDelta, TxUndoOverride } from "@excalidraw/element";
+
+import type { ExcalidrawElement } from "@excalidraw/element/types";
+
+import {
+  TX_UNDO_OVERRIDE_IGNORED_PROPS,
+  collectElementChanges,
+  getElementProp,
+  getElementPropEntries,
+  getUpdatedElementEntries,
+  hasTouchedProp,
+  isPartialTouchedProps,
+  isLedgerValueEqual,
+  serializeConsumedPropKey,
+  serializeIntermediateValue,
+  touchesWholeElement,
+  type ElementUpdatedEntry,
+} from "./diff";
+
+import type {
+  ElementPropName,
+  TouchedElementProps,
+  TransactionLedgerEntry,
+} from "./types";
+
+type TxUndoOverrideCandidate = Omit<TxUndoOverride, "txId">;
+
+/**
+ * Per-element-prop history of tx intermediate values.
+ *
+ * We keep:
+ * - the full sequence for exact deep-equality fallback
+ * - a serialized signature set for fast negative lookups
+ * - the latest value for the most common positive lookup path
+ */
+class TxIntermediateValueHistory {
+  private readonly values: unknown[] = [];
+  private readonly signatures = new Set<string>();
+  private latestValue: unknown;
+  private hasLatestValue = false;
+
+  /** Appends a new intermediate value, skipping consecutive duplicates. */
+  add(value: unknown) {
+    if (this.hasLatestValue && isLedgerValueEqual(this.latestValue, value)) {
+      return;
+    }
+
+    this.values.push(value);
+    this.signatures.add(serializeIntermediateValue(value));
+    this.latestValue = value;
+    this.hasLatestValue = true;
+  }
+
+  /** Returns whether the candidate appeared in this tx prop history. */
+  contains(candidate: unknown) {
+    const candidateSignature = serializeIntermediateValue(candidate);
+    if (!this.signatures.has(candidateSignature)) {
+      return false;
+    }
+
+    if (
+      this.hasLatestValue &&
+      isLedgerValueEqual(this.latestValue, candidate)
+    ) {
+      return true;
+    }
+
+    return this.values.some((value) => isLedgerValueEqual(value, candidate));
+  }
+}
+
+/**
+ * Tracks tx intermediate values and computes undo baseline override markers
+ * for durable user deltas recorded while tx is active.
+ *
+ * High-level flow:
+ * 1. `recordStep()` observes every in-tx scene mutation and records the
+ *    intermediate value reached by each touched element prop.
+ * 2. When a durable user delta is about to be recorded,
+ *    `collectCandidatesForDurableDelta()` checks whether that delta's
+ *    deleted-baseline values match any tx intermediate value.
+ * 3. If they do, we emit override candidates so undo can restore the pre-tx
+ *    baseline once the tx has ended.
+ * 4. `markConsumed()` ensures only the first polluted durable entry for a
+ *    given element+prop gets patched; later user actions keep their own
+ *    action-local undo baseline.
+ */
+export class TxUndoOverridePlanner {
+  private readonly intermediateValuesByElementProp = new Map<
+    string,
+    Map<ElementPropName, TxIntermediateValueHistory>
+  >();
+  private readonly consumedOverridePropKeys = new Set<string>();
+
+  /** Resets planner state when the transaction finishes. */
+  clear() {
+    this.consumedOverridePropKeys.clear();
+    this.intermediateValuesByElementProp.clear();
+  }
+
+  /** Records per-prop intermediate values reached by one in-tx scene step. */
+  recordStep(
+    before: ReadonlyMap<string, ExcalidrawElement>,
+    after: ReadonlyMap<string, ExcalidrawElement>,
+  ) {
+    for (const change of collectElementChanges(before, after)) {
+      const { id: elementId, after: afterElement, touchedProps } = change;
+
+      if (!afterElement || !isPartialTouchedProps(touchedProps)) {
+        continue;
+      }
+
+      for (const prop of touchedProps.props) {
+        this.recordIntermediateValue(
+          elementId,
+          prop,
+          getElementProp(afterElement, prop),
+        );
+      }
+    }
+  }
+
+  /**
+   * Collects override candidates for one durable user delta recorded while the
+   * tx is active.
+   */
+  collectCandidatesForDurableDelta(
+    delta: StoreDelta,
+    getLedgerEntry: (elementId: string) => TransactionLedgerEntry | undefined,
+    reservedConsumedKeys: Set<string>,
+  ): TxUndoOverrideCandidate[] {
+    const candidates: TxUndoOverrideCandidate[] = [];
+
+    for (const [elementId, deltaEntry] of Object.entries(
+      getUpdatedElementEntries(delta),
+    )) {
+      const ledgerEntry = getLedgerEntry(elementId);
+      if (!ledgerEntry) {
+        continue;
+      }
+
+      const elementCandidates = this.collectCandidatesForElement(
+        elementId,
+        deltaEntry,
+        ledgerEntry,
+        reservedConsumedKeys,
+      );
+      if (elementCandidates.length > 0) {
+        candidates.push(...elementCandidates);
+      }
+    }
+
+    return candidates;
+  }
+
+  /** Evaluates one element's updated entry against the tx ledger snapshot. */
+  private collectCandidatesForElement(
+    elementId: string,
+    deltaEntry: ElementUpdatedEntry,
+    ledgerEntry: TransactionLedgerEntry,
+    reservedConsumedKeys: Set<string>,
+  ): TxUndoOverrideCandidate[] {
+    const { baselineElement, touchedProps } = ledgerEntry;
+    if (!baselineElement || touchesWholeElement(touchedProps)) {
+      return [];
+    }
+
+    const candidates: TxUndoOverrideCandidate[] = [];
+    for (const [prop, deletedValue] of getElementPropEntries(
+      deltaEntry.deleted,
+    )) {
+      const candidate = this.createCandidateForProp({
+        elementId,
+        prop,
+        deletedValue,
+        baselineElement,
+        touchedProps,
+        reservedConsumedKeys,
+      });
+      if (candidate) {
+        candidates.push(candidate);
+      }
+    }
+
+    return candidates;
+  }
+
+  /**
+   * Returns an override candidate for one element+prop when the durable delta's
+   * deleted baseline was polluted by a tx intermediate value.
+   */
+  private createCandidateForProp(args: {
+    elementId: string;
+    prop: ElementPropName;
+    deletedValue: unknown;
+    baselineElement: ExcalidrawElement;
+    touchedProps: TouchedElementProps;
+    reservedConsumedKeys: Set<string>;
+  }): TxUndoOverrideCandidate | null {
+    const { elementId, prop, deletedValue, baselineElement, touchedProps } =
+      args;
+
+    if (
+      TX_UNDO_OVERRIDE_IGNORED_PROPS.has(prop) ||
+      !hasTouchedProp(touchedProps, prop)
+    ) {
+      return null;
+    }
+
+    const consumedPropKey = serializeConsumedPropKey(elementId, prop);
+    // Override only the first polluted user entry for this element+prop.
+    // Later user actions should keep action-local undo baselines.
+    if (
+      this.consumedOverridePropKeys.has(consumedPropKey) ||
+      args.reservedConsumedKeys.has(consumedPropKey)
+    ) {
+      return null;
+    }
+
+    if (!this.matchesIntermediateValue(elementId, prop, deletedValue)) {
+      return null;
+    }
+
+    return {
+      elementId,
+      prop,
+      expectedInsertedValue: deletedValue,
+      preTxBaselineValue: getElementProp(baselineElement, prop),
+      consumedKey: consumedPropKey,
+    };
+  }
+
+  /** Marks an element+prop override as consumed by an earlier durable entry. */
+  markConsumed(consumedPropKey: string) {
+    this.consumedOverridePropKeys.add(consumedPropKey);
+  }
+
+  /** Returns the per-prop history map for one element, creating it if needed. */
+  private getOrCreatePropValues(elementId: string) {
+    const existing = this.intermediateValuesByElementProp.get(elementId);
+    if (existing) {
+      return existing;
+    }
+
+    const created = new Map<ElementPropName, TxIntermediateValueHistory>();
+    this.intermediateValuesByElementProp.set(elementId, created);
+    return created;
+  }
+
+  /** Appends one observed intermediate value for an element prop. */
+  private recordIntermediateValue(
+    elementId: string,
+    prop: ElementPropName,
+    value: unknown,
+  ) {
+    const propValues = this.getOrCreatePropValues(elementId);
+    const history = propValues.get(prop);
+    if (history) {
+      history.add(value);
+      return;
+    }
+
+    const nextHistory = new TxIntermediateValueHistory();
+    nextHistory.add(value);
+    propValues.set(prop, nextHistory);
+  }
+
+  /** Checks whether a durable delta baseline matches any tx intermediate value. */
+  private matchesIntermediateValue(
+    elementId: string,
+    prop: ElementPropName,
+    candidate: unknown,
+  ) {
+    const history = this.intermediateValuesByElementProp
+      .get(elementId)
+      ?.get(prop);
+    if (!history) {
+      return false;
+    }
+
+    return history.contains(candidate);
+  }
+}

packages/excalidraw/types.ts

@@ -315,10 +315,7 @@ export interface AppState {
   bindingPreference: "enabled" | "disabled";
   /** user preference whether arrow snap to midpoints while binding */
   isMidpointSnappingEnabled: boolean;
-  /**
-   * The bindable element the UI highlights for the user when an arrow is
-   * dragged or otherwise its endpoint being close to said element.
-   */
+  startBoundElement: NonDeleted<ExcalidrawBindableElement> | null;
   suggestedBinding: {
     element: NonDeleted<ExcalidrawBindableElement>;
     midPoint?: GlobalPoint;
@@ -350,11 +347,8 @@ export interface AppState {
     type: "selection" | "lasso";
     initialized: boolean;
   };
-
-  // Pen handling
   penMode: boolean;
   penDetected: boolean;
-
   exportBackground: boolean;
   exportEmbedScene: boolean;
   exportWithDarkMode: boolean;
@@ -478,9 +472,6 @@ export interface AppState {
   // as elements are unlocked, we remove the groupId from the elements
   // and also remove groupId from this map
   lockedMultiSelections: { [groupId: string]: true };
-  // Stores the current bind mode which is detemined at various points during
-  // a drag operation (like pointer position vs bindable element) but needed
-  // globally for calculating the binding strategy
   bindMode: BindMode;
 }
 
@@ -496,7 +487,10 @@ export type SearchMatch = {
   }[];
 };
 
-export type UIAppState = Omit<AppState, "cursorButton" | "scrollX" | "scrollY">;
+export type UIAppState = Omit<
+  AppState,
+  "startBoundElement" | "cursorButton" | "scrollX" | "scrollY"
+>;
 
 export type NormalizedZoomValue = number & { _brand: "normalizedZoom" };
 
@@ -802,6 +796,9 @@ export type AppClassProperties = {
   files: BinaryFiles;
   editorInterface: App["editorInterface"];
   scene: App["scene"];
+  store: App["store"];
+  transactionManager: App["transactionManager"];
+  createTransaction: App["createTransaction"];
   syncActionResult: App["syncActionResult"];
   fonts: App["fonts"];
   pasteFromClipboard: App["pasteFromClipboard"];
@@ -876,13 +873,8 @@ export type PointerDownState = Readonly<{
     // Whether selected element(s) were duplicated, might change during the
     // pointer interaction
     hasBeenDuplicated: boolean;
-    // Whether the pointer is hitting the common bounding box of selected
-    // elements, which is useful for discriminating between selecitng
-    // the entire selection vs a specific element
     hasHitCommonBoundingBoxOfSelectedElements: boolean;
   };
-  // This is determined on the initial pointer down event to
-  // set various interaction modalities
   withCmdOrCtrl: boolean;
   drag: {
     // Might change during the pointer interaction
@@ -908,7 +900,6 @@ export type PointerDownState = Readonly<{
     onKeyUp: null | ((event: KeyboardEvent) => void);
   };
   boxSelection: {
-    // If the box selection tool is activated on pointer down
     hasOccurred: boolean;
   };
 }>;

packages/math/src/constants.ts

@@ -1,3 +1,5 @@
+export const PRECISION = 10e-5;
+
 // Legendre-Gauss abscissae (x values) and weights for n=24
 // Refeerence: https://pomax.github.io/bezierinfo/legendre-gauss.html
 export const LegendreGaussN24TValues = [

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

@@ -98,6 +98,7 @@ exports[`exportToSvg > with default arguments 1`] = `
   "showHyperlinkPopup": false,
   "showWelcomeScreen": false,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,