@sovereignbase/convergent-replicated-list 1.1.0 → 1.2.0

package/dist/index.js

@@ -15,18 +15,27 @@
  */
 
 
-// src/.helpers/assertListIndices/index.ts
-function assertListIndices(crListReplica) {
-  if (!crListReplica.cursor) return;
+// src/.helpers/rebuildLiveIndex/index.ts
+function rebuildLiveIndex(crListReplica) {
+  if (!crListReplica.cursor) {
+    crListReplica.index?.clear();
+    crListReplica.cursorIndex = void 0;
+    return;
+  }
   let index = crListReplica.size;
+  const entries = crListReplica.index ?? /* @__PURE__ */ new Map();
+  void entries.clear();
   while (crListReplica.cursor.next)
     crListReplica.cursor = crListReplica.cursor.next;
   while (index >= 1) {
     index--;
     crListReplica.cursor.index = index;
+    void entries.set(index, crListReplica.cursor);
     if (crListReplica.cursor.prev === void 0) break;
     crListReplica.cursor = crListReplica.cursor.prev;
   }
+  crListReplica.index = entries;
+  crListReplica.cursorIndex = 0;
 }
 
 // src/.errors/class.ts
@@ -49,102 +58,97 @@ var CRListError = class extends Error {
   }
 };
 
-// src/.helpers/walkToIndex/index.ts
-function walkToIndex(targetIndex, crListReplica) {
+// src/.helpers/seekCursorToIndex/index.ts
+function seekCursorToIndex(targetIndex, crListReplica) {
   if (targetIndex < 0 || targetIndex >= crListReplica.size)
     throw new CRListError("INDEX_OUT_OF_BOUNDS", "Index out of bounds");
+  const indexedEntry = crListReplica.index?.get(targetIndex);
+  if (indexedEntry) {
+    if (crListReplica.parentMap.get(indexedEntry.uuidv7) === indexedEntry) {
+      crListReplica.cursor = indexedEntry;
+      crListReplica.cursorIndex = targetIndex;
+      return;
+    } else {
+      void crListReplica.index?.delete(targetIndex);
+    }
+  }
   if (!crListReplica.cursor)
     throw new CRListError("LIST_EMPTY", "List is empty");
-  const direction = crListReplica.cursor.index > targetIndex ? "prev" : "next";
-  while (crListReplica.cursor && crListReplica.cursor.index !== targetIndex) {
+  let cursorIndex = crListReplica.cursorIndex ?? crListReplica.cursor.index;
+  const direction = cursorIndex > targetIndex ? "prev" : "next";
+  while (crListReplica.cursor && cursorIndex !== targetIndex) {
     crListReplica.cursor = crListReplica.cursor[direction];
+    cursorIndex += direction === "next" ? 1 : -1;
+  }
+  if (crListReplica.cursor) {
+    crListReplica.cursorIndex = targetIndex;
+    void crListReplica.index?.set(targetIndex, crListReplica.cursor);
   }
 }
 
-// src/.helpers/insertBetween/index.ts
-function insertBetween(prev, linkedListEntry, next) {
+// src/.helpers/linkEntryBetween/index.ts
+function linkEntryBetween(prev, linkedListEntry, next) {
   linkedListEntry.prev = prev;
   linkedListEntry.next = next;
   if (prev) prev.next = linkedListEntry;
   if (next) next.prev = linkedListEntry;
 }
 
-// src/.helpers/flattenAndLinkTrustedState/index.ts
-function flattenAndLinkTrustedState(crListReplica) {
+// src/.helpers/rebuildLiveProjection/index.ts
+function rebuildLiveProjection(crListReplica) {
   crListReplica.cursor = void 0;
-  const resolvedSiblingPredecessors = /* @__PURE__ */ new Set();
+  const entries = crListReplica.index ?? /* @__PURE__ */ new Map();
+  void entries.clear();
   for (const entry of crListReplica.parentMap.values()) {
     if (!entry) continue;
     entry.prev = void 0;
     entry.next = void 0;
   }
-  const keys = [...crListReplica.childrenMap.keys()].sort(
-    (a, b) => a > b ? 1 : -1
-  );
-  let hasProgress = true;
-  while (hasProgress) {
-    hasProgress = false;
-    for (const predecessorIdentifier of keys) {
-      if (resolvedSiblingPredecessors.has(predecessorIdentifier)) continue;
-      const siblings = crListReplica.childrenMap.get(predecessorIdentifier);
-      if (!siblings) continue;
-      if (siblings.length > 1)
-        siblings.sort((a, b) => a.uuidv7 > b.uuidv7 ? 1 : -1);
-      const predecessor = predecessorIdentifier === "\0" ? void 0 : crListReplica.parentMap.get(predecessorIdentifier);
-      if (predecessor && !predecessor.prev && !predecessor.next && crListReplica.cursor !== predecessor)
-        continue;
-      let prev = predecessor ?? crListReplica.cursor;
-      const predecessorNext = predecessor?.next;
-      if (siblings.length === 1) {
-        const sibling = siblings[0];
-        insertBetween(prev, sibling, sibling.next);
-        prev = sibling;
-        if (predecessorNext && predecessorNext !== sibling) {
-          prev.next = predecessorNext;
-          predecessorNext.prev = prev;
-        } else {
-          prev.next = void 0;
-        }
-        if (!predecessorNext) crListReplica.cursor = prev;
-        resolvedSiblingPredecessors.add(predecessorIdentifier);
-        hasProgress = true;
+  let previous = void 0;
+  let first = void 0;
+  let index = 0;
+  const appendChildren = (predecessorIdentifier) => {
+    const siblings = crListReplica.childrenMap.get(predecessorIdentifier);
+    if (!siblings) return;
+    if (siblings.length > 1)
+      void siblings.sort((a, b) => a.uuidv7 > b.uuidv7 ? 1 : -1);
+    for (const sibling of siblings) {
+      if (!sibling || crListReplica.parentMap.get(sibling.uuidv7) !== sibling)
         continue;
-      }
-      const siblingSet = new Set(siblings);
-      for (let index = 0; index < siblings.length; index++) {
-        const sibling = siblings[index];
-        const next = siblings[index + 1];
-        insertBetween(prev, sibling, sibling.next);
-        prev = sibling;
-        if (next) {
-          prev.next = next;
-          next.prev = prev;
-        } else if (predecessorNext && !siblingSet.has(predecessorNext)) {
-          prev.next = predecessorNext;
-          predecessorNext.prev = prev;
-        } else {
-          prev.next = void 0;
-        }
-      }
-      if (!predecessorNext) crListReplica.cursor = prev;
-      resolvedSiblingPredecessors.add(predecessorIdentifier);
-      hasProgress = true;
+      sibling.index = index;
+      index++;
+      void linkEntryBetween(previous, sibling, void 0);
+      if (!first) first = sibling;
+      previous = sibling;
+      void appendChildren(sibling.uuidv7);
     }
-  }
+  };
+  void appendChildren("\0");
+  const detachedPredecessors = [];
+  for (const predecessorIdentifier of crListReplica.childrenMap.keys()) {
+    if (predecessorIdentifier !== "\0" && !crListReplica.parentMap.get(predecessorIdentifier))
+      void detachedPredecessors.push(predecessorIdentifier);
+  }
+  if (detachedPredecessors.length > 1)
+    detachedPredecessors.sort((a, b) => a > b ? 1 : -1);
+  for (const predecessorIdentifier of detachedPredecessors)
+    void appendChildren(predecessorIdentifier);
+  crListReplica.cursor = first;
+  crListReplica.cursorIndex = first ? 0 : void 0;
+  if (first) void entries.set(0, first);
+  crListReplica.index = entries;
   crListReplica.size = crListReplica.parentMap.size;
 }
 
-// src/.helpers/transformSnapshotEntryToStateEntry/index.ts
-import { isUuidV7, safeStructuredClone } from "@sovereignbase/utils";
-function transformSnapshotEntryToStateEntry(valueEntry, crListReplica) {
+// src/.helpers/materializeSnapshotEntry/index.ts
+import { isUuidV7 } from "@sovereignbase/utils";
+function materializeSnapshotEntry(valueEntry, crListReplica) {
   if (valueEntry === null || valueEntry === void 0) return void 0;
   if (!isUuidV7(valueEntry.uuidv7) || crListReplica.tombstones.has(valueEntry.uuidv7) || crListReplica.parentMap.has(valueEntry.uuidv7) || !isUuidV7(valueEntry.predecessor) && valueEntry.predecessor !== "\0" && !crListReplica.tombstones.has(valueEntry.predecessor))
     return void 0;
-  const [cloned, copiedValue] = safeStructuredClone(valueEntry.value);
-  if (!cloned) return void 0;
   return {
     uuidv7: valueEntry.uuidv7,
-    value: copiedValue,
+    value: valueEntry.value,
     predecessor: valueEntry.predecessor,
     index: 0,
     next: void 0,
@@ -152,59 +156,65 @@ function transformSnapshotEntryToStateEntry(valueEntry, crListReplica) {
   };
 }
 
-// src/.helpers/updateEntryToMaps/index.ts
-function updateEntryToMaps(crListReplica, linkedListEntry, deltaBuf) {
-  crListReplica.parentMap.set(linkedListEntry.uuidv7, linkedListEntry);
+// src/.helpers/attachEntryToIndexes/index.ts
+function attachEntryToIndexes(crListReplica, linkedListEntry, deltaBuf) {
+  void crListReplica.parentMap.set(linkedListEntry.uuidv7, linkedListEntry);
   const siblings = crListReplica.childrenMap.get(linkedListEntry.predecessor);
   if (siblings) {
-    siblings.push(linkedListEntry);
+    void siblings.push(linkedListEntry);
   } else {
-    crListReplica.childrenMap.set(linkedListEntry.predecessor, [
+    void crListReplica.childrenMap.set(linkedListEntry.predecessor, [
       linkedListEntry
     ]);
   }
   if (deltaBuf && !Array.isArray(deltaBuf.values)) deltaBuf.values = [];
   if (deltaBuf?.values)
-    deltaBuf.values.push({
+    void deltaBuf.values.push({
       uuidv7: linkedListEntry.uuidv7,
       value: linkedListEntry.value,
       predecessor: linkedListEntry.predecessor
     });
 }
 
-// src/.helpers/deleteEntryFromMaps/index.ts
-function deleteEntryFromMaps(crListReplica, linkedListEntry) {
-  crListReplica.parentMap.delete(linkedListEntry.uuidv7);
+// src/.helpers/detachEntryFromIndexes/index.ts
+function detachEntryFromIndexes(crListReplica, linkedListEntry) {
+  void crListReplica.parentMap.delete(linkedListEntry.uuidv7);
   const siblings = crListReplica.childrenMap.get(linkedListEntry.predecessor);
   if (!siblings) return;
   const index = siblings.indexOf(linkedListEntry);
-  if (index !== -1) siblings.splice(index, 1);
+  if (index !== -1) void siblings.splice(index, 1);
 }
 
-// src/.helpers/deleteLinkedEntry/index.ts
-function deleteLinkedEntry(crListReplica, linkedListEntry, deltaBuf) {
+// src/.helpers/deleteLiveEntry/index.ts
+function deleteLiveEntry(crListReplica, linkedListEntry, deltaBuf) {
   const prev = linkedListEntry.prev;
   const next = linkedListEntry.next;
-  crListReplica.tombstones.add(linkedListEntry.uuidv7);
+  void crListReplica.tombstones.add(linkedListEntry.uuidv7);
   if (deltaBuf && !Array.isArray(deltaBuf.tombstones)) deltaBuf.tombstones = [];
-  deltaBuf?.tombstones?.push(linkedListEntry.uuidv7);
+  void deltaBuf?.tombstones?.push(linkedListEntry.uuidv7);
   if (prev) prev.next = next;
   if (next) {
     next.prev = prev;
   }
-  void deleteEntryFromMaps(crListReplica, linkedListEntry);
+  void detachEntryFromIndexes(crListReplica, linkedListEntry);
   if (crListReplica.cursor === linkedListEntry)
     crListReplica.cursor = next ?? prev;
+  if (!crListReplica.cursor) crListReplica.cursorIndex = void 0;
   linkedListEntry.prev = void 0;
   linkedListEntry.next = void 0;
   crListReplica.size = crListReplica.parentMap.size;
 }
 
+// src/.helpers/dispatchCRListEvent/index.ts
+function dispatchCRListEvent(eventTarget, type, detail) {
+  void eventTarget.dispatchEvent(new CustomEvent(type, { detail }));
+}
+
 // src/.helpers/moveEntryToPredecessor/index.ts
 function moveEntryToPredecessor(crListReplica, linkedListEntry, predecessor, deltaBuf) {
-  void deleteEntryFromMaps(crListReplica, linkedListEntry);
+  void detachEntryFromIndexes(crListReplica, linkedListEntry);
   linkedListEntry.predecessor = predecessor;
-  void updateEntryToMaps(crListReplica, linkedListEntry, deltaBuf);
+  void attachEntryToIndexes(crListReplica, linkedListEntry, deltaBuf);
 }
 
 // src/.helpers/indexFromPropertyKey/index.ts
@@ -221,6 +231,8 @@ function __create(snapshot) {
   const crListReplica = {
     size: 0,
     cursor: void 0,
+    cursorIndex: void 0,
+    index: /* @__PURE__ */ new Map(),
     tombstones: /* @__PURE__ */ new Set(),
     parentMap: /* @__PURE__ */ new Map(),
     childrenMap: /* @__PURE__ */ new Map()
@@ -230,36 +242,50 @@ function __create(snapshot) {
     for (const tombstone of snapshot.tombstones) {
       if (crListReplica.tombstones.has(tombstone) || !isUuidV72(tombstone))
         continue;
-      crListReplica.tombstones.add(tombstone);
+      void crListReplica.tombstones.add(tombstone);
     }
   }
   if (!Object.hasOwn(snapshot, "values") || !Array.isArray(snapshot.values))
     return crListReplica;
+  let canUseLinearProjection = true;
+  let previous = void 0;
   for (const valueEntry of snapshot.values) {
-    const linkedListEntry = transformSnapshotEntryToStateEntry(
+    const linkedListEntry = materializeSnapshotEntry(
       valueEntry,
       crListReplica
     );
     if (!linkedListEntry) continue;
-    void updateEntryToMaps(crListReplica, linkedListEntry);
+    void attachEntryToIndexes(crListReplica, linkedListEntry);
+    if (canUseLinearProjection && linkedListEntry.predecessor === (previous?.uuidv7 ?? "\0")) {
+      linkedListEntry.index = crListReplica.parentMap.size - 1;
+      void linkEntryBetween(previous, linkedListEntry, void 0);
+      previous = linkedListEntry;
+      void crListReplica.index?.set(linkedListEntry.index, linkedListEntry);
+      continue;
+    }
+    canUseLinearProjection = false;
+  }
+  if (canUseLinearProjection) {
+    crListReplica.cursor = previous;
+    crListReplica.cursorIndex = previous ? crListReplica.parentMap.size - 1 : void 0;
+    crListReplica.size = crListReplica.parentMap.size;
+    return crListReplica;
   }
-  void flattenAndLinkTrustedState(crListReplica);
-  void assertListIndices(crListReplica);
+  void rebuildLiveProjection(crListReplica);
   return crListReplica;
 }
 
 // src/core/crud/read/index.ts
 function __read(targetIndex, crListReplica) {
   try {
-    void walkToIndex(targetIndex, crListReplica);
-    return structuredClone(crListReplica?.cursor?.value);
+    void seekCursorToIndex(targetIndex, crListReplica);
+    return crListReplica.cursor?.value;
   } catch {
     return void 0;
   }
 }
 
 // src/core/crud/update/index.ts
-import { safeStructuredClone as safeStructuredClone2 } from "@sovereignbase/utils";
 import { v7 as uuidv7 } from "uuid";
 function __update(listIndex, listValues, crListReplica, mode) {
   if (listIndex < 0 || listIndex > crListReplica.size)
@@ -272,14 +298,11 @@ function __update(listIndex, listValues, crListReplica, mode) {
   if (listValues.length === 0) return false;
   const change = {};
   const delta = { values: [], tombstones: [] };
-  let shiftCursor;
   for (const listValue of listValues) {
-    const [cloned, copiedValue] = safeStructuredClone2(listValue);
-    if (!cloned) throw new CRListError("VALUE_NOT_CLONEABLE");
     const v7 = uuidv7();
     const linkedListEntry = {
       uuidv7: v7,
-      value: copiedValue,
+      value: listValue,
       predecessor: "\0",
       index: 0,
       next: void 0,
@@ -290,26 +313,35 @@ function __update(listIndex, listValues, crListReplica, mode) {
         if (listIndex === crListReplica.size) {
           if (crListReplica.size === 0) {
             crListReplica.cursor = linkedListEntry;
-            void updateEntryToMaps(crListReplica, linkedListEntry, delta);
+            crListReplica.cursorIndex = linkedListEntry.index;
+            void attachEntryToIndexes(crListReplica, linkedListEntry, delta);
+            crListReplica.index?.set(linkedListEntry.index, linkedListEntry);
             change[linkedListEntry.index] = linkedListEntry.value;
             break;
           }
-          void walkToIndex(crListReplica.size - 1, crListReplica);
+          void seekCursorToIndex(crListReplica.size - 1, crListReplica);
           if (!crListReplica.cursor) return false;
-          linkedListEntry.index = crListReplica.cursor.index + 1;
+          linkedListEntry.index = (crListReplica.cursorIndex ?? 0) + 1;
           linkedListEntry.predecessor = crListReplica.cursor.uuidv7;
-          insertBetween(crListReplica.cursor, linkedListEntry, void 0);
-          void updateEntryToMaps(crListReplica, linkedListEntry, delta);
+          void linkEntryBetween(
+            crListReplica.cursor,
+            linkedListEntry,
+            void 0
+          );
+          void attachEntryToIndexes(crListReplica, linkedListEntry, delta);
           crListReplica.cursor = linkedListEntry;
-          change[linkedListEntry.index] = structuredClone(linkedListEntry.value);
+          crListReplica.cursorIndex = linkedListEntry.index;
+          void crListReplica.index?.set(linkedListEntry.index, linkedListEntry);
+          change[linkedListEntry.index] = linkedListEntry.value;
           break;
         }
-        void walkToIndex(listIndex, crListReplica);
+        void seekCursorToIndex(listIndex, crListReplica);
         if (!crListReplica.cursor) return false;
         const entryToOverwrite = crListReplica.cursor;
+        const actualIndex = crListReplica.cursorIndex ?? listIndex;
         linkedListEntry.predecessor = entryToOverwrite.predecessor;
-        linkedListEntry.index = entryToOverwrite.index;
-        insertBetween(
+        linkedListEntry.index = actualIndex;
+        void linkEntryBetween(
           entryToOverwrite.prev,
           linkedListEntry,
           entryToOverwrite.next
@@ -324,34 +356,38 @@ function __update(listIndex, listValues, crListReplica, mode) {
             );
           }
         }
-        void updateEntryToMaps(crListReplica, linkedListEntry, delta);
-        crListReplica.tombstones.add(entryToOverwrite.uuidv7);
-        delta.tombstones?.push(entryToOverwrite.uuidv7);
-        void deleteEntryFromMaps(crListReplica, entryToOverwrite);
+        void attachEntryToIndexes(crListReplica, linkedListEntry, delta);
+        void crListReplica.tombstones.add(entryToOverwrite.uuidv7);
+        void delta.tombstones?.push(entryToOverwrite.uuidv7);
+        void detachEntryFromIndexes(crListReplica, entryToOverwrite);
         entryToOverwrite.next = void 0;
         entryToOverwrite.prev = void 0;
         crListReplica.cursor = linkedListEntry;
-        change[linkedListEntry.index] = structuredClone(linkedListEntry.value);
+        crListReplica.cursorIndex = actualIndex;
+        void crListReplica.index?.set(linkedListEntry.index, linkedListEntry);
+        change[actualIndex] = linkedListEntry.value;
         break;
       }
       case "after": {
         if (crListReplica.size === 0 && listIndex === 0) {
           crListReplica.cursor = linkedListEntry;
-          void updateEntryToMaps(crListReplica, linkedListEntry, delta);
-          change[linkedListEntry.index] = structuredClone(linkedListEntry.value);
+          crListReplica.cursorIndex = linkedListEntry.index;
+          void attachEntryToIndexes(crListReplica, linkedListEntry, delta);
+          void crListReplica.index?.set(linkedListEntry.index, linkedListEntry);
+          change[linkedListEntry.index] = linkedListEntry.value;
           break;
         }
         if (listIndex === crListReplica.size) {
-          void walkToIndex(crListReplica.size - 1, crListReplica);
+          void seekCursorToIndex(crListReplica.size - 1, crListReplica);
         } else {
-          void walkToIndex(listIndex, crListReplica);
+          void seekCursorToIndex(listIndex, crListReplica);
         }
         if (!crListReplica.cursor) return false;
+        const actualIndex = crListReplica.cursorIndex ?? listIndex;
         const next = listIndex === crListReplica.size ? void 0 : crListReplica.cursor.next;
-        shiftCursor = next;
-        linkedListEntry.index = crListReplica.cursor.index + 1;
+        linkedListEntry.index = actualIndex + 1;
         linkedListEntry.predecessor = crListReplica.cursor.uuidv7;
-        insertBetween(crListReplica.cursor, linkedListEntry, next);
+        void linkEntryBetween(crListReplica.cursor, linkedListEntry, next);
         if (next) {
           if (next.predecessor === crListReplica.cursor.uuidv7) {
             void moveEntryToPredecessor(
@@ -362,27 +398,32 @@ function __update(listIndex, listValues, crListReplica, mode) {
             );
           }
         }
-        void updateEntryToMaps(crListReplica, linkedListEntry, delta);
+        void attachEntryToIndexes(crListReplica, linkedListEntry, delta);
         crListReplica.cursor = linkedListEntry;
-        change[linkedListEntry.index] = structuredClone(linkedListEntry.value);
+        crListReplica.cursorIndex = linkedListEntry.index;
+        if (next) crListReplica.index = /* @__PURE__ */ new Map();
+        void crListReplica.index?.set(linkedListEntry.index, linkedListEntry);
+        change[linkedListEntry.index] = linkedListEntry.value;
         break;
       }
       case "before": {
         if (crListReplica.size === 0 && listIndex === 0) {
           crListReplica.cursor = linkedListEntry;
-          void updateEntryToMaps(crListReplica, linkedListEntry, delta);
-          change[linkedListEntry.index] = structuredClone(linkedListEntry.value);
+          crListReplica.cursorIndex = linkedListEntry.index;
+          void attachEntryToIndexes(crListReplica, linkedListEntry, delta);
+          void crListReplica.index?.set(linkedListEntry.index, linkedListEntry);
+          change[linkedListEntry.index] = linkedListEntry.value;
           mode = "after";
           listIndex = linkedListEntry.index - 1;
           break;
         }
-        void walkToIndex(listIndex, crListReplica);
+        void seekCursorToIndex(listIndex, crListReplica);
         if (!crListReplica.cursor) return false;
+        const actualIndex = crListReplica.cursorIndex ?? listIndex;
         const prev = crListReplica.cursor.prev;
-        shiftCursor = crListReplica.cursor;
-        linkedListEntry.index = crListReplica.cursor.index;
+        linkedListEntry.index = actualIndex;
         linkedListEntry.predecessor = prev?.uuidv7 ?? "\0";
-        insertBetween(prev, linkedListEntry, crListReplica.cursor);
+        void linkEntryBetween(prev, linkedListEntry, crListReplica.cursor);
         if (crListReplica.cursor.predecessor === linkedListEntry.predecessor) {
           void moveEntryToPredecessor(
             crListReplica,
@@ -391,9 +432,12 @@ function __update(listIndex, listValues, crListReplica, mode) {
             delta
           );
         }
-        void updateEntryToMaps(crListReplica, linkedListEntry, delta);
+        void attachEntryToIndexes(crListReplica, linkedListEntry, delta);
         crListReplica.cursor = linkedListEntry;
-        change[linkedListEntry.index] = structuredClone(linkedListEntry.value);
+        crListReplica.cursorIndex = actualIndex;
+        crListReplica.index = /* @__PURE__ */ new Map();
+        void crListReplica.index?.set(linkedListEntry.index, linkedListEntry);
+        change[actualIndex] = linkedListEntry.value;
         mode = "after";
         listIndex = linkedListEntry.index - 1;
         break;
@@ -402,11 +446,6 @@ function __update(listIndex, listValues, crListReplica, mode) {
     crListReplica.size = crListReplica.parentMap.size;
     listIndex++;
   }
-  if (mode !== "overwrite")
-    while (shiftCursor) {
-      shiftCursor.index += listValues.length;
-      shiftCursor = shiftCursor.next;
-    }
   return { change, delta };
 }
 
@@ -420,22 +459,29 @@ function __delete(crListReplica, startIndex, endIndex) {
     throw new CRListError("INDEX_OUT_OF_BOUNDS");
   const deleteCount = Math.min(targetEndIndex, crListReplica.size) - listIndex;
   if (deleteCount <= 0) return false;
-  void walkToIndex(listIndex, crListReplica);
+  void seekCursorToIndex(listIndex, crListReplica);
   if (!crListReplica.cursor) return false;
   let current = crListReplica.cursor;
   let deleted = 0;
+  let currentIndex = crListReplica.cursorIndex ?? listIndex;
   while (current && deleted < deleteCount) {
     const next = current.next;
-    change[current.index] = void 0;
-    void deleteLinkedEntry(crListReplica, current, delta);
+    change[currentIndex] = void 0;
+    void crListReplica.index?.delete(currentIndex);
+    void deleteLiveEntry(crListReplica, current, delta);
     current = next;
+    currentIndex++;
     deleted++;
   }
   crListReplica.size = crListReplica.parentMap.size;
-  while (current) {
-    current.index -= deleted;
-    current = current.next;
-  }
+  crListReplica.cursor = current ?? crListReplica.cursor;
+  crListReplica.cursorIndex = current ? listIndex : crListReplica.cursor ? Math.max(0, crListReplica.size - 1) : void 0;
+  crListReplica.index = /* @__PURE__ */ new Map();
+  if (crListReplica.cursor && crListReplica.cursorIndex !== void 0)
+    void crListReplica.index.set(
+      crListReplica.cursorIndex,
+      crListReplica.cursor
+    );
   return { change, delta };
 }
 
@@ -447,22 +493,42 @@ function __merge(crListReplica, crListDelta) {
   const newTombsIndices = [];
   const change = {};
   let needsRelink = false;
+  if (Object.hasOwn(crListDelta, "values") && Array.isArray(crListDelta.values) && crListDelta.values.length === 1 && (!Object.hasOwn(crListDelta, "tombstones") || Array.isArray(crListDelta.tombstones) && crListDelta.tombstones.length === 0)) {
+    const linkedListEntry = materializeSnapshotEntry(
+      crListDelta.values[0],
+      crListReplica
+    );
+    if (!linkedListEntry) return false;
+    const predecessor = linkedListEntry.predecessor === "\0" ? void 0 : crListReplica.parentMap.get(linkedListEntry.predecessor);
+    if (linkedListEntry.predecessor === "\0" && crListReplica.size === 0 || predecessor && !predecessor.next) {
+      linkedListEntry.prev = predecessor;
+      linkedListEntry.index = crListReplica.size;
+      if (predecessor) predecessor.next = linkedListEntry;
+      crListReplica.cursor = linkedListEntry;
+      crListReplica.cursorIndex = linkedListEntry.index;
+      void attachEntryToIndexes(crListReplica, linkedListEntry);
+      crListReplica.size = crListReplica.parentMap.size;
+      void crListReplica.index?.set(linkedListEntry.index, linkedListEntry);
+      return { [linkedListEntry.index]: linkedListEntry.value };
+    }
+  }
   if (Object.hasOwn(crListDelta, "tombstones") && Array.isArray(crListDelta.tombstones)) {
     for (const tombstone of crListDelta.tombstones) {
       if (crListReplica.tombstones.has(tombstone) || !isUuidV73(tombstone))
         continue;
-      crListReplica.tombstones.add(tombstone);
+      void crListReplica.tombstones.add(tombstone);
       const linkedListEntry = crListReplica.parentMap.get(tombstone);
       if (linkedListEntry) {
         void newTombsIndices.push(linkedListEntry.index);
-        void deleteLinkedEntry(crListReplica, linkedListEntry);
+        void crListReplica.index?.delete(linkedListEntry.index);
+        void deleteLiveEntry(crListReplica, linkedListEntry);
         needsRelink = true;
       }
     }
   }
   if (!Object.hasOwn(crListDelta, "values") || !Array.isArray(crListDelta.values)) {
     if (newTombsIndices.length === 0) return false;
-    void assertListIndices(crListReplica);
+    void rebuildLiveIndex(crListReplica);
     for (const index of newTombsIndices) {
       change[index] = void 0;
     }
@@ -472,7 +538,8 @@ function __merge(crListReplica, crListDelta) {
     if (valueEntry === null || valueEntry === void 0) continue;
     const existingEntry = crListReplica.parentMap.get(valueEntry.uuidv7);
     if (existingEntry) {
-      if (crListReplica.tombstones.has(valueEntry.uuidv7) || !isUuidV73(valueEntry.predecessor) && valueEntry.predecessor !== "\0")
+      if (crListReplica.tombstones.has(valueEntry.uuidv7)) continue;
+      if (valueEntry.predecessor !== "\0" && !isUuidV73(valueEntry.predecessor))
         continue;
       if (existingEntry.predecessor >= valueEntry.predecessor) continue;
       void moveEntryToPredecessor(
@@ -483,41 +550,44 @@ function __merge(crListReplica, crListDelta) {
       needsRelink = true;
       continue;
     }
-    const linkedListEntry = transformSnapshotEntryToStateEntry(
+    const linkedListEntry = materializeSnapshotEntry(
       valueEntry,
       crListReplica
     );
     if (!linkedListEntry) continue;
     const predecessor = linkedListEntry.predecessor === "\0" ? void 0 : crListReplica.parentMap.get(linkedListEntry.predecessor);
-    void updateEntryToMaps(crListReplica, linkedListEntry);
+    void attachEntryToIndexes(crListReplica, linkedListEntry);
     void newVals.push(linkedListEntry);
     if (!needsRelink && linkedListEntry.predecessor === "\0") {
       if (crListReplica.size === 0) {
         crListReplica.cursor = linkedListEntry;
+        crListReplica.cursorIndex = linkedListEntry.index;
         crListReplica.size = crListReplica.parentMap.size;
+        void crListReplica.index?.set(linkedListEntry.index, linkedListEntry);
       } else {
         needsRelink = true;
       }
     } else if (!needsRelink && predecessor && !predecessor.next) {
       linkedListEntry.prev = predecessor;
-      linkedListEntry.index = predecessor.index + 1;
+      linkedListEntry.index = crListReplica.size;
       predecessor.next = linkedListEntry;
       crListReplica.cursor = linkedListEntry;
+      crListReplica.cursorIndex = linkedListEntry.index;
       crListReplica.size = crListReplica.parentMap.size;
+      void crListReplica.index?.set(linkedListEntry.index, linkedListEntry);
     } else {
       needsRelink = true;
     }
   }
   if (needsRelink) {
-    void flattenAndLinkTrustedState(crListReplica);
-    void assertListIndices(crListReplica);
+    void rebuildLiveProjection(crListReplica);
   }
   if (newTombsIndices.length === 0 && newVals.length === 0) return false;
   for (const index of newTombsIndices) {
     change[index] = void 0;
   }
   for (const val of newVals) {
-    change[val.index] = structuredClone(val.value);
+    change[val.index] = val.value;
   }
   return change;
 }
@@ -525,7 +595,7 @@ function __merge(crListReplica, crListDelta) {
 // src/core/mags/acknowledge/index.ts
 function __acknowledge(crListReplica) {
   let largest = false;
-  crListReplica.tombstones.forEach((tombstone) => {
+  void crListReplica.tombstones.forEach((tombstone) => {
     if (largest === false || largest < tombstone) largest = tombstone;
   });
   if (typeof largest === "string") return largest;
@@ -536,12 +606,12 @@ function __acknowledge(crListReplica) {
 import { isUuidV7 as isUuidV74 } from "@sovereignbase/utils";
 function __garbageCollect(frontiers, crListReplica) {
   if (!Array.isArray(frontiers)) return;
-  frontiers.sort();
+  void frontiers.sort();
   const smallest = frontiers.find((frontier) => isUuidV74(frontier));
   if (typeof smallest !== "string") return;
-  crListReplica.tombstones.forEach((tombstone, __, tombstones) => {
+  void crListReplica.tombstones.forEach((tombstone, __, tombstones) => {
     if (tombstone <= smallest) {
-      tombstones.delete(tombstone);
+      void tombstones.delete(tombstone);
     }
   });
 }
@@ -554,7 +624,7 @@ function __snapshot(crListReplica) {
         if (!linkedListEntry) throw new CRListError("LIST_INTEGRITY_VIOLATION");
         return {
           uuidv7: linkedListEntry.uuidv7,
-          value: structuredClone(linkedListEntry.value),
+          value: linkedListEntry.value,
           predecessor: linkedListEntry.predecessor
         };
       }
@@ -566,12 +636,12 @@ function __snapshot(crListReplica) {
 // src/CRList/class.ts
 var CRList = class {
   /**
-   * Creates a replicated list from an optional detached structured-clone-compatible snapshot.
+   * Creates a replicated list from an optional CRList snapshot.
    *
    * @param snapshot - A previously emitted CRList snapshot.
    */
   constructor(snapshot) {
-    Object.defineProperties(this, {
+    void Object.defineProperties(this, {
       state: {
         value: __create(snapshot),
         enumerable: false,
@@ -604,13 +674,9 @@ var CRList = class {
           if (!result) return false;
           const { delta, change } = result;
           if (delta)
-            void target.eventTarget.dispatchEvent(
-              new CustomEvent("delta", { detail: delta })
-            );
+            void dispatchCRListEvent(target.eventTarget, "delta", delta);
           if (change)
-            void target.eventTarget.dispatchEvent(
-              new CustomEvent("change", { detail: change })
-            );
+            void dispatchCRListEvent(target.eventTarget, "change", change);
           return true;
         } catch (error) {
           if (error instanceof CRListError) throw error;
@@ -624,16 +690,10 @@ var CRList = class {
           const result = __delete(target.state, listIndex, listIndex + 1);
           if (!result) return false;
           const { delta, change } = result;
-          if (delta) {
-            void target.eventTarget.dispatchEvent(
-              new CustomEvent("delta", { detail: delta })
-            );
-          }
-          if (change) {
-            void target.eventTarget.dispatchEvent(
-              new CustomEvent("change", { detail: change })
-            );
-          }
+          if (delta)
+            void dispatchCRListEvent(target.eventTarget, "delta", delta);
+          if (change)
+            void dispatchCRListEvent(target.eventTarget, "change", change);
           return true;
         } catch (error) {
           if (error instanceof CRListError) throw error;
@@ -678,14 +738,8 @@ var CRList = class {
     const result = __update(beforeIndex ?? 0, [value], this.state, "before");
     if (!result) return;
     const { delta, change } = result;
-    if (delta)
-      void this.eventTarget.dispatchEvent(
-        new CustomEvent("delta", { detail: delta })
-      );
-    if (change)
-      void this.eventTarget.dispatchEvent(
-        new CustomEvent("change", { detail: change })
-      );
+    if (delta) void dispatchCRListEvent(this.eventTarget, "delta", delta);
+    if (change) void dispatchCRListEvent(this.eventTarget, "change", change);
   }
   /**
    * Inserts a value after an index.
@@ -704,14 +758,8 @@ var CRList = class {
     );
     if (!result) return;
     const { delta, change } = result;
-    if (delta)
-      void this.eventTarget.dispatchEvent(
-        new CustomEvent("delta", { detail: delta })
-      );
-    if (change)
-      void this.eventTarget.dispatchEvent(
-        new CustomEvent("change", { detail: change })
-      );
+    if (delta) void dispatchCRListEvent(this.eventTarget, "delta", delta);
+    if (change) void dispatchCRListEvent(this.eventTarget, "change", change);
   }
   /**
    * Removes the entry at an index.
@@ -722,28 +770,26 @@ var CRList = class {
     const result = __delete(this.state, index, index + 1);
     if (!result) return;
     const { delta, change } = result;
-    if (delta)
-      void this.eventTarget.dispatchEvent(
-        new CustomEvent("delta", { detail: delta })
-      );
-    if (change)
-      void this.eventTarget.dispatchEvent(
-        new CustomEvent("change", { detail: change })
-      );
+    if (delta) void dispatchCRListEvent(this.eventTarget, "delta", delta);
+    if (change) void dispatchCRListEvent(this.eventTarget, "change", change);
   }
   /**
-   * Returns the first live value copy matching a predicate in index order.
+   * Returns the first live value matching a predicate in index order.
    *
-   * Predicate values are detached copies, so mutating them does not mutate the
-   * list.
+   * Predicate values are live references. Mutating them directly can mutate the
+   * list without emitting a delta.
    *
-   * @param predicate - Function to test each value copy.
+   * @param predicate - Function to test each live value.
    * @param thisArg - Optional `this` value for the predicate.
    */
   find(predicate, thisArg) {
+    let linkedListEntry = this.state.index?.get(0) ?? this.state.cursor;
+    while (linkedListEntry?.prev) linkedListEntry = linkedListEntry.prev;
     let index = 0;
-    for (const value of this) {
-      if (predicate.call(thisArg, value, index, this)) return value;
+    while (linkedListEntry) {
+      if (predicate.call(thisArg, linkedListEntry.value, index, this))
+        return linkedListEntry.value;
+      linkedListEntry = linkedListEntry.next;
       index++;
     }
     return void 0;
@@ -757,20 +803,14 @@ var CRList = class {
    */
   merge(delta) {
     const change = __merge(this.state, delta);
-    if (change)
-      void this.eventTarget.dispatchEvent(
-        new CustomEvent("change", { detail: change })
-      );
+    if (change) void dispatchCRListEvent(this.eventTarget, "change", change);
   }
   /**
    * Emits an acknowledgement frontier for currently retained tombstones.
    */
   acknowledge() {
     const ack = __acknowledge(this.state);
-    if (ack)
-      void this.eventTarget.dispatchEvent(
-        new CustomEvent("ack", { detail: ack })
-      );
+    if (ack) void dispatchCRListEvent(this.eventTarget, "ack", ack);
   }
   /**
    * Garbage-collects tombstones that are covered by acknowledgement frontiers.
@@ -781,14 +821,15 @@ var CRList = class {
     void __garbageCollect(frontiers, this.state);
   }
   /**
-   * Emits the current detached structured-clone-compatible list snapshot.
+   * Emits the current CRList snapshot.
+   *
+   * Snapshot value payloads are live references. Mutating them can mutate
+   * replica state without emitting a delta.
    */
   snapshot() {
     const snapshot = __snapshot(this.state);
     if (snapshot)
-      void this.eventTarget.dispatchEvent(
-        new CustomEvent("snapshot", { detail: snapshot })
-      );
+      void dispatchCRListEvent(this.eventTarget, "snapshot", snapshot);
   }
   /**
    * Registers an event listener.
@@ -798,7 +839,7 @@ var CRList = class {
    * @param options - Listener registration options.
    */
   addEventListener(type, listener, options) {
-    this.eventTarget.addEventListener(
+    void this.eventTarget.addEventListener(
       type,
       listener,
       options
@@ -812,14 +853,17 @@ var CRList = class {
    * @param options - Listener removal options.
    */
   removeEventListener(type, listener, options) {
-    this.eventTarget.removeEventListener(
+    void this.eventTarget.removeEventListener(
       type,
       listener,
       options
     );
   }
   /**
-   * Returns a detached structured-clone-compatible snapshot of this list.
+   * Returns a CRList snapshot of this list.
+   *
+   * Snapshot value payloads are live references. Mutating them can mutate
+   * replica state without emitting a delta.
    *
    * Called automatically by `JSON.stringify`.
    */
@@ -847,7 +891,7 @@ var CRList = class {
     return this.toJSON();
   }
   /**
-   * Iterates over detached copies of the current live values in index order.
+   * Iterates over current live values in index order.
    */
   *[Symbol.iterator]() {
     for (let index = 0; index < this.size; index++) {
@@ -856,17 +900,17 @@ var CRList = class {
     }
   }
   /**
-   * Calls a function once for each live value copy in index order.
+   * Calls a function once for each live value in index order.
    *
-   * Callback values are detached copies, so mutating them does not mutate the
-   * list.
+   * Callback values are live references. Mutating them directly can mutate the
+   * list without emitting a delta.
    *
-   * @param callback - Function to call for each value copy.
+   * @param callback - Function to call for each live value.
    * @param thisArg - Optional `this` value for the callback.
    */
   forEach(callback, thisArg) {
     for (let index = 0; index < this.size; index++) {
-      callback.call(thisArg, this[index], index, this);
+      void callback.call(thisArg, this[index], index, this);
     }
   }
 };