microboard-temp 0.13.44 → 0.13.46

package/dist/cjs/browser.js

@@ -4133,277 +4133,6 @@ var init_Color = __esm(() => {
   init_resolveColor();
 });
 
-// src/Events/SyncLog.ts
-function createSyncLog() {
-  const log = [];
-  const subject = new Subject;
-  log.push = function(...msgs) {
-    let newLength = log.length;
-    for (const msg of msgs) {
-      const lastItem = log[log.length - 1];
-      if (lastItem && lastItem.msg === msg.msg) {
-        lastItem.records = lastItem.records.concat(msg.records);
-      } else {
-        newLength = Array.prototype.push.call(log, msg);
-      }
-    }
-    subject.publish(log);
-    return newLength;
-  };
-  return {
-    log,
-    subject
-  };
-}
-var init_SyncLog = () => {};
-
-// src/Events/Log/createEventsList.ts
-function createEventsList(commandFactory) {
-  const confirmedRecords = [];
-  const recordsToSend = [];
-  const newRecords = [];
-  const justConfirmed = [];
-  const { log: syncLog, subject: syncLogSubject } = createSyncLog();
-  let snapshotLastIndex = 0;
-  function revert(records) {
-    for (let i = records.length - 1;i >= 0; i--) {
-      records[i].command.revert();
-    }
-  }
-  function getOpItems(op) {
-    if ("item" in op) {
-      const item = op.item;
-      if (Array.isArray(item))
-        return item;
-      if (typeof item === "string")
-        return [item];
-      if (item && typeof item === "object")
-        return Object.keys(item);
-    }
-    if ("itemsMap" in op && op.itemsMap)
-      return Object.keys(op.itemsMap);
-    if ("items" in op) {
-      const items = op.items;
-      if (Array.isArray(items)) {
-        return items.map((i) => typeof i === "string" ? i : i.id).filter(Boolean);
-      }
-      if (items && typeof items === "object" && items !== null)
-        return Object.keys(items);
-    }
-    if ("itemsOps" in op) {
-      const itemsOps = op.itemsOps;
-      return itemsOps.map((io) => io.item);
-    }
-    return [];
-  }
-  return {
-    commandFactory,
-    addConfirmedRecords(records) {
-      confirmedRecords.push(...records);
-      syncLog.push({ msg: "confirmed", records });
-    },
-    addNewRecords(records) {
-      newRecords.push(...records);
-      syncLog.push({ msg: "addedNew", records });
-    },
-    confirmSentRecords(events) {
-      for (const event of events) {
-        const index = recordsToSend.findIndex((r) => r.event.body.eventId === event.body.eventId);
-        if (index !== -1) {
-          const [record] = recordsToSend.splice(index, 1);
-          confirmedRecords.push(record);
-          syncLog.push({ msg: "confirmed", records: [record] });
-        }
-      }
-    },
-    getConfirmedRecords() {
-      return confirmedRecords;
-    },
-    getRecordsToSend() {
-      return recordsToSend;
-    },
-    getNewRecords() {
-      return newRecords;
-    },
-    getAllRecords() {
-      return [...confirmedRecords, ...recordsToSend, ...newRecords];
-    },
-    prepareRecordsToSend() {
-      const records = [...newRecords];
-      recordsToSend.push(...records);
-      newRecords.length = 0;
-      syncLog.push({ msg: "toSend", records });
-      return records;
-    },
-    forwardIterable() {
-      return function* () {
-        yield* confirmedRecords;
-        yield* recordsToSend;
-        yield* newRecords;
-      }();
-    },
-    backwardIterable() {
-      return function* () {
-        for (let i = newRecords.length - 1;i >= 0; i--)
-          yield newRecords[i];
-        for (let i = recordsToSend.length - 1;i >= 0; i--)
-          yield recordsToSend[i];
-        for (let i = confirmedRecords.length - 1;i >= 0; i--)
-          yield confirmedRecords[i];
-      }();
-    },
-    revertUnconfirmed(predicate) {
-      const toRevert = [...recordsToSend, ...newRecords].filter(predicate || (() => true));
-      revert(toRevert);
-      syncLog.push({ msg: "revertUnconfirmed", records: toRevert });
-    },
-    applyUnconfirmed(predicate) {
-      const unconfirmed = [...recordsToSend, ...newRecords].filter(predicate || (() => true));
-      for (const record of unconfirmed) {
-        record.command.apply();
-      }
-      syncLog.push({ msg: "applyUnconfirmed", records: unconfirmed });
-    },
-    justConfirmed,
-    getSyncLog() {
-      return syncLog;
-    },
-    syncLogSubject,
-    clear() {
-      confirmedRecords.length = 0;
-      recordsToSend.length = 0;
-      newRecords.length = 0;
-      syncLog.length = 0;
-      syncLogSubject.publish(syncLog);
-    },
-    clearConfirmedRecords() {
-      confirmedRecords.length = 0;
-      syncLog.length = 0;
-      syncLogSubject.publish(syncLog);
-    },
-    removeUnconfirmedEventsByItems(itemIds) {
-      const itemIdSet = new Set(itemIds);
-      const filter = (record) => {
-        const opItems = getOpItems(record.event.body.operation);
-        return !opItems.some((id) => itemIdSet.has(id));
-      };
-      const filteredNewRecords = newRecords.filter(filter);
-      newRecords.length = 0;
-      newRecords.push(...filteredNewRecords);
-      const filteredRecordsToSend = recordsToSend.filter(filter);
-      recordsToSend.length = 0;
-      recordsToSend.push(...filteredRecordsToSend);
-      syncLog.length = 0;
-      syncLog.push({ msg: "confirmed", records: confirmedRecords });
-      syncLog.push({ msg: "toSend", records: recordsToSend });
-      syncLog.push({ msg: "addedNew", records: newRecords });
-      syncLogSubject.publish(syncLog);
-    },
-    isAllEventsConfirmed() {
-      return recordsToSend.length === 0 && newRecords.length === 0;
-    },
-    setSnapshotLastIndex(index) {
-      snapshotLastIndex = index;
-    },
-    getSnapshotLastIndex() {
-      return snapshotLastIndex;
-    }
-  };
-}
-var init_createEventsList = __esm(() => {
-  init_SyncLog();
-});
-
-// src/Events/Log/getRecordByIdFromList.ts
-function getRecordByIdFromList(id, list) {
-  for (const record of list.forwardIterable()) {
-    if (record.event.body.eventId === id) {
-      return record;
-    }
-  }
-  return;
-}
-
-// src/Events/Log/shouldSkipEvent.ts
-function shouldSkipEvent(record, userId) {
-  const { operation } = record.event.body;
-  return record.event.body.userId !== userId || operation.method === "updateVideoData" || operation.class === "Audio" && operation.method === "setUrl";
-}
-
-// src/Events/Log/getRedoRecordFromList.ts
-function getRedoRecordFromList(userId, list) {
-  let counter = 0;
-  for (const record of list.backwardIterable()) {
-    if (shouldSkipEvent(record, userId)) {
-      continue;
-    }
-    if (record.event.body.operation.method !== "undo" && record.event.body.operation.method !== "redo") {
-      return null;
-    }
-    const { method } = record.event.body.operation;
-    if (method === "redo") {
-      counter++;
-    } else if (method === "undo") {
-      if (counter > 0) {
-        counter--;
-      } else if (counter === 0) {
-        return record;
-      }
-    }
-  }
-  return null;
-}
-var init_getRedoRecordFromList = () => {};
-
-// src/Events/Log/getUndoRecordFromList.ts
-function getUndoRecordFromList(userId, list) {
-  let counter = 0;
-  const isAllEventsConfirmed = list.isAllEventsConfirmed();
-  if (!isAllEventsConfirmed) {
-    return null;
-  }
-  for (const record of list.getConfirmedRecords().slice().reverse()) {
-    if (shouldSkipEvent(record, userId)) {
-      continue;
-    }
-    if (record.event.body.operation.method === "undo") {
-      counter++;
-    } else if (counter === 0) {
-      return record;
-    } else {
-      counter--;
-    }
-  }
-  return null;
-}
-var init_getUndoRecordFromList = () => {};
-
-// src/Events/Log/getUnpublishedEventFromList.ts
-function getUnpublishedEventFromList(list) {
-  const recordsToSend = list.prepareRecordsToSend();
-  if (recordsToSend.length === 0) {
-    return null;
-  }
-  const operations = getOperationsFromEventRecords(recordsToSend);
-  return combineOperationsIntoPack(recordsToSend[0].event, operations);
-}
-function getOperationsFromEventRecords(records) {
-  return records.map((record) => ({
-    ...record.event.body.operation,
-    actualId: record.event.body.eventId
-  }));
-}
-function combineOperationsIntoPack(baseEvent, operations) {
-  const { operation, ...bodyWithoutOperation } = baseEvent.body;
-  return {
-    ...baseEvent,
-    body: {
-      ...bodyWithoutOperation,
-      operations
-    }
-  };
-}
-
 // src/Events/EventsOperations.ts
 function isTransformation(op) {
   return op.class === "Transformation";
@@ -4732,41 +4461,69 @@ var init_Merge = __esm(() => {
   import_slate = require("slate");
 });
 
-// src/Events/mergeEvents.ts
-function mergeEvents(events) {
-  if (events.length < 2) {
-    return events;
+// src/Events/mergeRecords.ts
+function mergeRecords(records) {
+  if (records.length < 2) {
+    return records;
   }
-  const mergedEvents = [];
+  const mergedRecords = [];
   let previous = null;
-  for (const event of events) {
+  for (const record of records) {
     if (!previous) {
-      previous = event;
+      previous = record;
       continue;
     }
-    const mergedOperation = mergeOperations(previous.body.operation, event.body.operation);
-    if (!mergedOperation) {
-      mergedEvents.push(previous);
-      previous = event;
+    const mergedEventOperation = mergeOperations(previous.event.body.operation, record.event.body.operation);
+    if (!mergedEventOperation) {
+      mergedRecords.push(previous);
+      previous = record;
     } else {
+      const mergedCommand = record.command.merge ? previous.command.merge(mergedEventOperation) : previous.command;
       previous = {
-        ...event,
-        body: {
-          ...event.body,
-          operation: mergedOperation
-        }
+        event: {
+          ...record.event,
+          body: {
+            ...record.event.body,
+            operation: mergedEventOperation
+          }
+        },
+        command: mergedCommand
       };
     }
   }
   if (previous) {
-    mergedEvents.push(previous);
+    mergedRecords.push(previous);
   }
-  return mergedEvents;
+  return mergedRecords;
 }
-var init_mergeEvents = __esm(() => {
+var init_mergeRecords = __esm(() => {
   init_Merge();
 });
 
+// src/Events/SyncLog.ts
+function createSyncLog() {
+  const log = [];
+  const subject = new Subject;
+  log.push = function(...msgs) {
+    let newLength = log.length;
+    for (const msg of msgs) {
+      const lastItem = log[log.length - 1];
+      if (lastItem && lastItem.msg === msg.msg) {
+        lastItem.records = lastItem.records.concat(msg.records);
+      } else {
+        newLength = Array.prototype.push.call(log, msg);
+      }
+    }
+    subject.publish(log);
+    return newLength;
+  };
+  return {
+    log,
+    subject
+  };
+}
+var init_SyncLog = () => {};
+
 // src/Events/Transform/removeText_removeText.ts
 function removeText_removeText(confirmed, toTransform) {
   const transformed = { ...toTransform };
@@ -5883,6 +5640,346 @@ var init_transformEvents = __esm(() => {
   init_Transform2();
 });
 
+// src/Events/Log/createEventsList.ts
+function createEventsList(commandFactory) {
+  const confirmedRecords = [];
+  const recordsToSend = [];
+  const newRecords = [];
+  const justConfirmed = [];
+  const { log: syncLog, subject: syncLogSubject } = createSyncLog();
+  let snapshotLastIndex = 0;
+  function revert(records) {
+    for (let i = records.length - 1;i >= 0; i--) {
+      records[i].command.revert();
+    }
+  }
+  function apply(records) {
+    for (const record of records) {
+      record.command = commandFactory(record.event.body.operation);
+      record.command.apply();
+    }
+  }
+  function mergeAndPushConfirmedRecords(records) {
+    const lastConfirmedRecord = confirmedRecords.pop();
+    const recordsToMerge = lastConfirmedRecord ? [lastConfirmedRecord, ...records] : records;
+    const mergedRecords = mergeRecords(recordsToMerge);
+    confirmedRecords.push(...mergedRecords);
+  }
+  return {
+    commandFactory,
+    addConfirmedRecords(records) {
+      syncLog.push({ msg: "confirmed", records });
+      mergeAndPushConfirmedRecords(records);
+    },
+    addNewRecords(records) {
+      for (const record of records) {
+        if (newRecords.length > 0) {
+          const lastRecord = newRecords[newRecords.length - 1];
+          const mergedOperation = mergeOperations(lastRecord.event.body.operation, record.event.body.operation);
+          if (mergedOperation) {
+            lastRecord.event = {
+              ...lastRecord.event,
+              body: {
+                ...lastRecord.event.body,
+                operation: mergedOperation
+              }
+            };
+            lastRecord.command = commandFactory(mergedOperation);
+            continue;
+          }
+        }
+        newRecords.push(record);
+        syncLog.push({ msg: "addedNew", records: [record] });
+      }
+    },
+    confirmSentRecords(events) {
+      const records = recordsToSend;
+      if (records.length !== events.length) {
+        console.error("Mismatch between records and events length");
+        return;
+      }
+      for (let i = 0;i < records.length; i++) {
+        records[i].event.order = events[i].order;
+      }
+      syncLog.push({ msg: "confirmed", records: [...records] });
+      mergeAndPushConfirmedRecords(records);
+      recordsToSend.splice(0, records.length);
+    },
+    confirmSentRecordIds(eventIds, order) {
+      const confirmedRecordsById = [];
+      for (const eventId of eventIds) {
+        const index = recordsToSend.findIndex((record2) => record2.event.body.eventId === eventId);
+        if (index === -1) {
+          continue;
+        }
+        const [record] = recordsToSend.splice(index, 1);
+        record.event.order = order;
+        confirmedRecordsById.push(record);
+      }
+      if (confirmedRecordsById.length === 0) {
+        return;
+      }
+      syncLog.push({ msg: "confirmed", records: confirmedRecordsById });
+      mergeAndPushConfirmedRecords(confirmedRecordsById);
+    },
+    getConfirmedRecords() {
+      return confirmedRecords;
+    },
+    getRecordsToSend() {
+      return recordsToSend;
+    },
+    getNewRecords() {
+      return newRecords;
+    },
+    getAllRecords() {
+      return [...confirmedRecords, ...recordsToSend, ...newRecords];
+    },
+    prepareRecordsToSend() {
+      if (recordsToSend.length === 0 && newRecords.length > 0) {
+        const records = [...newRecords];
+        recordsToSend.push(...records);
+        newRecords.length = 0;
+        syncLog.push({ msg: "toSend", records });
+      }
+      return recordsToSend;
+    },
+    forwardIterable() {
+      return function* () {
+        yield* confirmedRecords;
+        yield* recordsToSend;
+        yield* newRecords;
+      }();
+    },
+    backwardIterable() {
+      return function* () {
+        for (let i = newRecords.length - 1;i >= 0; i--)
+          yield newRecords[i];
+        for (let i = recordsToSend.length - 1;i >= 0; i--)
+          yield recordsToSend[i];
+        for (let i = confirmedRecords.length - 1;i >= 0; i--)
+          yield confirmedRecords[i];
+      }();
+    },
+    revertUnconfirmed(predicate) {
+      const toRevert = [...recordsToSend, ...newRecords].filter(predicate || (() => true));
+      revert(toRevert);
+      syncLog.push({ msg: "revertUnconfirmed", records: toRevert });
+    },
+    applyUnconfirmed(predicate) {
+      const filter = predicate || (() => true);
+      if (justConfirmed.length > 0) {
+        const confirmedEvents = justConfirmed.map((record) => record.event);
+        const transformedSend = transformEvents(confirmedEvents, recordsToSend.map((record) => record.event));
+        const transformedNew = transformEvents(confirmedEvents, newRecords.map((record) => record.event));
+        const updatedRecordsToSend = transformedSend.map((event) => ({
+          event,
+          command: commandFactory(event.body.operation)
+        }));
+        const updatedNewRecords = transformedNew.map((event) => ({
+          event,
+          command: commandFactory(event.body.operation)
+        }));
+        recordsToSend.length = 0;
+        recordsToSend.push(...updatedRecordsToSend);
+        newRecords.length = 0;
+        newRecords.push(...updatedNewRecords);
+        justConfirmed.length = 0;
+      }
+      const unconfirmed = [...recordsToSend, ...newRecords].filter(filter);
+      apply(unconfirmed);
+      syncLog.push({ msg: "applyUnconfirmed", records: unconfirmed });
+    },
+    justConfirmed,
+    getSyncLog() {
+      return syncLog;
+    },
+    syncLogSubject,
+    clear() {
+      confirmedRecords.length = 0;
+      recordsToSend.length = 0;
+      newRecords.length = 0;
+      syncLog.length = 0;
+      syncLogSubject.publish(syncLog);
+    },
+    clearConfirmedRecords() {
+      confirmedRecords.length = 0;
+      syncLog.length = 0;
+      syncLogSubject.publish(syncLog);
+    },
+    removeUnconfirmedEventsByItems(itemIds) {
+      function shouldRemoveEvent(operation, ids) {
+        if (operation.method === "add" && operation.class === "Board") {
+          if (Array.isArray(operation.item)) {
+            return operation.item.some((id) => ids.includes(id));
+          }
+          return ids.includes(operation.item);
+        }
+        if (operation.method === "remove" && operation.class === "Board") {
+          return operation.item.some((id) => ids.includes(id));
+        }
+        return false;
+      }
+      const nextRecordsToSend = recordsToSend.filter((record) => !shouldRemoveEvent(record.event.body.operation, itemIds));
+      if (nextRecordsToSend.length !== recordsToSend.length) {
+        recordsToSend.length = 0;
+        recordsToSend.push(...nextRecordsToSend);
+      }
+      const nextNewRecords = newRecords.filter((record) => !shouldRemoveEvent(record.event.body.operation, itemIds));
+      if (nextNewRecords.length !== newRecords.length) {
+        newRecords.length = 0;
+        newRecords.push(...nextNewRecords);
+      }
+    },
+    isAllEventsConfirmed() {
+      return recordsToSend.length === 0 && newRecords.length === 0;
+    },
+    setSnapshotLastIndex(index) {
+      snapshotLastIndex = index;
+    },
+    getSnapshotLastIndex() {
+      return snapshotLastIndex;
+    }
+  };
+}
+var init_createEventsList = __esm(() => {
+  init_Merge();
+  init_mergeRecords();
+  init_SyncLog();
+  init_transformEvents();
+});
+
+// src/Events/Log/getRecordByIdFromList.ts
+function getRecordByIdFromList(id, list) {
+  for (const record of list.forwardIterable()) {
+    if (record.event.body.eventId === id) {
+      return record;
+    }
+  }
+  return;
+}
+
+// src/Events/Log/shouldSkipEvent.ts
+function shouldSkipEvent(record, userId) {
+  const { operation } = record.event.body;
+  return record.event.body.userId !== userId || operation.method === "updateVideoData" || operation.class === "Audio" && operation.method === "setUrl";
+}
+
+// src/Events/Log/getRedoRecordFromList.ts
+function getRedoRecordFromList(userId, list) {
+  let counter = 0;
+  for (const record of list.backwardIterable()) {
+    if (shouldSkipEvent(record, userId)) {
+      continue;
+    }
+    if (record.event.body.operation.method !== "undo" && record.event.body.operation.method !== "redo") {
+      return null;
+    }
+    const { method } = record.event.body.operation;
+    if (method === "redo") {
+      counter++;
+    } else if (method === "undo") {
+      if (counter > 0) {
+        counter--;
+      } else if (counter === 0) {
+        return record;
+      }
+    }
+  }
+  return null;
+}
+var init_getRedoRecordFromList = () => {};
+
+// src/Events/Log/getUndoRecordFromList.ts
+function getUndoRecordFromList(userId, list) {
+  let counter = 0;
+  const isAllEventsConfirmed = list.isAllEventsConfirmed();
+  if (!isAllEventsConfirmed) {
+    return null;
+  }
+  for (const record of list.getConfirmedRecords().slice().reverse()) {
+    if (shouldSkipEvent(record, userId)) {
+      continue;
+    }
+    if (record.event.body.operation.method === "undo") {
+      counter++;
+    } else if (counter === 0) {
+      return record;
+    } else {
+      counter--;
+    }
+  }
+  return null;
+}
+var init_getUndoRecordFromList = () => {};
+
+// src/Events/Log/getUnpublishedEventFromList.ts
+function getUnpublishedEventFromList(list) {
+  const recordsToSend = list.prepareRecordsToSend();
+  if (recordsToSend.length === 0) {
+    return null;
+  }
+  const mergedRecords = mergeRecords(recordsToSend);
+  const operations = getOperationsFromEventRecords(mergedRecords);
+  return {
+    event: combineOperationsIntoPack(recordsToSend[0].event, operations),
+    sentEventIds: recordsToSend.map((record) => record.event.body.eventId)
+  };
+}
+function getOperationsFromEventRecords(records) {
+  return records.map((record) => ({
+    ...record.event.body.operation,
+    actualId: record.event.body.eventId
+  }));
+}
+function combineOperationsIntoPack(baseEvent, operations) {
+  const { operation, ...bodyWithoutOperation } = baseEvent.body;
+  return {
+    ...baseEvent,
+    body: {
+      ...bodyWithoutOperation,
+      operations
+    }
+  };
+}
+var init_getUnpublishedEventFromList = __esm(() => {
+  init_mergeRecords();
+});
+
+// src/Events/mergeEvents.ts
+function mergeEvents(events) {
+  if (events.length < 2) {
+    return events;
+  }
+  const mergedEvents = [];
+  let previous = null;
+  for (const event of events) {
+    if (!previous) {
+      previous = event;
+      continue;
+    }
+    const mergedOperation = mergeOperations(previous.body.operation, event.body.operation);
+    if (!mergedOperation) {
+      mergedEvents.push(previous);
+      previous = event;
+    } else {
+      previous = {
+        ...event,
+        body: {
+          ...event.body,
+          operation: mergedOperation
+        }
+      };
+    }
+  }
+  if (previous) {
+    mergedEvents.push(previous);
+  }
+  return mergedEvents;
+}
+var init_mergeEvents = __esm(() => {
+  init_Merge();
+});
+
 // src/Events/Log/expandEvents.ts
 function expandEvents(events) {
   return events.flatMap((event) => {
@@ -6096,6 +6193,9 @@ class EventsLog {
     const events = expandEvents([event]);
     this.list.confirmSentRecords(events);
   }
+  confirmSentLocalEventIds(eventIds, order) {
+    this.list.confirmSentRecordIds(eventIds, order);
+  }
   getUnorderedRecords() {
     return this.list.getRecordsToSend().concat(this.list.getNewRecords());
   }
@@ -6138,6 +6238,7 @@ var init_EventsLog = __esm(() => {
   init_createEventsList();
   init_getRedoRecordFromList();
   init_getUndoRecordFromList();
+  init_getUnpublishedEventFromList();
   init_insertEventsFromOtherConnectionsIntoList();
 });
 
@@ -55451,25 +55552,16 @@ function handleBoardEventMessage(message, board) {
   if (event.order <= log.getLastIndex()) {
     return;
   }
-  const eventUserId = parseFloat(event.body.eventId.split(":")[0]);
-  const currentUserId = Number(localStorage.getItem("userId") || "0");
-  const isEventFromCurrentUser = eventUserId === currentUserId;
+  const eventConnectionId = Number(event.body.eventId.split(":")[0]);
+  const currentConnectionId = board.events.connection?.connectionId;
+  const isEventFromCurrentUser = currentConnectionId !== undefined && eventConnectionId === currentConnectionId;
   if (isEventFromCurrentUser) {
     return;
   }
   if ("operations" in event.body) {
-    log.insertEventsFromOtherConnections({
-      ...event,
-      body: {
-        ...event.body,
-        userId: Number(message.userId)
-      }
-    });
+    log.insertEventsFromOtherConnections(event);
   } else {
-    log.insertEventsFromOtherConnections({
-      ...event,
-      userId: Number(message.userId)
-    });
+    log.insertEventsFromOtherConnections(event);
   }
   const last = log.getLastConfirmed();
   if (last) {
@@ -55521,11 +55613,11 @@ function tryPublishEvent(board) {
   if (log.pendingEvent) {
     return;
   }
-  const unpublishedEvent = log.getUnpublishedEvent();
-  if (!unpublishedEvent) {
+  const unpublishedBatch = log.getUnpublishedEvent();
+  if (!unpublishedBatch) {
     return;
   }
-  sendBoardEvent(board, unpublishedEvent, log.currentSequenceNumber);
+  sendBoardEvent(board, unpublishedBatch, log.currentSequenceNumber);
 }
 function tryResendEvent(board) {
   const { log } = board.events;
@@ -55542,7 +55634,10 @@ function tryResendEvent(board) {
     board.presence.clear();
     conf.connection?.notifyAboutLostConnection();
   }
-  sendBoardEvent(board, log.pendingEvent.event, log.currentSequenceNumber);
+  sendBoardEvent(board, {
+    event: log.pendingEvent.event,
+    sentEventIds: log.pendingEvent.sentEventIds
+  }, log.currentSequenceNumber);
 }
 function handleSnapshotApplication(snapshot, board) {
   const { log } = board.events;
@@ -55567,8 +55662,9 @@ function handleBoardEventListApplication(events, board) {
     board.events.subject.publish(newEvents[0]);
   }
 }
-function sendBoardEvent(board, event, sequenceNumber) {
+function sendBoardEvent(board, batch, sequenceNumber) {
   const { log } = board.events;
+  const { event, sentEventIds } = batch;
   const toSend = {
     ...event,
     body: {
@@ -55586,6 +55682,7 @@ function sendBoardEvent(board, event, sequenceNumber) {
   const date = Date.now();
   log.pendingEvent = {
     event: toSend,
+    sentEventIds,
     sequenceNumber,
     lastSentTime: date
   };
@@ -55633,7 +55730,7 @@ function handleConfirmation(msg, board) {
   conf.connection?.dismissNotificationAboutLostConnection();
   log.currentSequenceNumber++;
   log.pendingEvent.event.order = msg.order;
-  log.confirmSentLocalEvent(log.pendingEvent.event);
+  log.confirmSentLocalEventIds(log.pendingEvent.sentEventIds, msg.order);
   board.subject.publish();
   log.pendingEvent = null;
   log.firstSentTime = null;
@@ -60578,11 +60675,28 @@ class ForceGraphEngine {
   syncTimer = null;
   lastSyncedPositions = new Map;
   activeComponents = new Map;
+  isPhysicsEmit = false;
   TICK_MS = 33;
   SYNC_MS = 300;
   MIN_MOVE_PX = 0.05;
   constructor(board) {
     this.board = board;
+    board.events.subject.subscribe((event) => {
+      if (this.isPhysicsEmit)
+        return;
+      const op = event.body?.operation;
+      if (!op || op.class !== "Transformation" || op.method !== "applyMatrix")
+        return;
+      for (const { id, matrix } of op.items) {
+        const last = this.lastSyncedPositions.get(id);
+        if (last) {
+          this.lastSyncedPositions.set(id, {
+            x: last.x + matrix.translateX,
+            y: last.y + matrix.translateY
+          });
+        }
+      }
+    });
   }
   enableForGraph(startNodeId) {
     if (this.isNodeInActiveGraph(startNodeId))
@@ -60810,8 +60924,8 @@ class ForceGraphEngine {
       }
       vel.vx = (vel.vx + (ax.get(id) ?? 0)) * conf.FG_DAMPING;
       vel.vy = (vel.vy + (ay.get(id) ?? 0)) * conf.FG_DAMPING;
-      totalEnergy += Math.abs(vel.vx) + Math.abs(vel.vy);
       if (Math.abs(vel.vx) >= this.MIN_MOVE_PX || Math.abs(vel.vy) >= this.MIN_MOVE_PX) {
+        totalEnergy += Math.abs(vel.vx) + Math.abs(vel.vy);
         item.transformation.applyMatrixSilent({
           translateX: vel.vx,
           translateY: vel.vy,
@@ -60833,26 +60947,33 @@ class ForceGraphEngine {
     const nodes = this.getNodes().filter((item) => activeIds.has(item.getId()) && !draggedIds.has(item.getId()) && !(item.parent !== "Board" && draggedIds.has(item.parent)));
     if (nodes.length === 0)
       return;
-    const movedItems = nodes.map((item) => {
+    const toSend = [];
+    for (const item of nodes) {
       const id = item.getId();
       const pos = item.transformation.getTranslation();
       const last = this.lastSyncedPositions.get(id);
       const dx = last ? pos.x - last.x : 0;
       const dy = last ? pos.y - last.y : 0;
-      this.lastSyncedPositions.set(id, { x: pos.x, y: pos.y });
-      return { id, dx, dy };
-    }).filter(({ dx, dy }) => Math.abs(dx) > 0.5 || Math.abs(dy) > 0.5);
-    if (movedItems.length === 0)
+      if (Math.abs(dx) > 0.5 || Math.abs(dy) > 0.5) {
+        toSend.push({ id, dx, dy, x: pos.x, y: pos.y });
+      }
+    }
+    if (toSend.length === 0)
       return;
+    for (const { id, x, y } of toSend) {
+      this.lastSyncedPositions.set(id, { x, y });
+    }
     const operation = {
       class: "Transformation",
       method: "applyMatrix",
-      items: movedItems.map(({ id, dx, dy }) => ({
+      items: toSend.map(({ id, dx, dy }) => ({
         id,
         matrix: { translateX: dx, translateY: dy, scaleX: 1, scaleY: 1, shearX: 0, shearY: 0 }
       }))
     };
+    this.isPhysicsEmit = true;
     this.board.events.emit(operation);
+    this.isPhysicsEmit = false;
   }
 }