@sovereignbase/convergent-replicated-list 0.0.0

package/dist/index.js

@@ -0,0 +1,859 @@
+/*
+ * Copyright 2026 Sovereignbase
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+// src/core/crud/create/index.ts
+import { isUuidV7 as isUuidV72, prototype } from "@sovereignbase/utils";
+
+// src/.helpers/assertListIndices/index.ts
+function assertListIndices(crListReplica) {
+  if (!crListReplica.cursor) return;
+  let index = crListReplica.size;
+  while (crListReplica.cursor.next)
+    crListReplica.cursor = crListReplica.cursor.next;
+  while (index >= 1) {
+    index--;
+    crListReplica.cursor.index = index;
+    if (crListReplica.cursor.prev === void 0) break;
+    crListReplica.cursor = crListReplica.cursor.prev;
+  }
+}
+
+// src/.errors/class.ts
+var CRListError = class extends Error {
+  /**
+   * The semantic error code for the failure.
+   */
+  code;
+  /**
+   * Creates a typed CRList error.
+   *
+   * @param code - The semantic error code.
+   * @param message - An optional human-readable detail message.
+   */
+  constructor(code, message) {
+    const detail = message ?? code;
+    super(`{@sovereignbase/convergent-replicated-list} ${detail}`);
+    this.code = code;
+    this.name = "CRListError";
+  }
+};
+
+// src/.helpers/walkToIndex/index.ts
+function walkToIndex(targetIndex, crListReplica) {
+  if (targetIndex < 0 || targetIndex >= crListReplica.size)
+    throw new CRListError("INDEX_OUT_OF_BOUNDS", "Index out of bounds");
+  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) {
+    crListReplica.cursor = crListReplica.cursor[direction];
+  }
+}
+
+// src/.helpers/insertBetween/index.ts
+function insertBetween(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) {
+  crListReplica.cursor = void 0;
+  const resolvedSiblingPredecessors = /* @__PURE__ */ new Set();
+  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;
+        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;
+    }
+  }
+  crListReplica.size = crListReplica.parentMap.size;
+}
+
+// src/.helpers/snapshotValueToLinkedListValue/index.ts
+import { isUuidV7, safeStructuredClone } from "@sovereignbase/utils";
+function snapshotValueToLinkedListValue(valueEntry, crListReplica) {
+  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,
+    predecessor: valueEntry.predecessor,
+    index: 0,
+    next: void 0,
+    prev: void 0
+  };
+}
+
+// src/.helpers/updateEntryToMaps/index.ts
+function updateEntryToMaps(crListReplica, linkedListEntry, deltaBuf) {
+  crListReplica.parentMap.set(linkedListEntry.uuidv7, linkedListEntry);
+  const siblings = crListReplica.childrenMap.get(linkedListEntry.predecessor);
+  if (siblings) {
+    siblings.push(linkedListEntry);
+  } else {
+    crListReplica.childrenMap.set(linkedListEntry.predecessor, [
+      linkedListEntry
+    ]);
+  }
+  if (deltaBuf && !Array.isArray(deltaBuf.values)) deltaBuf.values = [];
+  if (deltaBuf?.values)
+    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);
+  const siblings = crListReplica.childrenMap.get(linkedListEntry.predecessor);
+  if (!siblings) return;
+  const index = siblings.indexOf(linkedListEntry);
+  if (index !== -1) siblings.splice(index, 1);
+}
+
+// src/.helpers/deleteLinkedEntry/index.ts
+function deleteLinkedEntry(crListReplica, linkedListEntry, deltaBuf) {
+  const prev = linkedListEntry.prev;
+  const next = linkedListEntry.next;
+  crListReplica.tombstones.add(linkedListEntry.uuidv7);
+  if (deltaBuf && !Array.isArray(deltaBuf.tombstones)) deltaBuf.tombstones = [];
+  deltaBuf?.tombstones?.push(linkedListEntry.uuidv7);
+  if (prev) prev.next = next;
+  if (next) {
+    next.prev = prev;
+  }
+  void deleteEntryFromMaps(crListReplica, linkedListEntry);
+  if (crListReplica.cursor === linkedListEntry)
+    crListReplica.cursor = next ?? prev;
+  linkedListEntry.prev = void 0;
+  linkedListEntry.next = void 0;
+  crListReplica.size = crListReplica.parentMap.size;
+}
+
+// src/.helpers/moveEntryToPredecessor/index.ts
+function moveEntryToPredecessor(crListReplica, linkedListEntry, predecessor, deltaBuf) {
+  void deleteEntryFromMaps(crListReplica, linkedListEntry);
+  linkedListEntry.predecessor = predecessor;
+  void updateEntryToMaps(crListReplica, linkedListEntry, deltaBuf);
+}
+
+// src/.helpers/indexFromPropertyKey/index.ts
+function indexFromPropertyKey(index) {
+  if (typeof index !== "string" || !/^(0|[1-9]\d*)$/.test(index))
+    return void 0;
+  const listIndex = Number(index);
+  return Number.isSafeInteger(listIndex) ? listIndex : void 0;
+}
+
+// src/core/crud/create/index.ts
+function __create(snapshot) {
+  const crListReplica = {
+    size: 0,
+    cursor: void 0,
+    tombstones: /* @__PURE__ */ new Set(),
+    parentMap: /* @__PURE__ */ new Map(),
+    childrenMap: /* @__PURE__ */ new Map()
+  };
+  if (!snapshot || prototype(snapshot) !== "record") return crListReplica;
+  if (Object.hasOwn(snapshot, "tombstones") && Array.isArray(snapshot.tombstones)) {
+    for (const tombstone of snapshot.tombstones) {
+      if (crListReplica.tombstones.has(tombstone) || !isUuidV72(tombstone))
+        continue;
+      crListReplica.tombstones.add(tombstone);
+    }
+  }
+  if (!Object.hasOwn(snapshot, "values") || !Array.isArray(snapshot.values))
+    return crListReplica;
+  for (const valueEntry of snapshot.values) {
+    const linkedListEntry = snapshotValueToLinkedListValue(
+      valueEntry,
+      crListReplica
+    );
+    if (!linkedListEntry) continue;
+    void updateEntryToMaps(crListReplica, linkedListEntry);
+  }
+  void flattenAndLinkTrustedState(crListReplica);
+  void assertListIndices(crListReplica);
+  return crListReplica;
+}
+
+// src/core/crud/read/index.ts
+function __read(targetIndex, crListReplica) {
+  try {
+    void walkToIndex(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)
+    throw new CRListError("INDEX_OUT_OF_BOUNDS");
+  if (!Array.isArray(listValues))
+    throw new CRListError(
+      "UPDATE_EXPECTED_AN_ARRAY",
+      "`listValues` must be an Array"
+    );
+  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,
+      predecessor: "\0",
+      index: 0,
+      next: void 0,
+      prev: void 0
+    };
+    switch (mode) {
+      case "overwrite": {
+        if (listIndex === crListReplica.size) {
+          if (crListReplica.size === 0) {
+            crListReplica.cursor = linkedListEntry;
+            void updateEntryToMaps(crListReplica, linkedListEntry, delta);
+            change[linkedListEntry.index] = linkedListEntry.value;
+            break;
+          }
+          void walkToIndex(crListReplica.size - 1, crListReplica);
+          if (!crListReplica.cursor) return false;
+          linkedListEntry.index = crListReplica.cursor.index + 1;
+          linkedListEntry.predecessor = crListReplica.cursor.uuidv7;
+          insertBetween(crListReplica.cursor, linkedListEntry, void 0);
+          void updateEntryToMaps(crListReplica, linkedListEntry, delta);
+          crListReplica.cursor = linkedListEntry;
+          change[linkedListEntry.index] = linkedListEntry.value;
+          break;
+        }
+        void walkToIndex(listIndex, crListReplica);
+        if (!crListReplica.cursor) return false;
+        const entryToOverwrite = crListReplica.cursor;
+        linkedListEntry.predecessor = entryToOverwrite.predecessor;
+        linkedListEntry.index = entryToOverwrite.index;
+        insertBetween(
+          entryToOverwrite.prev,
+          linkedListEntry,
+          entryToOverwrite.next
+        );
+        if (entryToOverwrite.next) {
+          if (entryToOverwrite.next.predecessor === entryToOverwrite.uuidv7) {
+            void moveEntryToPredecessor(
+              crListReplica,
+              entryToOverwrite.next,
+              linkedListEntry.uuidv7,
+              delta
+            );
+          }
+        }
+        void updateEntryToMaps(crListReplica, linkedListEntry, delta);
+        crListReplica.tombstones.add(entryToOverwrite.uuidv7);
+        delta.tombstones?.push(entryToOverwrite.uuidv7);
+        void deleteEntryFromMaps(crListReplica, entryToOverwrite);
+        entryToOverwrite.next = void 0;
+        entryToOverwrite.prev = void 0;
+        crListReplica.cursor = linkedListEntry;
+        change[linkedListEntry.index] = linkedListEntry.value;
+        break;
+      }
+      case "after": {
+        if (crListReplica.size === 0 && listIndex === 0) {
+          crListReplica.cursor = linkedListEntry;
+          void updateEntryToMaps(crListReplica, linkedListEntry, delta);
+          change[linkedListEntry.index] = linkedListEntry.value;
+          break;
+        }
+        if (listIndex === crListReplica.size) {
+          void walkToIndex(crListReplica.size - 1, crListReplica);
+        } else {
+          void walkToIndex(listIndex, crListReplica);
+        }
+        if (!crListReplica.cursor) return false;
+        const next = listIndex === crListReplica.size ? void 0 : crListReplica.cursor.next;
+        shiftCursor = next;
+        linkedListEntry.index = crListReplica.cursor.index + 1;
+        linkedListEntry.predecessor = crListReplica.cursor.uuidv7;
+        insertBetween(crListReplica.cursor, linkedListEntry, next);
+        if (next) {
+          if (next.predecessor === crListReplica.cursor.uuidv7) {
+            void moveEntryToPredecessor(
+              crListReplica,
+              next,
+              linkedListEntry.uuidv7,
+              delta
+            );
+          }
+        }
+        void updateEntryToMaps(crListReplica, linkedListEntry, delta);
+        crListReplica.cursor = 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] = linkedListEntry.value;
+          mode = "after";
+          listIndex = linkedListEntry.index - 1;
+          break;
+        }
+        void walkToIndex(listIndex, crListReplica);
+        if (!crListReplica.cursor) return false;
+        const prev = crListReplica.cursor.prev;
+        shiftCursor = crListReplica.cursor;
+        linkedListEntry.index = crListReplica.cursor.index;
+        linkedListEntry.predecessor = prev?.uuidv7 ?? "\0";
+        insertBetween(prev, linkedListEntry, crListReplica.cursor);
+        if (crListReplica.cursor.predecessor === linkedListEntry.predecessor) {
+          void moveEntryToPredecessor(
+            crListReplica,
+            crListReplica.cursor,
+            linkedListEntry.uuidv7,
+            delta
+          );
+        }
+        void updateEntryToMaps(crListReplica, linkedListEntry, delta);
+        crListReplica.cursor = linkedListEntry;
+        change[linkedListEntry.index] = linkedListEntry.value;
+        mode = "after";
+        listIndex = linkedListEntry.index - 1;
+        break;
+      }
+    }
+    crListReplica.size = crListReplica.parentMap.size;
+    listIndex++;
+  }
+  if (mode !== "overwrite")
+    while (shiftCursor) {
+      shiftCursor.index += listValues.length;
+      shiftCursor = shiftCursor.next;
+    }
+  return { change, delta };
+}
+
+// src/core/crud/delete/index.ts
+function __delete(crListReplica, startIndex, endIndex) {
+  const change = {};
+  const delta = { values: [], tombstones: [] };
+  const listIndex = startIndex ?? 0;
+  const targetEndIndex = endIndex ?? crListReplica.size;
+  if (listIndex < 0 || targetEndIndex < listIndex || listIndex > crListReplica.size)
+    throw new CRListError("INDEX_OUT_OF_BOUNDS");
+  const deleteCount = Math.min(targetEndIndex, crListReplica.size) - listIndex;
+  if (deleteCount <= 0) return false;
+  void walkToIndex(listIndex, crListReplica);
+  if (!crListReplica.cursor) return false;
+  let current = crListReplica.cursor;
+  let deleted = 0;
+  while (current && deleted < deleteCount) {
+    const next = current.next;
+    change[current.index] = void 0;
+    void deleteLinkedEntry(crListReplica, current, delta);
+    current = next;
+    deleted++;
+  }
+  crListReplica.size = crListReplica.parentMap.size;
+  while (current) {
+    current.index -= deleted;
+    current = current.next;
+  }
+  return { change, delta };
+}
+
+// src/core/mags/merge/index.ts
+import { prototype as prototype2, isUuidV7 as isUuidV73 } from "@sovereignbase/utils";
+function __merge(crListReplica, crListDelta) {
+  if (!crListDelta || prototype2(crListDelta) !== "record") return false;
+  const newVals = [];
+  const newTombsIndices = [];
+  const change = {};
+  let needsRelink = false;
+  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);
+      const linkedListEntry = crListReplica.parentMap.get(tombstone);
+      if (linkedListEntry) {
+        void newTombsIndices.push(linkedListEntry.index);
+        void deleteLinkedEntry(crListReplica, linkedListEntry);
+        needsRelink = true;
+      }
+    }
+  }
+  if (!Object.hasOwn(crListDelta, "values") || !Array.isArray(crListDelta.values)) {
+    if (newTombsIndices.length === 0) return false;
+    void assertListIndices(crListReplica);
+    for (const index of newTombsIndices) {
+      change[index] = void 0;
+    }
+    return change;
+  }
+  for (const valueEntry of crListDelta.values) {
+    const existingEntry = crListReplica.parentMap.get(valueEntry.uuidv7);
+    if (existingEntry) {
+      if (crListReplica.tombstones.has(valueEntry.uuidv7) || !isUuidV73(valueEntry.predecessor) && valueEntry.predecessor !== "\0")
+        continue;
+      if (existingEntry.predecessor >= valueEntry.predecessor) continue;
+      void moveEntryToPredecessor(
+        crListReplica,
+        existingEntry,
+        valueEntry.predecessor
+      );
+      needsRelink = true;
+      void newVals.push(existingEntry);
+      continue;
+    }
+    const linkedListEntry = snapshotValueToLinkedListValue(
+      valueEntry,
+      crListReplica
+    );
+    if (!linkedListEntry) continue;
+    const predecessor = linkedListEntry.predecessor === "\0" ? void 0 : crListReplica.parentMap.get(linkedListEntry.predecessor);
+    void updateEntryToMaps(crListReplica, linkedListEntry);
+    void newVals.push(linkedListEntry);
+    if (!needsRelink && linkedListEntry.predecessor === "\0") {
+      if (crListReplica.size === 0) {
+        crListReplica.cursor = linkedListEntry;
+        crListReplica.size = crListReplica.parentMap.size;
+      } else {
+        needsRelink = true;
+      }
+    } else if (!needsRelink && predecessor && !predecessor.next) {
+      linkedListEntry.prev = predecessor;
+      linkedListEntry.index = predecessor.index + 1;
+      predecessor.next = linkedListEntry;
+      crListReplica.cursor = linkedListEntry;
+      crListReplica.size = crListReplica.parentMap.size;
+    } else {
+      needsRelink = true;
+    }
+  }
+  if (needsRelink) {
+    void flattenAndLinkTrustedState(crListReplica);
+    void assertListIndices(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] = val.value;
+  }
+  return change;
+}
+
+// src/core/mags/acknowledge/index.ts
+function __acknowledge(crListReplica) {
+  let frontier = false;
+  crListReplica.tombstones.forEach((tombstone) => {
+    if (frontier === false || frontier < tombstone) frontier = tombstone;
+  });
+  if (typeof frontier === "string") return frontier;
+  return false;
+}
+
+// src/core/mags/garbageCollect/index.ts
+function __garbageCollect(frontiers, crListReplica) {
+  if (!Array.isArray(frontiers)) return;
+  const frontier = frontiers.sort().shift();
+  if (typeof frontier !== "string") return;
+  crListReplica.tombstones.forEach((tombstone, __, tombstones) => {
+    if (tombstone <= frontier) {
+      tombstones.delete(tombstone);
+    }
+  });
+}
+
+// src/core/mags/snapshot/index.ts
+function __snapshot(crListReplica) {
+  return {
+    values: Array.from(crListReplica.parentMap.values()).map(
+      (linkedListEntry) => {
+        if (!linkedListEntry) throw new CRListError("LIST_INTEGRITY_VIOLATION");
+        return {
+          uuidv7: linkedListEntry.uuidv7,
+          value: structuredClone(linkedListEntry.value),
+          predecessor: linkedListEntry.predecessor
+        };
+      }
+    ),
+    tombstones: Array.from(crListReplica.tombstones)
+  };
+}
+
+// src/CRList/class.ts
+var CRList = class {
+  /**
+   * Creates a replicated list from an optional serializable snapshot.
+   *
+   * @param snapshot - A previously emitted CRList snapshot.
+   */
+  constructor(snapshot) {
+    Object.defineProperties(this, {
+      state: {
+        value: __create(snapshot),
+        enumerable: false,
+        configurable: false,
+        writable: false
+      },
+      eventTarget: {
+        value: new EventTarget(),
+        enumerable: false,
+        configurable: false,
+        writable: false
+      }
+    });
+    return new Proxy(this, {
+      get(target, index, receiver) {
+        const listIndex = indexFromPropertyKey(index);
+        if (listIndex === void 0) return Reflect.get(target, index, receiver);
+        return __read(listIndex, target.state);
+      },
+      has(target, index) {
+        const listIndex = indexFromPropertyKey(index);
+        if (listIndex === void 0) return Reflect.has(target, index);
+        return listIndex >= 0 && listIndex < target.state.size;
+      },
+      set(target, index, value) {
+        const listIndex = indexFromPropertyKey(index);
+        if (listIndex === void 0) return false;
+        try {
+          const result = __update(listIndex, [value], target.state, "overwrite");
+          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 })
+            );
+          return true;
+        } catch {
+          return false;
+        }
+      },
+      deleteProperty(target, index) {
+        const listIndex = indexFromPropertyKey(index);
+        if (listIndex === void 0) return false;
+        try {
+          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 })
+            );
+          }
+          return true;
+        } catch {
+          return false;
+        }
+      },
+      ownKeys(target) {
+        return [
+          ...Reflect.ownKeys(target),
+          ...Array.from({ length: target.size }, (_, index) => String(index))
+        ];
+      },
+      getOwnPropertyDescriptor(target, index) {
+        const listIndex = indexFromPropertyKey(index);
+        if (listIndex !== void 0 && listIndex < target.size) {
+          return {
+            value: __read(listIndex, target.state),
+            writable: true,
+            enumerable: true,
+            configurable: true
+          };
+        }
+        return Reflect.getOwnPropertyDescriptor(target, index);
+      }
+    });
+  }
+  /**
+   * The current number of live entries.
+   */
+  get size() {
+    return this.state.size;
+  }
+  /**
+   * Inserts a value before an index.
+   *
+   * If `beforeIndex` is omitted, the value is inserted at the start of the list.
+   *
+   * @param value - The value to insert.
+   * @param beforeIndex - The index to insert before.
+   */
+  prepend(value, beforeIndex) {
+    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 })
+      );
+  }
+  /**
+   * Inserts a value after an index.
+   *
+   * If `afterIndex` is omitted, the value is appended at the end of the list.
+   *
+   * @param value - The value to insert.
+   * @param afterIndex - The index to insert after.
+   */
+  append(value, afterIndex) {
+    const result = __update(
+      afterIndex ?? this.state.size,
+      [value],
+      this.state,
+      "after"
+    );
+    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 })
+      );
+  }
+  /**
+   * Removes the entry at an index.
+   *
+   * @param index - The index to remove.
+   */
+  remove(index) {
+    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 })
+      );
+  }
+  /**
+   * Applies a remote gossip delta to this list.
+   *
+   * Emits a `change` event when the merge changes the live projection.
+   *
+   * @param delta - The remote CRList delta to merge.
+   */
+  merge(delta) {
+    const change = __merge(this.state, delta);
+    if (change)
+      void this.eventTarget.dispatchEvent(
+        new CustomEvent("change", { detail: 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 })
+      );
+  }
+  /**
+   * Garbage-collects tombstones that are covered by acknowledgement frontiers.
+   *
+   * @param frontiers - Replica acknowledgement frontiers.
+   */
+  garbageCollect(frontiers) {
+    void __garbageCollect(frontiers, this.state);
+  }
+  /**
+   * Emits the current serializable list snapshot.
+   */
+  snapshot() {
+    const snapshot = __snapshot(this.state);
+    if (snapshot)
+      void this.eventTarget.dispatchEvent(
+        new CustomEvent("snapshot", { detail: snapshot })
+      );
+  }
+  /**
+   * Registers an event listener.
+   *
+   * @param type - The event type to listen for.
+   * @param listener - The listener to register.
+   * @param options - Listener registration options.
+   */
+  addEventListener(type, listener, options) {
+    this.eventTarget.addEventListener(
+      type,
+      listener,
+      options
+    );
+  }
+  /**
+   * Removes an event listener.
+   *
+   * @param type - The event type to stop listening for.
+   * @param listener - The listener to remove.
+   * @param options - Listener removal options.
+   */
+  removeEventListener(type, listener, options) {
+    this.eventTarget.removeEventListener(
+      type,
+      listener,
+      options
+    );
+  }
+  /**
+   * Returns a serializable snapshot representation of this list.
+   *
+   * Called automatically by `JSON.stringify`.
+   */
+  toJSON() {
+    return __snapshot(this.state);
+  }
+  /**
+   * Returns this list as a JSON string.
+   */
+  toString() {
+    return JSON.stringify(this);
+  }
+  /**
+   * Returns the Node.js console inspection representation.
+   */
+  [/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")]() {
+    return this.toJSON();
+  }
+  /**
+   * Returns the Deno console inspection representation.
+   */
+  [/* @__PURE__ */ Symbol.for("Deno.customInspect")]() {
+    return this.toJSON();
+  }
+  /**
+   * Iterates over the current live values in index order.
+   */
+  *[Symbol.iterator]() {
+    for (let index = 0; index < this.size; index++) {
+      const value = this[index];
+      yield value;
+    }
+  }
+  /**
+   * Calls a function once for each live value in index order.
+   *
+   * @param callback - Function to call for each 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);
+    }
+  }
+};
+export {
+  CRList,
+  __acknowledge,
+  __create,
+  __delete,
+  __garbageCollect,
+  __merge,
+  __read,
+  __snapshot,
+  __update
+};
+//# sourceMappingURL=index.js.map