mobx-keystone-loro 1.0.0

package/dist/mobx-keystone-loro.umd.js

@@ -0,0 +1,957 @@
+(function(global, factory) {
+  typeof exports === "object" && typeof module !== "undefined" ? factory(exports, require("loro-crdt"), require("mobx"), require("mobx-keystone")) : typeof define === "function" && define.amd ? define(["exports", "loro-crdt", "mobx", "mobx-keystone"], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, factory(global["mobx-keystone-loro"] = {}, global["loro-crdt"], global.mobx, global["mobx-keystone"]));
+})(this, (function(exports2, loroCrdt, mobx, mobxKeystone) {
+  "use strict";var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+  let nanoid = (size = 21) => crypto.getRandomValues(new Uint8Array(size)).reduce((id, byte) => {
+    byte &= 63;
+    if (byte < 36) {
+      id += byte.toString(36);
+    } else if (byte < 62) {
+      id += (byte - 26).toString(36).toUpperCase();
+    } else if (byte > 62) {
+      id += "-";
+    } else {
+      id += "_";
+    }
+    return id;
+  }, "");
+  const atomMap = /* @__PURE__ */ new WeakMap();
+  function getOrCreateLoroCollectionAtom(collection) {
+    let atom = atomMap.get(collection);
+    if (!atom) {
+      atom = mobx.createAtom(`loroCollectionAtom`);
+      atomMap.set(collection, atom);
+    }
+    return atom;
+  }
+  class MobxKeystoneLoroError extends Error {
+    constructor(msg) {
+      super(msg);
+      Object.setPrototypeOf(this, MobxKeystoneLoroError.prototype);
+    }
+  }
+  function failure(message) {
+    throw new MobxKeystoneLoroError(message);
+  }
+  const loroBindingContext = mobxKeystone.createContext(void 0);
+  function resolveLoroPath(loroObject, path) {
+    let currentLoroObject = loroObject;
+    path.forEach((pathPart, i) => {
+      if (currentLoroObject instanceof loroCrdt.LoroMap) {
+        getOrCreateLoroCollectionAtom(currentLoroObject).reportObserved();
+        const key = String(pathPart);
+        currentLoroObject = currentLoroObject.get(key);
+      } else if (currentLoroObject instanceof loroCrdt.LoroMovableList) {
+        getOrCreateLoroCollectionAtom(currentLoroObject).reportObserved();
+        const key = Number(pathPart);
+        currentLoroObject = currentLoroObject.get(key);
+      } else {
+        throw failure(
+          `LoroMap or LoroMovableList was expected at path ${JSON.stringify(
+            path.slice(0, i)
+          )} in order to resolve path ${JSON.stringify(path)}, but got ${currentLoroObject} instead`
+        );
+      }
+    });
+    return currentLoroObject;
+  }
+  var __defProp2 = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __decorateClass = (decorators, target, key, kind) => {
+    var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+    for (var i = decorators.length - 1, decorator; i >= 0; i--)
+      if (decorator = decorators[i])
+        result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+    if (kind && result) __defProp2(target, key, result);
+    return result;
+  };
+  const loroTextModelId = "mobx-keystone-loro/LoroTextModel";
+  exports2.LoroTextModel = class LoroTextModel extends mobxKeystone.Model({
+    /**
+     * The current delta representing the rich text content.
+     * Uses Quill delta format.
+     */
+    deltaList: mobxKeystone.tProp(mobxKeystone.types.frozen(mobxKeystone.types.unchecked()), () => mobxKeystone.frozen([]))
+  }) {
+    constructor() {
+      super(...arguments);
+      /**
+       * Atom that gets changed when the associated Loro text changes.
+       */
+      __publicField(this, "loroTextChangedAtom", mobx.createAtom("loroTextChangedAtom"));
+    }
+    /**
+     * Creates a LoroTextModel with initial text content.
+     */
+    static withText(text) {
+      return new exports2.LoroTextModel({
+        deltaList: mobxKeystone.frozen([{ insert: text }])
+      });
+    }
+    /**
+     * Creates a LoroTextModel with initial delta.
+     */
+    static withDelta(delta) {
+      return new exports2.LoroTextModel({
+        deltaList: mobxKeystone.frozen(delta)
+      });
+    }
+    get loroText() {
+      const ctx = loroBindingContext.get(this);
+      if ((ctx == null ? void 0 : ctx.boundObject) == null) {
+        return void 0;
+      }
+      try {
+        const path = mobxKeystone.getParentToChildPath(ctx.boundObject, this);
+        if (!path) {
+          return void 0;
+        }
+        if (path.length === 0) {
+          const loroObject2 = ctx.loroObject;
+          if (loroObject2 instanceof loroCrdt.LoroText) {
+            getOrCreateLoroCollectionAtom(loroObject2).reportObserved();
+            return loroObject2;
+          }
+          return void 0;
+        }
+        const loroObject = resolveLoroPath(ctx.loroObject, path);
+        if (loroObject instanceof loroCrdt.LoroText) {
+          getOrCreateLoroCollectionAtom(loroObject).reportObserved();
+          return loroObject;
+        }
+      } catch {
+      }
+      return void 0;
+    }
+    get text() {
+      this.loroTextChangedAtom.reportObserved();
+      return this.deltaToText(this.deltaList.data);
+    }
+    get currentDelta() {
+      this.loroTextChangedAtom.reportObserved();
+      const loroText = this.loroText;
+      if (loroText) {
+        try {
+          return loroText.toDelta();
+        } catch {
+        }
+      }
+      return this.deltaList.data;
+    }
+    /**
+     * Converts delta to plain text.
+     */
+    deltaToText(delta) {
+      let result = "";
+      for (const op of delta) {
+        if ("insert" in op && typeof op.insert === "string") {
+          result += op.insert;
+        }
+      }
+      return result;
+    }
+    setDelta(delta) {
+      this.deltaList = mobxKeystone.frozen(delta);
+    }
+    insertText(index, text) {
+      const loroText = this.loroText;
+      if (loroText) {
+        loroText.insert(index, text);
+      } else {
+        const currentText = this.text;
+        const newText = currentText.slice(0, index) + text + currentText.slice(index);
+        this.deltaList = mobxKeystone.frozen([{ insert: newText }]);
+      }
+    }
+    deleteText(index, length) {
+      const loroText = this.loroText;
+      if (loroText) {
+        loroText.delete(index, length);
+      } else {
+        const currentText = this.text;
+        const newText = currentText.slice(0, index) + currentText.slice(index + length);
+        this.deltaList = mobxKeystone.frozen([{ insert: newText }]);
+      }
+    }
+    _updateDeltaFromLoro(delta) {
+      this.deltaList = mobxKeystone.frozen(delta);
+    }
+  };
+  __decorateClass([
+    mobx.computed
+  ], exports2.LoroTextModel.prototype, "loroText", 1);
+  __decorateClass([
+    mobx.computed
+  ], exports2.LoroTextModel.prototype, "text", 1);
+  __decorateClass([
+    mobx.computed
+  ], exports2.LoroTextModel.prototype, "currentDelta", 1);
+  __decorateClass([
+    mobxKeystone.modelAction
+  ], exports2.LoroTextModel.prototype, "setDelta", 1);
+  __decorateClass([
+    mobxKeystone.modelAction
+  ], exports2.LoroTextModel.prototype, "insertText", 1);
+  __decorateClass([
+    mobxKeystone.modelAction
+  ], exports2.LoroTextModel.prototype, "deleteText", 1);
+  __decorateClass([
+    mobxKeystone.modelAction
+  ], exports2.LoroTextModel.prototype, "_updateDeltaFromLoro", 1);
+  exports2.LoroTextModel = __decorateClass([
+    mobxKeystone.model(loroTextModelId)
+  ], exports2.LoroTextModel);
+  const loroTextModelType = mobxKeystone.types.model(exports2.LoroTextModel);
+  function isLoroTextModelSnapshot(value) {
+    return mobxKeystone.getSnapshotModelType(value) === loroTextModelId;
+  }
+  function convertLoroDataToJson(value) {
+    if (value === null) {
+      return null;
+    }
+    if (typeof value !== "object") {
+      if (value === void 0) {
+        throw new Error("undefined values are not supported by Loro");
+      }
+      return value;
+    }
+    if (loroCrdt.isContainer(value)) {
+      if (value instanceof loroCrdt.LoroMap) {
+        const result2 = {};
+        for (const [k, v] of value.entries()) {
+          result2[k] = convertLoroDataToJson(v);
+        }
+        return result2;
+      }
+      if (value instanceof loroCrdt.LoroMovableList) {
+        const result2 = [];
+        for (let i = 0; i < value.length; i++) {
+          result2.push(convertLoroDataToJson(value.get(i)));
+        }
+        return result2;
+      }
+      if (value instanceof loroCrdt.LoroText) {
+        const deltas = value.toDelta();
+        return mobxKeystone.modelSnapshotOutWithMetadata(exports2.LoroTextModel, {
+          deltaList: mobxKeystone.toFrozenSnapshot(deltas)
+        });
+      }
+      throw failure(`unsupported bindable Loro container type`);
+    }
+    if (Array.isArray(value)) {
+      return value.map((item) => convertLoroDataToJson(item));
+    }
+    const result = {};
+    for (const [k, v] of Object.entries(value)) {
+      result[k] = convertLoroDataToJson(v);
+    }
+    return result;
+  }
+  function applyLoroEventToMobx(event, loroDoc, boundObject, rootPath, reconciliationMap, newlyInsertedContainers) {
+    if (newlyInsertedContainers.has(event.target)) {
+      return;
+    }
+    const eventPath = loroDoc.getPathToContainer(event.target);
+    if (!eventPath) {
+      return;
+    }
+    const relativePath = resolveEventPath(eventPath, rootPath);
+    if (relativePath === void 0) {
+      return;
+    }
+    const { value: target } = mobxKeystone.resolvePath(boundObject, relativePath);
+    if (!target) {
+      throw failure(`cannot resolve path ${JSON.stringify(relativePath)}`);
+    }
+    mobxKeystone.runUnprotected(() => {
+      const diff = event.diff;
+      if (diff.type === "map") {
+        applyMapEventToMobx(diff, loroDoc, event.target, target, reconciliationMap);
+      } else if (diff.type === "list") {
+        applyListEventToMobx(
+          diff,
+          loroDoc,
+          event.target,
+          target,
+          reconciliationMap,
+          newlyInsertedContainers
+        );
+      } else if (diff.type === "text") {
+        applyTextEventToMobx(loroDoc, event.target, target);
+      }
+    });
+  }
+  function processDeletedValue(val, reconciliationMap) {
+    if (mobxKeystone.isModel(val) || mobxKeystone.isDataModel(val)) {
+      const id = mobxKeystone.modelIdKey in val ? val[mobxKeystone.modelIdKey] : void 0;
+      if (id) {
+        reconciliationMap.set(id, val);
+      }
+    }
+  }
+  function reviveValue(jsonValue, reconciliationMap) {
+    if (jsonValue === null || typeof jsonValue !== "object") {
+      return jsonValue;
+    }
+    if (mobxKeystone.isFrozenSnapshot(jsonValue)) {
+      return mobxKeystone.frozen(jsonValue.data);
+    }
+    if (reconciliationMap) {
+      const modelId = mobxKeystone.getSnapshotModelId(jsonValue);
+      if (modelId) {
+        const existing = reconciliationMap.get(modelId);
+        if (existing) {
+          reconciliationMap.delete(modelId);
+          return existing;
+        }
+      }
+    }
+    return mobxKeystone.fromSnapshot(jsonValue);
+  }
+  function applyMapEventToMobx(diff, loroDoc, containerTarget, target, reconciliationMap) {
+    const container = loroDoc.getContainerById(containerTarget);
+    if (!container || !(container instanceof loroCrdt.LoroMap)) {
+      throw failure(`${containerTarget} was not a Loro map`);
+    }
+    for (const key of Object.keys(diff.updated)) {
+      const loroValue = container.get(key);
+      if (loroValue === void 0) {
+        if (key in target) {
+          processDeletedValue(target[key], reconciliationMap);
+          if (mobxKeystone.isModel(target)) {
+            mobx.remove(target.$, key);
+          } else {
+            mobx.remove(target, key);
+          }
+        }
+      } else {
+        if (key in target) {
+          processDeletedValue(target[key], reconciliationMap);
+        }
+        const jsonValue = convertLoroDataToJson(loroValue);
+        target[key] = reviveValue(jsonValue, reconciliationMap);
+      }
+    }
+  }
+  function applyListEventToMobx(diff, loroDoc, containerTarget, target, reconciliationMap, newlyInsertedContainers) {
+    const container = loroDoc.getContainerById(containerTarget);
+    if (!container || !(container instanceof loroCrdt.LoroMovableList)) {
+      throw failure(`${containerTarget} was not a Loro movable list`);
+    }
+    let currentIndex = 0;
+    for (const change of diff.diff) {
+      if (change.retain) {
+        currentIndex += change.retain;
+      }
+      if (change.delete) {
+        const deletedItems = target.slice(currentIndex, currentIndex + change.delete);
+        deletedItems.forEach((item) => {
+          processDeletedValue(item, reconciliationMap);
+        });
+        target.splice(currentIndex, change.delete);
+      }
+      if (change.insert) {
+        const insertedItems = change.insert;
+        const values = insertedItems.map((loroValue) => {
+          if (loroCrdt.isContainer(loroValue)) {
+            newlyInsertedContainers.add(loroValue.id);
+            collectNestedContainerIds(loroValue, newlyInsertedContainers);
+          }
+          const jsonValue = convertLoroDataToJson(loroValue);
+          return reviveValue(jsonValue, reconciliationMap);
+        });
+        target.splice(currentIndex, 0, ...values);
+        currentIndex += values.length;
+      }
+    }
+  }
+  function applyTextEventToMobx(loroDoc, containerTarget, target) {
+    const container = loroDoc.getContainerById(containerTarget);
+    if (!container || !(container instanceof loroCrdt.LoroText)) {
+      throw failure(`${containerTarget} was not a Loro text container`);
+    }
+    if (!("deltaList" in target)) {
+      throw failure("target does not have a deltaList property - expected LoroTextModel");
+    }
+    target.deltaList = mobxKeystone.frozen(container.toDelta());
+  }
+  function collectNestedContainerIds(container, containerIds) {
+    if (!loroCrdt.isContainer(container)) {
+      return;
+    }
+    containerIds.add(container.id);
+    if (container instanceof loroCrdt.LoroMap) {
+      for (const key of Object.keys(container.toJSON())) {
+        const value = container.get(key);
+        collectNestedContainerIds(value, containerIds);
+      }
+    }
+    if (container instanceof loroCrdt.LoroMovableList) {
+      for (let i = 0; i < container.length; i++) {
+        collectNestedContainerIds(container.get(i), containerIds);
+      }
+    }
+  }
+  function resolveEventPath(eventPath, rootPath) {
+    if (eventPath.length < rootPath.length) {
+      return void 0;
+    }
+    for (let i = 0; i < rootPath.length; i++) {
+      if (eventPath[i] !== rootPath[i]) {
+        return void 0;
+      }
+    }
+    return eventPath.slice(rootPath.length);
+  }
+  function isBindableLoroContainer(value) {
+    return value instanceof loroCrdt.LoroMap || value instanceof loroCrdt.LoroMovableList || value instanceof loroCrdt.LoroText;
+  }
+  const loroContainerToSnapshot = /* @__PURE__ */ new WeakMap();
+  function setLoroContainerSnapshot(container, snapshot) {
+    loroContainerToSnapshot.set(container, snapshot);
+  }
+  function isLoroContainerUpToDate(container, snapshot) {
+    return loroContainerToSnapshot.get(container) === snapshot;
+  }
+  function isPlainPrimitive(v) {
+    const t = typeof v;
+    return t === "string" || t === "number" || t === "boolean" || v === null || v === void 0;
+  }
+  function isPlainArray(v) {
+    return Array.isArray(v);
+  }
+  function isPlainObject(v) {
+    return typeof v === "object" && v !== null && !Array.isArray(v);
+  }
+  function extractTextDeltaFromSnapshot(delta) {
+    if (mobxKeystone.isFrozenSnapshot(delta)) {
+      const data = delta.data;
+      if (Array.isArray(data)) {
+        return data;
+      }
+    }
+    if (Array.isArray(delta)) {
+      return delta;
+    }
+    return [];
+  }
+  function applyDeltaToLoroText(text, deltas) {
+    let position = 0;
+    const markOperations = [];
+    for (const delta of deltas) {
+      if (delta.insert !== void 0) {
+        const content = delta.insert;
+        text.insert(position, content);
+        if (delta.attributes && Object.keys(delta.attributes).length > 0) {
+          markOperations.push({
+            start: position,
+            end: position + content.length,
+            attributes: delta.attributes
+          });
+        }
+        position += content.length;
+      } else if (delta.retain) {
+        position += delta.retain;
+      } else if (delta.delete) {
+        text.delete(position, delta.delete);
+      }
+    }
+    for (const op of markOperations) {
+      for (const [key, value] of Object.entries(op.attributes)) {
+        text.mark({ start: op.start, end: op.end }, key, value);
+      }
+    }
+  }
+  function convertJsonToLoroData(v) {
+    if (isPlainPrimitive(v)) {
+      return v;
+    }
+    if (isPlainArray(v)) {
+      const list = new loroCrdt.LoroMovableList();
+      applyJsonArrayToLoroMovableList(list, v);
+      return list;
+    }
+    if (isPlainObject(v)) {
+      if (v[mobxKeystone.frozenKey] === true) {
+        return v;
+      }
+      if (isLoroTextModelSnapshot(v)) {
+        const text = new loroCrdt.LoroText();
+        const deltas = extractTextDeltaFromSnapshot(v.deltaList);
+        if (deltas.length > 0) {
+          applyDeltaToLoroText(text, deltas);
+        }
+        return text;
+      }
+      const map = new loroCrdt.LoroMap();
+      applyJsonObjectToLoroMap(map, v);
+      return map;
+    }
+    throw new Error(`unsupported value type: ${v}`);
+  }
+  const applyJsonArrayToLoroMovableList = (dest, source, options = {}) => {
+    const { mode = "add" } = options;
+    if (mode === "add") {
+      for (const item of source) {
+        const converted = convertJsonToLoroData(item);
+        if (isBindableLoroContainer(converted)) {
+          dest.pushContainer(converted);
+        } else {
+          dest.push(converted);
+        }
+      }
+      return;
+    }
+    if (isLoroContainerUpToDate(dest, source)) {
+      return;
+    }
+    const destLen = dest.length;
+    const srcLen = source.length;
+    if (destLen > srcLen) {
+      dest.delete(srcLen, destLen - srcLen);
+    }
+    const minLen = Math.min(destLen, srcLen);
+    for (let i = 0; i < minLen; i++) {
+      const srcItem = source[i];
+      const destItem = dest.get(i);
+      if (isPlainObject(srcItem) && destItem instanceof loroCrdt.LoroMap) {
+        applyJsonObjectToLoroMap(destItem, srcItem, options);
+        continue;
+      }
+      if (isPlainArray(srcItem) && destItem instanceof loroCrdt.LoroMovableList) {
+        applyJsonArrayToLoroMovableList(destItem, srcItem, options);
+        continue;
+      }
+      if (isPlainPrimitive(srcItem) && destItem === srcItem) {
+        continue;
+      }
+      dest.delete(i, 1);
+      const converted = convertJsonToLoroData(srcItem);
+      if (isBindableLoroContainer(converted)) {
+        dest.insertContainer(i, converted);
+      } else {
+        dest.insert(i, converted);
+      }
+    }
+    for (let i = destLen; i < srcLen; i++) {
+      const converted = convertJsonToLoroData(source[i]);
+      if (isBindableLoroContainer(converted)) {
+        dest.pushContainer(converted);
+      } else {
+        dest.push(converted);
+      }
+    }
+    setLoroContainerSnapshot(dest, source);
+  };
+  const applyJsonObjectToLoroMap = (dest, source, options = {}) => {
+    const { mode = "add" } = options;
+    if (mode === "add") {
+      for (const k of Object.keys(source)) {
+        const v = source[k];
+        if (v !== void 0) {
+          const converted = convertJsonToLoroData(v);
+          if (isBindableLoroContainer(converted)) {
+            dest.setContainer(k, converted);
+          } else {
+            dest.set(k, converted);
+          }
+        }
+      }
+      return;
+    }
+    if (isLoroContainerUpToDate(dest, source)) {
+      return;
+    }
+    const sourceKeysWithValues = new Set(Object.keys(source).filter((k) => source[k] !== void 0));
+    for (const key of dest.keys()) {
+      if (!sourceKeysWithValues.has(key)) {
+        dest.delete(key);
+      }
+    }
+    for (const k of Object.keys(source)) {
+      const v = source[k];
+      if (v === void 0) {
+        continue;
+      }
+      const existing = dest.get(k);
+      if (isPlainObject(v) && existing instanceof loroCrdt.LoroMap) {
+        applyJsonObjectToLoroMap(existing, v, options);
+        continue;
+      }
+      if (isPlainArray(v) && existing instanceof loroCrdt.LoroMovableList) {
+        applyJsonArrayToLoroMovableList(existing, v, options);
+        continue;
+      }
+      if (isPlainPrimitive(v) && existing === v) {
+        continue;
+      }
+      const converted = convertJsonToLoroData(v);
+      if (isBindableLoroContainer(converted)) {
+        dest.setContainer(k, converted);
+      } else {
+        dest.set(k, converted);
+      }
+    }
+    setLoroContainerSnapshot(dest, source);
+  };
+  function convertValue(v) {
+    if (v === null || v === void 0 || typeof v !== "object") {
+      return v;
+    }
+    if (Array.isArray(v) && v.length === 0) {
+      return new loroCrdt.LoroMovableList();
+    }
+    if (isLoroTextModelSnapshot(v)) {
+      return v;
+    }
+    return convertJsonToLoroData(v);
+  }
+  function insertIntoList(list, index, value) {
+    if (value instanceof loroCrdt.LoroMap || value instanceof loroCrdt.LoroMovableList || value instanceof loroCrdt.LoroText) {
+      list.insertContainer(index, value);
+    } else if (isLoroTextModelSnapshot(value)) {
+      const attachedText = list.insertContainer(index, new loroCrdt.LoroText());
+      const deltas = extractTextDeltaFromSnapshot(value.deltaList);
+      if (deltas.length > 0) {
+        applyDeltaToLoroText(attachedText, deltas);
+      }
+    } else {
+      list.insert(index, value);
+    }
+  }
+  function setInMap(map, key, value) {
+    if (value === void 0) {
+      map.delete(key);
+    } else if (value instanceof loroCrdt.LoroMap || value instanceof loroCrdt.LoroMovableList || value instanceof loroCrdt.LoroText) {
+      map.setContainer(key, value);
+    } else if (isLoroTextModelSnapshot(value)) {
+      const attachedText = map.setContainer(key, new loroCrdt.LoroText());
+      const deltas = extractTextDeltaFromSnapshot(value.deltaList);
+      if (deltas.length > 0) {
+        applyDeltaToLoroText(attachedText, deltas);
+      }
+    } else {
+      map.set(key, value);
+    }
+  }
+  function applyMobxChangeToLoroObject(change, loroObject) {
+    const loroContainer = resolveLoroPath(loroObject, change.path);
+    if (!loroContainer) {
+      throw failure(
+        `cannot apply change to missing Loro container at path: ${JSON.stringify(change.path)}`
+      );
+    }
+    switch (change.type) {
+      case "ArrayMove": {
+        if (!(loroContainer instanceof loroCrdt.LoroMovableList)) {
+          throw failure(`ArrayMove change requires a LoroMovableList container`);
+        }
+        loroContainer.move(change.fromIndex, change.toIndex);
+        break;
+      }
+      case mobxKeystone.DeepChangeType.ArraySplice: {
+        if (!(loroContainer instanceof loroCrdt.LoroMovableList)) {
+          throw failure(`ArraySplice change requires a LoroMovableList container`);
+        }
+        if (change.removedValues.length > 0) {
+          loroContainer.delete(change.index, change.removedValues.length);
+        }
+        if (change.addedValues.length > 0) {
+          const valuesToInsert = change.addedValues.map(convertValue);
+          for (let i = 0; i < valuesToInsert.length; i++) {
+            insertIntoList(loroContainer, change.index + i, valuesToInsert[i]);
+          }
+        }
+        break;
+      }
+      case mobxKeystone.DeepChangeType.ArrayUpdate: {
+        if (!(loroContainer instanceof loroCrdt.LoroMovableList)) {
+          throw failure(`ArrayUpdate change requires a LoroMovableList container`);
+        }
+        const converted = convertValue(change.newValue);
+        if (converted instanceof loroCrdt.LoroMap || converted instanceof loroCrdt.LoroMovableList || converted instanceof loroCrdt.LoroText) {
+          loroContainer.setContainer(change.index, converted);
+        } else if (isLoroTextModelSnapshot(converted)) {
+          const attachedText = loroContainer.setContainer(change.index, new loroCrdt.LoroText());
+          const deltas = extractTextDeltaFromSnapshot(converted.deltaList);
+          if (deltas.length > 0) {
+            applyDeltaToLoroText(attachedText, deltas);
+          }
+        } else {
+          loroContainer.set(change.index, converted);
+        }
+        break;
+      }
+      case mobxKeystone.DeepChangeType.ObjectAdd:
+      case mobxKeystone.DeepChangeType.ObjectUpdate: {
+        if (loroContainer instanceof loroCrdt.LoroText) {
+          if (change.key === "deltaList") {
+            const deltas = extractTextDeltaFromSnapshot(change.newValue);
+            if (loroContainer.length > 0) {
+              loroContainer.delete(0, loroContainer.length);
+            }
+            if (deltas.length > 0) {
+              applyDeltaToLoroText(loroContainer, deltas);
+            }
+          }
+        } else if (loroContainer instanceof loroCrdt.LoroMap) {
+          const converted = convertValue(change.newValue);
+          setInMap(loroContainer, change.key, converted);
+        } else {
+          throw failure(`ObjectAdd/ObjectUpdate change requires a LoroMap or LoroText container`);
+        }
+        break;
+      }
+      case mobxKeystone.DeepChangeType.ObjectRemove: {
+        if (loroContainer instanceof loroCrdt.LoroText) ;
+        else if (loroContainer instanceof loroCrdt.LoroMap) {
+          loroContainer.delete(change.key);
+        } else {
+          throw failure(`ObjectRemove change requires a LoroMap or LoroText container`);
+        }
+        break;
+      }
+      default: {
+        const _exhaustiveCheck = change;
+        throw failure(`unsupported change type: ${_exhaustiveCheck.type}`);
+      }
+    }
+  }
+  let activeMoveContext;
+  function moveWithinArray(array, fromIndex, toIndex) {
+    if (fromIndex < 0 || fromIndex >= array.length) {
+      throw new Error(`fromIndex ${fromIndex} is out of bounds (array length: ${array.length})`);
+    }
+    if (toIndex < 0 || toIndex > array.length) {
+      throw new Error(`toIndex ${toIndex} is out of bounds (array length: ${array.length})`);
+    }
+    if (fromIndex === toIndex) {
+      return;
+    }
+    activeMoveContext = {
+      array,
+      fromIndex,
+      toIndex,
+      path: void 0,
+      receivedFirstSplice: false
+    };
+    try {
+      const [item] = array.splice(fromIndex, 1);
+      const adjustedTarget = toIndex > fromIndex ? toIndex - 1 : toIndex;
+      array.splice(adjustedTarget, 0, item);
+    } finally {
+      activeMoveContext = void 0;
+    }
+  }
+  function processChangeForMove(change) {
+    const ctx = activeMoveContext;
+    if (!ctx.receivedFirstSplice) {
+      ctx.path = change.path;
+      ctx.receivedFirstSplice = true;
+      return void 0;
+    }
+    const adjustedToIndex = ctx.toIndex > ctx.fromIndex ? ctx.toIndex - 1 : ctx.toIndex;
+    return {
+      type: "ArrayMove",
+      path: ctx.path,
+      fromIndex: ctx.fromIndex,
+      toIndex: adjustedToIndex
+    };
+  }
+  function isInMoveContextForArray(array) {
+    return activeMoveContext !== void 0 && activeMoveContext.array === array;
+  }
+  function captureChangeSnapshots(change) {
+    if (change.type === mobxKeystone.DeepChangeType.ArraySplice && change.addedValues.length > 0) {
+      const snapshots = change.addedValues.map((v) => mobxKeystone.isTreeNode(v) ? mobxKeystone.getSnapshot(v) : v);
+      return { ...change, addedValues: snapshots };
+    } else if (change.type === mobxKeystone.DeepChangeType.ArrayUpdate) {
+      const snapshot = mobxKeystone.isTreeNode(change.newValue) ? mobxKeystone.getSnapshot(change.newValue) : change.newValue;
+      return { ...change, newValue: snapshot };
+    } else if (change.type === mobxKeystone.DeepChangeType.ObjectAdd || change.type === mobxKeystone.DeepChangeType.ObjectUpdate) {
+      const snapshot = mobxKeystone.isTreeNode(change.newValue) ? mobxKeystone.getSnapshot(change.newValue) : change.newValue;
+      return { ...change, newValue: snapshot };
+    }
+    return change;
+  }
+  function bindLoroToMobxKeystone({
+    loroDoc,
+    loroObject,
+    mobxKeystoneType
+  }) {
+    var _a;
+    const loroOrigin = `bindLoroToMobxKeystoneTransactionOrigin-${nanoid()}`;
+    let applyingLoroChangesToMobxKeystone = 0;
+    const bindingContext = {
+      loroDoc,
+      loroObject,
+      mobxKeystoneType,
+      loroOrigin,
+      boundObject: void 0,
+      // not yet created
+      get isApplyingLoroChangesToMobxKeystone() {
+        return applyingLoroChangesToMobxKeystone > 0;
+      }
+    };
+    const loroJson = convertLoroDataToJson(loroObject);
+    let boundObject;
+    let hasInitChanges = false;
+    const createBoundObject = () => {
+      const disposeGlobalListener = mobxKeystone.onGlobalDeepChange((_target, change) => {
+        if (change.isInit) {
+          hasInitChanges = true;
+        }
+      });
+      try {
+        const result = loroBindingContext.apply(
+          () => mobxKeystone.fromSnapshot(mobxKeystoneType, loroJson),
+          bindingContext
+        );
+        loroBindingContext.set(result, { ...bindingContext, boundObject: result });
+        return result;
+      } finally {
+        disposeGlobalListener();
+      }
+    };
+    boundObject = createBoundObject();
+    const rootLoroPath = (_a = loroDoc.getPathToContainer(loroObject.id)) != null ? _a : [];
+    const loroSubscribeCb = mobx.action((eventBatch) => {
+      if (eventBatch.origin === loroOrigin) {
+        return;
+      }
+      const newlyInsertedContainers = /* @__PURE__ */ new Set();
+      const reconciliationMap = /* @__PURE__ */ new Map();
+      const initChanges = [];
+      const disposeGlobalListener = mobxKeystone.onGlobalDeepChange((target, change) => {
+        if (change.isInit) {
+          initChanges.push({ target, change: captureChangeSnapshots(change) });
+        }
+      });
+      applyingLoroChangesToMobxKeystone++;
+      try {
+        try {
+          for (const event of eventBatch.events) {
+            applyLoroEventToMobx(
+              event,
+              loroDoc,
+              boundObject,
+              rootLoroPath,
+              reconciliationMap,
+              newlyInsertedContainers
+            );
+          }
+        } finally {
+          disposeGlobalListener();
+        }
+        if (initChanges.length > 0) {
+          loroDoc.setNextCommitOrigin(loroOrigin);
+          for (const { target, change } of initChanges) {
+            const pathToTarget = mobxKeystone.getParentToChildPath(boundObject, target);
+            if (pathToTarget !== void 0) {
+              const changeWithCorrectPath = {
+                ...change,
+                path: [...pathToTarget, ...change.path]
+              };
+              applyMobxChangeToLoroObject(changeWithCorrectPath, loroObject);
+            }
+          }
+          loroDoc.commit();
+        }
+        if (loroObject instanceof loroCrdt.LoroMap || loroObject instanceof loroCrdt.LoroMovableList) {
+          setLoroContainerSnapshot(loroObject, mobxKeystone.getSnapshot(boundObject));
+        }
+      } finally {
+        applyingLoroChangesToMobxKeystone--;
+      }
+    });
+    const loroUnsubscribe = loroDoc.subscribe(loroSubscribeCb);
+    let pendingChanges = [];
+    const disposeOnDeepChange = mobxKeystone.onDeepChange(boundObject, (change) => {
+      if (bindingContext.isApplyingLoroChangesToMobxKeystone) {
+        return;
+      }
+      if (change.isInit) {
+        return;
+      }
+      if (change.type === mobxKeystone.DeepChangeType.ArraySplice) {
+        const resolved = mobxKeystone.resolvePath(boundObject, change.path);
+        if (resolved.resolved && isInMoveContextForArray(resolved.value)) {
+          const moveResult = processChangeForMove(change);
+          if (moveResult === void 0) {
+            return;
+          }
+          pendingChanges.push(moveResult);
+          return;
+        }
+      }
+      pendingChanges.push(captureChangeSnapshots(change));
+    });
+    const disposeOnSnapshot = mobxKeystone.onSnapshot(boundObject, () => {
+      if (pendingChanges.length === 0) {
+        return;
+      }
+      const changesToApply = pendingChanges;
+      pendingChanges = [];
+      if (bindingContext.isApplyingLoroChangesToMobxKeystone) {
+        return;
+      }
+      loroDoc.setNextCommitOrigin(loroOrigin);
+      for (const change of changesToApply) {
+        applyMobxChangeToLoroObject(change, loroObject);
+      }
+      loroDoc.commit();
+      if (loroObject instanceof loroCrdt.LoroMap || loroObject instanceof loroCrdt.LoroMovableList) {
+        setLoroContainerSnapshot(loroObject, mobxKeystone.getSnapshot(boundObject));
+      }
+      getOrCreateLoroCollectionAtom(loroObject).reportChanged();
+    });
+    const finalSnapshot = mobxKeystone.getSnapshot(boundObject);
+    if (hasInitChanges) {
+      loroDoc.setNextCommitOrigin(loroOrigin);
+      if (loroObject instanceof loroCrdt.LoroMap) {
+        applyJsonObjectToLoroMap(loroObject, finalSnapshot, { mode: "merge" });
+      } else if (loroObject instanceof loroCrdt.LoroMovableList) {
+        applyJsonArrayToLoroMovableList(loroObject, finalSnapshot, { mode: "merge" });
+      } else if (loroObject instanceof loroCrdt.LoroText) {
+        const snapshot = finalSnapshot;
+        if (snapshot.$modelType === loroTextModelId) {
+          if (loroObject.length > 0) {
+            loroObject.delete(0, loroObject.length);
+          }
+          const deltas = extractTextDeltaFromSnapshot(snapshot.deltaList);
+          if (deltas.length > 0) {
+            applyDeltaToLoroText(loroObject, deltas);
+          }
+        }
+      }
+      loroDoc.commit();
+    }
+    if (loroObject instanceof loroCrdt.LoroMap || loroObject instanceof loroCrdt.LoroMovableList) {
+      setLoroContainerSnapshot(loroObject, finalSnapshot);
+    }
+    const dispose = () => {
+      loroUnsubscribe();
+      disposeOnDeepChange();
+      disposeOnSnapshot();
+    };
+    return {
+      boundObject,
+      dispose,
+      loroOrigin
+    };
+  }
+  exports2.MobxKeystoneLoroError = MobxKeystoneLoroError;
+  exports2.applyJsonArrayToLoroMovableList = applyJsonArrayToLoroMovableList;
+  exports2.applyJsonObjectToLoroMap = applyJsonObjectToLoroMap;
+  exports2.bindLoroToMobxKeystone = bindLoroToMobxKeystone;
+  exports2.convertJsonToLoroData = convertJsonToLoroData;
+  exports2.isLoroTextModelSnapshot = isLoroTextModelSnapshot;
+  exports2.loroBindingContext = loroBindingContext;
+  exports2.loroTextModelType = loroTextModelType;
+  exports2.moveWithinArray = moveWithinArray;
+  Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
+}));
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"mobx-keystone-loro.umd.js","sources":["../node_modules/nanoid/index.browser.js","../src/utils/getOrCreateLoroCollectionAtom.ts","../src/utils/error.ts","../src/binding/loroBindingContext.ts","../src/binding/resolveLoroPath.ts","../src/binding/LoroTextModel.ts","../src/binding/convertLoroDataToJson.ts","../src/binding/applyLoroEventToMobx.ts","../src/utils/isBindableLoroContainer.ts","../src/binding/loroSnapshotTracking.ts","../src/binding/convertJsonToLoroData.ts","../src/binding/applyMobxChangeToLoroObject.ts","../src/binding/moveWithinArray.ts","../src/binding/bindLoroToMobxKeystone.ts"],"sourcesContent":["import { urlAlphabet } from './url-alphabet/index.js'\nlet random = bytes => crypto.getRandomValues(new Uint8Array(bytes))\nlet customRandom = (alphabet, defaultSize, getRandom) => {\n  let mask = (2 << (Math.log(alphabet.length - 1) / Math.LN2)) - 1\n  let step = -~((1.6 * mask * defaultSize) / alphabet.length)\n  return (size = defaultSize) => {\n    let id = ''\n    while (true) {\n      let bytes = getRandom(step)\n      let j = step | 0\n      while (j--) {\n        id += alphabet[bytes[j] & mask] || ''\n        if (id.length === size) return id\n      }\n    }\n  }\n}\nlet customAlphabet = (alphabet, size = 21) =>\n  customRandom(alphabet, size, random)\nlet nanoid = (size = 21) =>\n  crypto.getRandomValues(new Uint8Array(size)).reduce((id, byte) => {\n    byte &= 63\n    if (byte < 36) {\n      id += byte.toString(36)\n    } else if (byte < 62) {\n      id += (byte - 26).toString(36).toUpperCase()\n    } else if (byte > 62) {\n      id += '-'\n    } else {\n      id += '_'\n    }\n    return id\n  }, '')\nexport { nanoid, customAlphabet, customRandom, urlAlphabet, random }\n","import { createAtom, type IAtom } from \"mobx\"\nimport type { BindableLoroContainer } from \"./isBindableLoroContainer\"\n\nconst atomMap = new WeakMap<BindableLoroContainer, IAtom>()\n\n/**\n * Gets or creates a MobX atom for a Loro collection.\n * This is used to track reactivity for computed properties that read from Loro containers.\n */\nexport function getOrCreateLoroCollectionAtom(collection: BindableLoroContainer): IAtom {\n  let atom = atomMap.get(collection)\n  if (!atom) {\n    atom = createAtom(`loroCollectionAtom`)\n    atomMap.set(collection, atom)\n  }\n  return atom\n}\n","export class MobxKeystoneLoroError extends Error {\n  constructor(msg: string) {\n    super(msg)\n\n    // Set the prototype explicitly for better instanceof support\n    Object.setPrototypeOf(this, MobxKeystoneLoroError.prototype)\n  }\n}\n\nexport function failure(message: string): never {\n  throw new MobxKeystoneLoroError(message)\n}\n","import type { LoroDoc } from \"loro-crdt\"\nimport { type AnyType, createContext } from \"mobx-keystone\"\nimport type { BindableLoroContainer } from \"../utils/isBindableLoroContainer\"\n\n/**\n * Context for the Loro binding, providing access to the Loro document\n * and binding state from within mobx-keystone models.\n */\nexport interface LoroBindingContext {\n  /**\n   * The Loro document being bound.\n   */\n  loroDoc: LoroDoc\n\n  /**\n   * The root Loro object being bound.\n   */\n  loroObject: BindableLoroContainer\n\n  /**\n   * The mobx-keystone model type being used.\n   */\n  mobxKeystoneType: AnyType\n\n  /**\n   * String used as origin for Loro transactions to identify changes\n   * coming from mobx-keystone.\n   */\n  loroOrigin: string\n\n  /**\n   * The bound mobx-keystone object (once created).\n   */\n  boundObject: unknown\n\n  /**\n   * Whether changes are currently being applied from Loro to mobx-keystone.\n   * Used to prevent infinite loops.\n   */\n  isApplyingLoroChangesToMobxKeystone: boolean\n}\n\n/**\n * Context for accessing the Loro binding from within mobx-keystone models.\n */\nexport const loroBindingContext = createContext<LoroBindingContext | undefined>(undefined)\n","import { LoroMap, LoroMovableList } from \"loro-crdt\"\nimport type { Path } from \"mobx-keystone\"\nimport { failure } from \"../utils/error\"\nimport { getOrCreateLoroCollectionAtom } from \"../utils/getOrCreateLoroCollectionAtom\"\nimport type { BindableLoroContainer } from \"../utils/isBindableLoroContainer\"\n\n/**\n * Resolves a path within a Loro object structure.\n * Returns the Loro container at the specified path.\n *\n * @param loroObject The root Loro object\n * @param path Array of keys/indices to traverse\n * @returns The Loro container at the path\n */\nexport function resolveLoroPath(loroObject: BindableLoroContainer, path: Path): unknown {\n  let currentLoroObject: unknown = loroObject\n\n  path.forEach((pathPart, i) => {\n    if (currentLoroObject instanceof LoroMap) {\n      getOrCreateLoroCollectionAtom(currentLoroObject).reportObserved()\n      const key = String(pathPart)\n      currentLoroObject = currentLoroObject.get(key)\n    } else if (currentLoroObject instanceof LoroMovableList) {\n      getOrCreateLoroCollectionAtom(currentLoroObject).reportObserved()\n      const key = Number(pathPart)\n      currentLoroObject = currentLoroObject.get(key)\n    } else {\n      throw failure(\n        `LoroMap or LoroMovableList was expected at path ${JSON.stringify(\n          path.slice(0, i)\n        )} in order to resolve path ${JSON.stringify(path)}, but got ${currentLoroObject} instead`\n      )\n    }\n  })\n\n  return currentLoroObject\n}\n","import { type Delta, LoroText } from \"loro-crdt\"\r\nimport { computed, createAtom } from \"mobx\"\r\nimport {\r\n  frozen,\r\n  getParentToChildPath,\r\n  getSnapshotModelType,\r\n  Model,\r\n  model,\r\n  modelAction,\r\n  type SnapshotOutOf,\r\n  tProp,\r\n  types,\r\n} from \"mobx-keystone\"\r\nimport { getOrCreateLoroCollectionAtom } from \"../utils/getOrCreateLoroCollectionAtom\"\r\nimport { loroBindingContext } from \"./loroBindingContext\"\r\nimport { resolveLoroPath } from \"./resolveLoroPath\"\r\n\r\nexport const loroTextModelId = \"mobx-keystone-loro/LoroTextModel\"\r\n\r\n/**\r\n * Type for the delta stored in the model.\r\n * Uses Quill delta format: array of operations with insert, delete, retain.\r\n */\r\nexport type LoroTextDeltaList = Delta<string>[]\r\n\r\n/**\r\n * A mobx-keystone model representing Loro rich text.\r\n * This model stores the current delta state (Quill format) and syncs with LoroText.\r\n */\r\n@model(loroTextModelId)\r\nexport class LoroTextModel extends Model({\r\n  /**\r\n   * The current delta representing the rich text content.\r\n   * Uses Quill delta format.\r\n   */\r\n  deltaList: tProp(types.frozen(types.unchecked<LoroTextDeltaList>()), () => frozen([])),\r\n}) {\r\n  /**\r\n   * Creates a LoroTextModel with initial text content.\r\n   */\r\n  static withText(text: string): LoroTextModel {\r\n    return new LoroTextModel({\r\n      deltaList: frozen([{ insert: text }]),\r\n    })\r\n  }\r\n\r\n  /**\r\n   * Creates a LoroTextModel with initial delta.\r\n   */\r\n  static withDelta(delta: LoroTextDeltaList): LoroTextModel {\r\n    return new LoroTextModel({\r\n      deltaList: frozen(delta),\r\n    })\r\n  }\r\n\r\n  /**\r\n   * Atom that gets changed when the associated Loro text changes.\r\n   */\r\n  loroTextChangedAtom = createAtom(\"loroTextChangedAtom\")\r\n\r\n  /**\r\n   * The LoroText object represented by this mobx-keystone node, if bound.\r\n   * Returns undefined when the model is not part of a bound object tree.\r\n   */\r\n  @computed\r\n  get loroText(): LoroText | undefined {\r\n    // Check if we have a binding context first - return undefined if not bound\r\n    const ctx = loroBindingContext.get(this)\r\n    if (ctx?.boundObject == null) {\r\n      return undefined\r\n    }\r\n\r\n    try {\r\n      const path = getParentToChildPath(ctx.boundObject, this)\r\n      if (!path) {\r\n        return undefined\r\n      }\r\n\r\n      // If this model IS the bound object, the loroObject is the LoroText\r\n      if (path.length === 0) {\r\n        const loroObject = ctx.loroObject\r\n        if (loroObject instanceof LoroText) {\r\n          getOrCreateLoroCollectionAtom(loroObject).reportObserved()\r\n          return loroObject\r\n        }\r\n        return undefined\r\n      }\r\n\r\n      // Otherwise resolve the path\r\n      const loroObject = resolveLoroPath(ctx.loroObject, path)\r\n\r\n      if (loroObject instanceof LoroText) {\r\n        getOrCreateLoroCollectionAtom(loroObject).reportObserved()\r\n        return loroObject\r\n      }\r\n    } catch {\r\n      // Path resolution failed - return undefined\r\n    }\r\n\r\n    return undefined\r\n  }\r\n\r\n  /**\r\n   * Gets the plain text content.\r\n   * This always uses the stored delta, which is kept in sync with Loro.\r\n   */\r\n  @computed\r\n  get text(): string {\r\n    this.loroTextChangedAtom.reportObserved()\r\n\r\n    // Always compute from delta - it's the source of truth for this model\r\n    // The delta is kept in sync with Loro via patches\r\n    return this.deltaToText(this.deltaList.data)\r\n  }\r\n\r\n  /**\r\n   * Gets the current delta (Quill format).\r\n   */\r\n  @computed\r\n  get currentDelta(): LoroTextDeltaList {\r\n    this.loroTextChangedAtom.reportObserved()\r\n\r\n    // Try to get from bound LoroText first\r\n    const loroText = this.loroText\r\n    if (loroText) {\r\n      try {\r\n        return loroText.toDelta()\r\n      } catch {\r\n        // fall back to stored delta\r\n      }\r\n    }\r\n\r\n    return this.deltaList.data\r\n  }\r\n\r\n  /**\r\n   * Converts delta to plain text.\r\n   */\r\n  private deltaToText(delta: LoroTextDeltaList): string {\r\n    let result = \"\"\r\n    for (const op of delta) {\r\n      if (\"insert\" in op && typeof op.insert === \"string\") {\r\n        result += op.insert\r\n      }\r\n    }\r\n    return result\r\n  }\r\n\r\n  /**\r\n   * Sets the delta.\r\n   */\r\n  @modelAction\r\n  setDelta(delta: LoroTextDeltaList): void {\r\n    this.deltaList = frozen(delta)\r\n  }\r\n\r\n  /**\r\n   * Inserts text at the specified position.\r\n   */\r\n  @modelAction\r\n  insertText(index: number, text: string): void {\r\n    const loroText = this.loroText\r\n    if (loroText) {\r\n      loroText.insert(index, text)\r\n      // The binding will handle syncing back\r\n    } else {\r\n      // Fallback: modify delta directly\r\n      const currentText = this.text\r\n      const newText = currentText.slice(0, index) + text + currentText.slice(index)\r\n      this.deltaList = frozen([{ insert: newText }])\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Deletes text at the specified range.\r\n   */\r\n  @modelAction\r\n  deleteText(index: number, length: number): void {\r\n    const loroText = this.loroText\r\n    if (loroText) {\r\n      loroText.delete(index, length)\r\n      // The binding will handle syncing back\r\n    } else {\r\n      // Fallback: modify delta directly\r\n      const currentText = this.text\r\n      const newText = currentText.slice(0, index) + currentText.slice(index + length)\r\n      this.deltaList = frozen([{ insert: newText }])\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Internal action to update delta from Loro sync.\r\n   * @internal\r\n   */\r\n  @modelAction\r\n  _updateDeltaFromLoro(delta: LoroTextDeltaList): void {\r\n    this.deltaList = frozen(delta)\r\n  }\r\n}\r\n\r\n/**\r\n * Type for LoroTextModel for use with tProp.\r\n */\r\nexport const loroTextModelType = types.model(LoroTextModel)\r\n\r\n/**\r\n * Checks if a snapshot is a LoroTextModel snapshot.\r\n */\r\nexport function isLoroTextModelSnapshot(value: unknown): value is SnapshotOutOf<LoroTextModel> {\r\n  return getSnapshotModelType(value) === loroTextModelId\r\n}\r\n","import { isContainer, LoroMap, LoroMovableList, LoroText } from \"loro-crdt\"\nimport { modelSnapshotOutWithMetadata, toFrozenSnapshot } from \"mobx-keystone\"\nimport type { PlainValue } from \"../plainTypes\"\nimport { failure } from \"../utils/error\"\nimport { type BindableLoroContainer } from \"../utils/isBindableLoroContainer\"\nimport { LoroTextModel } from \"./LoroTextModel\"\n\ntype LoroValue = BindableLoroContainer | PlainValue\n\n/**\n * Converts Loro data to JSON-compatible format for mobx-keystone snapshots.\n *\n * @param value The Loro value to convert\n * @returns JSON-compatible value\n */\nexport function convertLoroDataToJson(value: LoroValue): PlainValue {\n  if (value === null) {\n    return null\n  }\n\n  if (typeof value !== \"object\") {\n    if (value === undefined) {\n      throw new Error(\"undefined values are not supported by Loro\")\n    }\n\n    return value as PlainValue\n  }\n\n  if (isContainer(value)) {\n    if (value instanceof LoroMap) {\n      const result: Record<string, PlainValue> = {}\n      for (const [k, v] of value.entries()) {\n        result[k] = convertLoroDataToJson(v as LoroValue)\n      }\n      return result\n    }\n\n    if (value instanceof LoroMovableList) {\n      const result: PlainValue[] = []\n      for (let i = 0; i < value.length; i++) {\n        result.push(convertLoroDataToJson(value.get(i) as LoroValue))\n      }\n      return result\n    }\n\n    if (value instanceof LoroText) {\n      const deltas = value.toDelta()\n      // Return a LoroTextModel-compatible snapshot\n      return modelSnapshotOutWithMetadata(LoroTextModel, {\n        deltaList: toFrozenSnapshot(deltas),\n      }) as unknown as PlainValue\n    }\n\n    throw failure(`unsupported bindable Loro container type`)\n  }\n\n  // Plain object or array\n  if (Array.isArray(value)) {\n    return value.map((item) => convertLoroDataToJson(item as LoroValue))\n  }\n\n  const result: Record<string, PlainValue> = {}\n  for (const [k, v] of Object.entries(value)) {\n    result[k] = convertLoroDataToJson(v as LoroValue)\n  }\n\n  return result\n}\n","import type { ContainerID, ListDiff, LoroDoc, LoroEvent, MapDiff } from \"loro-crdt\"\nimport { isContainer, LoroMap, LoroMovableList, LoroText } from \"loro-crdt\"\nimport { remove } from \"mobx\"\nimport {\n  Frozen,\n  fromSnapshot,\n  frozen,\n  getSnapshotModelId,\n  isDataModel,\n  isFrozenSnapshot,\n  isModel,\n  modelIdKey,\n  Path,\n  resolvePath,\n  runUnprotected,\n} from \"mobx-keystone\"\nimport type { PlainValue } from \"../plainTypes\"\nimport { failure } from \"../utils/error\"\nimport { convertLoroDataToJson } from \"./convertLoroDataToJson\"\n\n// Represents the map of potential objects to reconcile (ID -> Object)\nexport type ReconciliationMap = Map<string, object>\n\n/**\n * Applies a Loro event directly to the MobX model tree using proper mutations\n * (splice for arrays, property assignment for objects).\n * This is more efficient than converting to patches first.\n */\nexport function applyLoroEventToMobx(\n  event: LoroEvent,\n  loroDoc: LoroDoc,\n  boundObject: object,\n  rootPath: Path,\n  reconciliationMap: ReconciliationMap,\n  newlyInsertedContainers: Set<ContainerID>\n): void {\n  // Skip events for containers that were just inserted as part of another container\n  // Their content is already included in the parent's convertLoroDataToJson call\n  if (newlyInsertedContainers.has(event.target)) {\n    return\n  }\n\n  // Resolve the path relative to the root\n  const eventPath = loroDoc.getPathToContainer(event.target)\n  if (!eventPath) {\n    return\n  }\n\n  // Strip the root path to get relative path\n  const relativePath = resolveEventPath(eventPath, rootPath)\n  if (relativePath === undefined) {\n    return\n  }\n\n  const { value: target } = resolvePath(boundObject, relativePath)\n\n  if (!target) {\n    throw failure(`cannot resolve path ${JSON.stringify(relativePath)}`)\n  }\n\n  // Wrap in runUnprotected since we're modifying the tree from outside a model action\n  runUnprotected(() => {\n    const diff = event.diff\n    if (diff.type === \"map\") {\n      applyMapEventToMobx(diff, loroDoc, event.target, target, reconciliationMap)\n    } else if (diff.type === \"list\") {\n      applyListEventToMobx(\n        diff,\n        loroDoc,\n        event.target,\n        target,\n        reconciliationMap,\n        newlyInsertedContainers\n      )\n    } else if (diff.type === \"text\") {\n      applyTextEventToMobx(loroDoc, event.target, target)\n    }\n  })\n}\n\nfunction processDeletedValue(val: unknown, reconciliationMap: ReconciliationMap) {\n  // Handle both Model and DataModel instances\n  if (isModel(val) || isDataModel(val)) {\n    const id = modelIdKey in val ? val[modelIdKey] : undefined\n    if (id) {\n      reconciliationMap.set(id, val)\n    }\n  }\n}\n\nfunction reviveValue(jsonValue: unknown, reconciliationMap: ReconciliationMap): unknown {\n  // Handle primitives\n  if (jsonValue === null || typeof jsonValue !== \"object\") {\n    return jsonValue\n  }\n\n  // Handle frozen\n  if (isFrozenSnapshot(jsonValue)) {\n    return frozen(jsonValue.data)\n  }\n\n  // If we have a reconciliation map and the value looks like a model with an ID, check if we have it\n  if (reconciliationMap) {\n    const modelId = getSnapshotModelId(jsonValue)\n    if (modelId) {\n      const existing = reconciliationMap.get(modelId)\n      if (existing) {\n        reconciliationMap.delete(modelId)\n        return existing\n      }\n    }\n  }\n\n  return fromSnapshot(jsonValue)\n}\n\nfunction applyMapEventToMobx(\n  diff: MapDiff,\n  loroDoc: LoroDoc,\n  containerTarget: ContainerID,\n  target: Record<string, unknown>,\n  reconciliationMap: ReconciliationMap\n): void {\n  const container = loroDoc.getContainerById(containerTarget)\n\n  if (!container || !(container instanceof LoroMap)) {\n    throw failure(`${containerTarget} was not a Loro map`)\n  }\n\n  // Process additions and updates from diff.updated\n  for (const key of Object.keys(diff.updated)) {\n    const loroValue = container.get(key)\n\n    if (loroValue === undefined) {\n      // Key was deleted (Loro returns undefined for deleted keys)\n      if (key in target) {\n        processDeletedValue(target[key], reconciliationMap)\n        // Use MobX's remove to properly delete the key from the observable object\n        if (isModel(target)) {\n          remove(target.$, key)\n        } else {\n          remove(target, key)\n        }\n      }\n    } else {\n      // Key was added or updated\n      if (key in target) {\n        processDeletedValue(target[key], reconciliationMap)\n      }\n      const jsonValue = convertLoroDataToJson(loroValue as PlainValue)\n      target[key] = reviveValue(jsonValue, reconciliationMap)\n    }\n  }\n}\n\nfunction applyListEventToMobx(\n  diff: ListDiff,\n  loroDoc: LoroDoc,\n  containerTarget: ContainerID,\n  target: unknown[],\n  reconciliationMap: ReconciliationMap,\n  newlyInsertedContainers: Set<ContainerID>\n): void {\n  const container = loroDoc.getContainerById(containerTarget)\n\n  if (!container || !(container instanceof LoroMovableList)) {\n    throw failure(`${containerTarget} was not a Loro movable list`)\n  }\n\n  // Process delta operations in order\n  let currentIndex = 0\n\n  for (const change of diff.diff) {\n    if (change.retain) {\n      currentIndex += change.retain\n    }\n\n    if (change.delete) {\n      // Capture deleted items for reconciliation\n      const deletedItems = target.slice(currentIndex, currentIndex + change.delete)\n      deletedItems.forEach((item) => {\n        processDeletedValue(item, reconciliationMap)\n      })\n\n      // Delete items at current position\n      target.splice(currentIndex, change.delete)\n    }\n\n    if (change.insert) {\n      // Insert items at current position\n      const insertedItems = change.insert\n      const values = insertedItems.map((loroValue) => {\n        // Track container IDs to avoid double-processing their events\n        // When a container with data is inserted, Loro fires events for both\n        // the container insert and the container's content, but the content\n        // is already included in convertLoroDataToJson\n        if (isContainer(loroValue)) {\n          newlyInsertedContainers.add(loroValue.id)\n          // Also recursively track any nested containers\n          collectNestedContainerIds(loroValue, newlyInsertedContainers)\n        }\n        const jsonValue = convertLoroDataToJson(loroValue as PlainValue)\n        return reviveValue(jsonValue, reconciliationMap)\n      })\n\n      target.splice(currentIndex, 0, ...values)\n      currentIndex += values.length\n    }\n  }\n}\n\nfunction applyTextEventToMobx(\n  loroDoc: LoroDoc,\n  containerTarget: ContainerID,\n  target: { deltaList?: Frozen<unknown[]> }\n): void {\n  const container = loroDoc.getContainerById(containerTarget)\n\n  if (!container || !(container instanceof LoroText)) {\n    throw failure(`${containerTarget} was not a Loro text container`)\n  }\n\n  // LoroTextModel has deltaList as a single Frozen<LoroTextDeltaList>, not an array\n  // Replace it with the current delta from the LoroText\n  if (!(\"deltaList\" in target)) {\n    throw failure(\"target does not have a deltaList property - expected LoroTextModel\")\n  }\n  target.deltaList = frozen(container.toDelta())\n}\n\n/**\n * Recursively collects all container IDs from a Loro container.\n * This is used to track containers that have been inserted and should not\n * have their events processed again (since their content was already included\n * in the parent's convertLoroDataToJson call).\n */\nfunction collectNestedContainerIds(container: unknown, containerIds: Set<ContainerID>): void {\n  if (!isContainer(container)) {\n    return\n  }\n\n  // Add this container's ID\n  containerIds.add(container.id)\n\n  // Handle LoroMap - iterate over values\n  if (container instanceof LoroMap) {\n    for (const key of Object.keys(container.toJSON())) {\n      const value = container.get(key)\n      collectNestedContainerIds(value, containerIds)\n    }\n  }\n\n  // Handle LoroMovableList - iterate over items\n  if (container instanceof LoroMovableList) {\n    for (let i = 0; i < container.length; i++) {\n      collectNestedContainerIds(container.get(i), containerIds)\n    }\n  }\n\n  // LoroText doesn't contain nested containers\n}\n\n/**\n * Resolves the path from a Loro event to a mobx-keystone path.\n * The event path is the path from the doc root to the container that emitted the event.\n * We need to strip the path of our root container to get a path relative to our bound object.\n */\nfunction resolveEventPath(eventPath: Path, rootPath: Path): Path | undefined {\n  if (eventPath.length < rootPath.length) {\n    return undefined\n  }\n\n  for (let i = 0; i < rootPath.length; i++) {\n    if (eventPath[i] !== rootPath[i]) {\n      return undefined\n    }\n  }\n\n  return eventPath.slice(rootPath.length) as Path\n}\n","import { LoroMap, LoroMovableList, LoroText } from \"loro-crdt\"\n\n/**\n * A bindable Loro container (Map, MovableList, or Text).\n */\nexport type BindableLoroContainer = LoroMap | LoroMovableList | LoroText\n\n/**\n * Checks if a value is a bindable Loro container.\n */\nexport function isBindableLoroContainer(value: unknown): value is BindableLoroContainer {\n  return value instanceof LoroMap || value instanceof LoroMovableList || value instanceof LoroText\n}\n","import type { LoroMap, LoroMovableList } from \"loro-crdt\"\n\ntype LoroContainer = LoroMap | LoroMovableList\n\n/**\n * WeakMap that tracks which snapshot each Loro container was last synced from.\n * This is used during reconciliation to skip containers that are already up-to-date.\n *\n * The key is the Loro container (LoroMap or LoroMovableList).\n * The value is the snapshot (plain object or array) that was last synced to it.\n */\nexport const loroContainerToSnapshot = new WeakMap<LoroContainer, unknown>()\n\n/**\n * Updates the snapshot tracking for a Loro container.\n * Call this after syncing a snapshot to a Loro container.\n */\nexport function setLoroContainerSnapshot(container: LoroContainer, snapshot: unknown): void {\n  loroContainerToSnapshot.set(container, snapshot)\n}\n\n/**\n * Gets the last synced snapshot for a Loro container.\n * Returns undefined if the container has never been synced.\n */\nexport function getLoroContainerSnapshot(container: LoroContainer): unknown {\n  return loroContainerToSnapshot.get(container)\n}\n\n/**\n * Checks if a Loro container is up-to-date with the given snapshot.\n * Uses reference equality to check if the snapshot is the same.\n */\nexport function isLoroContainerUpToDate(container: LoroContainer, snapshot: unknown): boolean {\n  return loroContainerToSnapshot.get(container) === snapshot\n}\n","import type { Delta } from \"loro-crdt\"\nimport { LoroMap, LoroMovableList, LoroText } from \"loro-crdt\"\nimport { frozenKey, isFrozenSnapshot } from \"mobx-keystone\"\nimport type { PlainArray, PlainObject, PlainPrimitive, PlainValue } from \"../plainTypes\"\nimport {\n  type BindableLoroContainer,\n  isBindableLoroContainer,\n} from \"../utils/isBindableLoroContainer\"\nimport { isLoroTextModelSnapshot } from \"./LoroTextModel\"\nimport { isLoroContainerUpToDate, setLoroContainerSnapshot } from \"./loroSnapshotTracking\"\n\ntype LoroValue = BindableLoroContainer | PlainValue\n\n/**\n * Options for applying JSON data to Loro data structures.\n */\nexport interface ApplyJsonToLoroOptions {\n  /**\n   * The mode to use when applying JSON data to Loro data structures.\n   * - `add`: Creates new Loro containers for objects/arrays (default, backwards compatible)\n   * - `merge`: Recursively merges values, preserving existing container references where possible\n   */\n  mode?: \"add\" | \"merge\"\n}\n\nfunction isPlainPrimitive(v: PlainValue): v is PlainPrimitive {\n  const t = typeof v\n  return t === \"string\" || t === \"number\" || t === \"boolean\" || v === null || v === undefined\n}\n\nfunction isPlainArray(v: PlainValue): v is PlainArray {\n  return Array.isArray(v)\n}\n\nfunction isPlainObject(v: PlainValue): v is PlainObject {\n  return typeof v === \"object\" && v !== null && !Array.isArray(v)\n}\n\n/**\n * Extracts delta array from a LoroTextModel snapshot's delta field.\n * The delta field is a frozen Delta<string>[] (array of delta operations).\n */\nexport function extractTextDeltaFromSnapshot(delta: unknown): Delta<string>[] {\n  // The delta field is frozen, so we need to extract it\n  if (isFrozenSnapshot<Delta<string>[]>(delta)) {\n    const data = delta.data\n    if (Array.isArray(data)) {\n      return data\n    }\n  }\n\n  // Handle plain delta array (not wrapped in frozen)\n  if (Array.isArray(delta)) {\n    return delta as Delta<string>[]\n  }\n\n  return []\n}\n\n/**\n * Applies delta operations to a LoroText using insert/mark APIs.\n * This works on both attached and detached containers.\n *\n * Strategy: Insert all text first, then apply marks. This avoids mark inheritance\n * issues when inserting at the boundary of a marked region.\n */\nexport function applyDeltaToLoroText(text: LoroText, deltas: Delta<string>[]): void {\n  // Phase 1: Insert all text content\n  let position = 0\n  const markOperations: Array<{\n    start: number\n    end: number\n    attributes: Record<string, unknown>\n  }> = []\n\n  for (const delta of deltas) {\n    if (delta.insert !== undefined) {\n      const content = delta.insert\n      text.insert(position, content)\n\n      // Collect mark operations to apply later\n      if (delta.attributes && Object.keys(delta.attributes).length > 0) {\n        markOperations.push({\n          start: position,\n          end: position + content.length,\n          attributes: delta.attributes,\n        })\n      }\n\n      position += content.length\n    } else if (delta.retain) {\n      position += delta.retain\n    } else if (delta.delete) {\n      text.delete(position, delta.delete)\n    }\n  }\n\n  // Phase 2: Apply all marks after text is inserted\n  for (const op of markOperations) {\n    for (const [key, value] of Object.entries(op.attributes)) {\n      text.mark({ start: op.start, end: op.end }, key, value)\n    }\n  }\n}\n\n/**\n * Converts a plain value to a Loro data structure.\n * Objects are converted to LoroMaps, arrays to LoroMovableLists, primitives are untouched.\n * Frozen values are a special case and they are kept as immutable plain values.\n */\nexport function convertJsonToLoroData(v: PlainValue): LoroValue {\n  if (isPlainPrimitive(v)) {\n    return v\n  }\n\n  if (isPlainArray(v)) {\n    const list = new LoroMovableList()\n    applyJsonArrayToLoroMovableList(list, v)\n    return list\n  }\n\n  if (isPlainObject(v)) {\n    if (v[frozenKey] === true) {\n      // frozen value with explicit $frozen marker (shouldn't reach here after above check)\n      return v\n    }\n\n    if (isLoroTextModelSnapshot(v)) {\n      const text = new LoroText()\n      // Extract delta from the snapshot and apply using insert/mark APIs\n      // (applyDelta doesn't work on detached containers, but insert/mark do)\n      const deltas = extractTextDeltaFromSnapshot(v.deltaList)\n      if (deltas.length > 0) {\n        applyDeltaToLoroText(text, deltas)\n      }\n      return text\n    }\n\n    const map = new LoroMap()\n    applyJsonObjectToLoroMap(map, v)\n    return map\n  }\n\n  throw new Error(`unsupported value type: ${v}`)\n}\n\n/**\n * Applies a JSON array to a LoroMovableList, using convertJsonToLoroData to convert the values.\n *\n * @param dest The destination LoroMovableList.\n * @param source The source JSON array.\n * @param options Options for applying the JSON data.\n */\nexport const applyJsonArrayToLoroMovableList = (\n  dest: LoroMovableList,\n  source: PlainArray,\n  options: ApplyJsonToLoroOptions = {}\n) => {\n  const { mode = \"add\" } = options\n\n  if (mode === \"add\") {\n    // Add mode: just push all items to the end\n    for (const item of source) {\n      const converted = convertJsonToLoroData(item)\n      if (isBindableLoroContainer(converted)) {\n        dest.pushContainer(converted)\n      } else {\n        dest.push(converted)\n      }\n    }\n    return\n  }\n\n  // Merge mode: recursively merge values, preserving existing container references\n  // In merge mode, check if the container is already up-to-date with this snapshot\n  if (isLoroContainerUpToDate(dest, source)) {\n    return\n  }\n\n  // Remove extra items from the end\n  const destLen = dest.length\n  const srcLen = source.length\n  if (destLen > srcLen) {\n    dest.delete(srcLen, destLen - srcLen)\n  }\n\n  // Update existing items\n  const minLen = Math.min(destLen, srcLen)\n  for (let i = 0; i < minLen; i++) {\n    const srcItem = source[i]\n    const destItem = dest.get(i)\n\n    // If both are objects, merge recursively\n    if (isPlainObject(srcItem) && destItem instanceof LoroMap) {\n      applyJsonObjectToLoroMap(destItem, srcItem, options)\n      continue\n    }\n\n    // If both are arrays, merge recursively\n    if (isPlainArray(srcItem) && destItem instanceof LoroMovableList) {\n      applyJsonArrayToLoroMovableList(destItem, srcItem, options)\n      continue\n    }\n\n    // Skip if primitive value is unchanged (optimization)\n    if (isPlainPrimitive(srcItem) && destItem === srcItem) {\n      continue\n    }\n\n    // Otherwise, replace the item\n    dest.delete(i, 1)\n    const converted = convertJsonToLoroData(srcItem)\n    if (isBindableLoroContainer(converted)) {\n      dest.insertContainer(i, converted)\n    } else {\n      dest.insert(i, converted)\n    }\n  }\n\n  // Add new items at the end\n  for (let i = destLen; i < srcLen; i++) {\n    const converted = convertJsonToLoroData(source[i])\n    if (isBindableLoroContainer(converted)) {\n      dest.pushContainer(converted)\n    } else {\n      dest.push(converted)\n    }\n  }\n\n  // Update snapshot tracking after successful merge\n  setLoroContainerSnapshot(dest, source)\n}\n\n/**\n * Applies a JSON object to a LoroMap, using convertJsonToLoroData to convert the values.\n *\n * @param dest The destination LoroMap.\n * @param source The source JSON object.\n * @param options Options for applying the JSON data.\n */\nexport const applyJsonObjectToLoroMap = (\n  dest: LoroMap,\n  source: PlainObject,\n  options: ApplyJsonToLoroOptions = {}\n) => {\n  const { mode = \"add\" } = options\n\n  if (mode === \"add\") {\n    // Add mode: just set all values\n    for (const k of Object.keys(source)) {\n      const v = source[k]\n      if (v !== undefined) {\n        const converted = convertJsonToLoroData(v)\n        if (isBindableLoroContainer(converted)) {\n          dest.setContainer(k, converted)\n        } else {\n          dest.set(k, converted)\n        }\n      }\n    }\n    return\n  }\n\n  // Merge mode: recursively merge values, preserving existing container references\n  // In merge mode, check if the container is already up-to-date with this snapshot\n  if (isLoroContainerUpToDate(dest, source)) {\n    return\n  }\n\n  // Delete keys that are not present in source (or have undefined value)\n  const sourceKeysWithValues = new Set(Object.keys(source).filter((k) => source[k] !== undefined))\n  for (const key of dest.keys()) {\n    if (!sourceKeysWithValues.has(key)) {\n      dest.delete(key)\n    }\n  }\n\n  for (const k of Object.keys(source)) {\n    const v = source[k]\n    // Skip undefined values - Loro maps cannot store undefined\n    if (v === undefined) {\n      continue\n    }\n\n    const existing = dest.get(k)\n\n    // If source is an object and dest has a LoroMap, merge recursively\n    if (isPlainObject(v) && existing instanceof LoroMap) {\n      applyJsonObjectToLoroMap(existing, v, options)\n      continue\n    }\n\n    // If source is an array and dest has a LoroMovableList, merge recursively\n    if (isPlainArray(v) && existing instanceof LoroMovableList) {\n      applyJsonArrayToLoroMovableList(existing, v, options)\n      continue\n    }\n\n    // Skip if primitive value is unchanged (optimization)\n    if (isPlainPrimitive(v) && existing === v) {\n      continue\n    }\n\n    // Otherwise, convert and set the value (this creates new containers if needed)\n    const converted = convertJsonToLoroData(v)\n    if (isBindableLoroContainer(converted)) {\n      dest.setContainer(k, converted)\n    } else {\n      dest.set(k, converted)\n    }\n  }\n\n  // Update snapshot tracking after successful merge\n  setLoroContainerSnapshot(dest, source)\n}\n","import { LoroMap, LoroMovableList, LoroText } from \"loro-crdt\"\nimport { DeepChange, DeepChangeType } from \"mobx-keystone\"\nimport type { PlainValue } from \"../plainTypes\"\nimport { failure } from \"../utils/error\"\nimport type { BindableLoroContainer } from \"../utils/isBindableLoroContainer\"\nimport {\n  applyDeltaToLoroText,\n  convertJsonToLoroData,\n  extractTextDeltaFromSnapshot,\n} from \"./convertJsonToLoroData\"\nimport { isLoroTextModelSnapshot } from \"./LoroTextModel\"\nimport type { ArrayMoveChange } from \"./moveWithinArray\"\nimport { resolveLoroPath } from \"./resolveLoroPath\"\n\n/**\n * Converts a snapshot value to a Loro-compatible value.\n * Note: All values passed here are already snapshots (captured at change time).\n */\nfunction convertValue(v: unknown): unknown {\n  // Handle primitives directly\n  if (v === null || v === undefined || typeof v !== \"object\") {\n    return v\n  }\n  // Handle plain arrays - used for empty array init\n  if (Array.isArray(v) && v.length === 0) {\n    return new LoroMovableList()\n  }\n  // Handle LoroTextModel snapshot specially - we need to return it as-is\n  // so the caller can handle creating the LoroText container properly\n  if (isLoroTextModelSnapshot(v)) {\n    return v\n  }\n  // Value is already a snapshot, convert to Loro data\n  return convertJsonToLoroData(v as PlainValue)\n}\n\n/**\n * Inserts a value into a LoroMovableList at the given index.\n */\nfunction insertIntoList(list: LoroMovableList, index: number, value: unknown): void {\n  if (value instanceof LoroMap || value instanceof LoroMovableList || value instanceof LoroText) {\n    list.insertContainer(index, value)\n  } else if (isLoroTextModelSnapshot(value)) {\n    const attachedText = list.insertContainer(index, new LoroText())\n    const deltas = extractTextDeltaFromSnapshot((value as any).deltaList)\n    if (deltas.length > 0) {\n      applyDeltaToLoroText(attachedText, deltas)\n    }\n  } else {\n    list.insert(index, value)\n  }\n}\n\n/**\n * Sets a value in a LoroMap at the given key.\n */\nfunction setInMap(map: LoroMap, key: string, value: unknown): void {\n  if (value === undefined) {\n    map.delete(key)\n  } else if (\n    value instanceof LoroMap ||\n    value instanceof LoroMovableList ||\n    value instanceof LoroText\n  ) {\n    map.setContainer(key, value)\n  } else if (isLoroTextModelSnapshot(value)) {\n    const attachedText = map.setContainer(key, new LoroText())\n    const deltas = extractTextDeltaFromSnapshot((value as any).deltaList)\n    if (deltas.length > 0) {\n      applyDeltaToLoroText(attachedText, deltas)\n    }\n  } else {\n    map.set(key, value)\n  }\n}\n\n/**\n * Applies a MobX DeepChange or an ArrayMoveChange to a Loro object.\n */\nexport function applyMobxChangeToLoroObject(\n  change: DeepChange | ArrayMoveChange,\n  loroObject: BindableLoroContainer\n): void {\n  const loroContainer = resolveLoroPath(loroObject, change.path)\n\n  // If container doesn't exist at this path, throw an error\n  if (!loroContainer) {\n    throw failure(\n      `cannot apply change to missing Loro container at path: ${JSON.stringify(change.path)}`\n    )\n  }\n\n  switch (change.type) {\n    case \"ArrayMove\": {\n      if (!(loroContainer instanceof LoroMovableList)) {\n        throw failure(`ArrayMove change requires a LoroMovableList container`)\n      }\n      loroContainer.move(change.fromIndex, change.toIndex)\n      break\n    }\n\n    case DeepChangeType.ArraySplice: {\n      if (!(loroContainer instanceof LoroMovableList)) {\n        throw failure(`ArraySplice change requires a LoroMovableList container`)\n      }\n      if (change.removedValues.length > 0) {\n        loroContainer.delete(change.index, change.removedValues.length)\n      }\n      if (change.addedValues.length > 0) {\n        const valuesToInsert = change.addedValues.map(convertValue)\n        for (let i = 0; i < valuesToInsert.length; i++) {\n          insertIntoList(loroContainer, change.index + i, valuesToInsert[i])\n        }\n      }\n      break\n    }\n\n    case DeepChangeType.ArrayUpdate: {\n      if (!(loroContainer instanceof LoroMovableList)) {\n        throw failure(`ArrayUpdate change requires a LoroMovableList container`)\n      }\n      const converted = convertValue(change.newValue)\n      if (\n        converted instanceof LoroMap ||\n        converted instanceof LoroMovableList ||\n        converted instanceof LoroText\n      ) {\n        loroContainer.setContainer(change.index, converted)\n      } else if (isLoroTextModelSnapshot(converted)) {\n        const attachedText = loroContainer.setContainer(change.index, new LoroText())\n        const deltas = extractTextDeltaFromSnapshot((converted as any).deltaList)\n        if (deltas.length > 0) {\n          applyDeltaToLoroText(attachedText, deltas)\n        }\n      } else {\n        loroContainer.set(change.index, converted)\n      }\n      break\n    }\n\n    case DeepChangeType.ObjectAdd:\n    case DeepChangeType.ObjectUpdate: {\n      if (loroContainer instanceof LoroText) {\n        // Handle changes to LoroText properties (mainly deltaList)\n        if (change.key === \"deltaList\") {\n          // change.newValue is already a snapshot (captured at change time)\n          const deltas = extractTextDeltaFromSnapshot(change.newValue)\n          if (loroContainer.length > 0) {\n            loroContainer.delete(0, loroContainer.length)\n          }\n          if (deltas.length > 0) {\n            applyDeltaToLoroText(loroContainer, deltas)\n          }\n        }\n        // ignore other property changes on LoroText as they're not synced\n      } else if (loroContainer instanceof LoroMap) {\n        const converted = convertValue(change.newValue)\n        setInMap(loroContainer, change.key, converted)\n      } else {\n        throw failure(`ObjectAdd/ObjectUpdate change requires a LoroMap or LoroText container`)\n      }\n      break\n    }\n\n    case DeepChangeType.ObjectRemove: {\n      if (loroContainer instanceof LoroText) {\n        // ignore removes on LoroText properties\n      } else if (loroContainer instanceof LoroMap) {\n        loroContainer.delete(change.key)\n      } else {\n        throw failure(`ObjectRemove change requires a LoroMap or LoroText container`)\n      }\n      break\n    }\n\n    default: {\n      // Exhaustive check - TypeScript will error if we miss a case\n      const _exhaustiveCheck: never = change\n      throw failure(`unsupported change type: ${(_exhaustiveCheck as any).type}`)\n    }\n  }\n}\n","import { DeepChange } from \"mobx-keystone\"\n\n/**\n * Synthetic change type for array moves.\n */\nexport interface ArrayMoveChange {\n  type: \"ArrayMove\"\n  path: readonly (string | number)[]\n  fromIndex: number\n  toIndex: number\n}\n\n/**\n * Tracks the currently active move operation.\n * When set, the next two splice operations on this array are intercepted.\n */\nlet activeMoveContext:\n  | {\n      array: unknown[]\n      fromIndex: number\n      toIndex: number\n      path: readonly (string | number)[] | undefined // Captured from first splice\n      receivedFirstSplice: boolean\n    }\n  | undefined\n\n/**\n * Moves an item within an array from one index to another.\n *\n * When used on a mobx-keystone array bound to a Loro movable list,\n * this translates to a native Loro move operation for optimal CRDT merging.\n *\n * For unbound arrays, performs a standard splice-based move.\n *\n * @param array The array to move within\n * @param fromIndex The index of the item to move\n * @param toIndex The target index to move the item to\n */\nexport function moveWithinArray<T>(array: T[], fromIndex: number, toIndex: number): void {\n  // Validate indices\n  if (fromIndex < 0 || fromIndex >= array.length) {\n    throw new Error(`fromIndex ${fromIndex} is out of bounds (array length: ${array.length})`)\n  }\n  if (toIndex < 0 || toIndex > array.length) {\n    throw new Error(`toIndex ${toIndex} is out of bounds (array length: ${array.length})`)\n  }\n  if (fromIndex === toIndex) {\n    return // No-op\n  }\n\n  // Set up the move context before mutations\n  activeMoveContext = {\n    array,\n    fromIndex,\n    toIndex,\n    path: undefined,\n    receivedFirstSplice: false,\n  }\n\n  try {\n    // Perform the actual splice operations\n    // This will trigger onDeepChange for each splice\n    const [item] = array.splice(fromIndex, 1)\n    const adjustedTarget = toIndex > fromIndex ? toIndex - 1 : toIndex\n    array.splice(adjustedTarget, 0, item)\n  } finally {\n    activeMoveContext = undefined\n  }\n}\n\n/**\n * Check if a change is part of an active move operation and process it.\n * This is called for ArraySplice changes on the target array.\n *\n * @param change The deep change (must be ArraySplice type)\n * @returns The ArrayMoveChange if the move is complete (second splice),\n *          undefined if intercepted but not complete (first splice)\n */\nexport function processChangeForMove(change: DeepChange): ArrayMoveChange | undefined {\n  // We know we're in a move context and this is an ArraySplice on the target array\n  const ctx = activeMoveContext!\n\n  if (!ctx.receivedFirstSplice) {\n    // First splice - capture the path and mark as received\n    ctx.path = change.path\n    ctx.receivedFirstSplice = true\n    return undefined\n  }\n\n  // Second splice - the move is complete.\n  // Note: We adjust toIndex here for Loro's move() semantics, which expects\n  // the target position after removal. This is intentionally separate from\n  // the adjustment on line 64, which is for the splice operation on the MobX array.\n  // Both adjustments are needed because:\n  // - Line 64: splice() inserts at a position in the already-shortened array\n  // - Here: Loro's move(from, to) also expects `to` as the position after removal\n  const adjustedToIndex = ctx.toIndex > ctx.fromIndex ? ctx.toIndex - 1 : ctx.toIndex\n\n  return {\n    type: \"ArrayMove\",\n    path: ctx.path!,\n    fromIndex: ctx.fromIndex,\n    toIndex: adjustedToIndex,\n  }\n}\n\n/**\n * Check if we're currently in a move context for a specific array.\n */\nexport function isInMoveContextForArray(array: unknown[]): boolean {\n  return activeMoveContext !== undefined && activeMoveContext.array === array\n}\n","import {\n  type ContainerID,\n  type LoroDoc,\n  type LoroEventBatch,\n  LoroMap,\n  LoroMovableList,\n  LoroText,\n} from \"loro-crdt\"\nimport { action } from \"mobx\"\nimport {\n  AnyDataModel,\n  AnyModel,\n  AnyStandardType,\n  DeepChange,\n  DeepChangeType,\n  fromSnapshot,\n  getParentToChildPath,\n  getSnapshot,\n  isTreeNode,\n  ModelClass,\n  onDeepChange,\n  onGlobalDeepChange,\n  onSnapshot,\n  resolvePath,\n  SnapshotOutOf,\n  TypeToData,\n} from \"mobx-keystone\"\nimport { nanoid } from \"nanoid\"\nimport type { PlainArray, PlainObject } from \"../plainTypes\"\nimport { getOrCreateLoroCollectionAtom } from \"../utils/getOrCreateLoroCollectionAtom\"\nimport type { BindableLoroContainer } from \"../utils/isBindableLoroContainer\"\n\nimport { applyLoroEventToMobx, ReconciliationMap } from \"./applyLoroEventToMobx\"\nimport { applyMobxChangeToLoroObject } from \"./applyMobxChangeToLoroObject\"\nimport {\n  applyDeltaToLoroText,\n  applyJsonArrayToLoroMovableList,\n  applyJsonObjectToLoroMap,\n  extractTextDeltaFromSnapshot,\n} from \"./convertJsonToLoroData\"\nimport { convertLoroDataToJson } from \"./convertLoroDataToJson\"\nimport { loroTextModelId } from \"./LoroTextModel\"\nimport { type LoroBindingContext, loroBindingContext } from \"./loroBindingContext\"\nimport { setLoroContainerSnapshot } from \"./loroSnapshotTracking\"\nimport {\n  type ArrayMoveChange,\n  isInMoveContextForArray,\n  processChangeForMove,\n} from \"./moveWithinArray\"\n\n/**\n * Captures snapshots of tree nodes in a DeepChange.\n * This ensures values are captured at change time, not at apply time,\n * preventing issues when values are mutated after being added to a collection.\n */\nfunction captureChangeSnapshots(change: DeepChange): DeepChange {\n  if (change.type === DeepChangeType.ArraySplice && change.addedValues.length > 0) {\n    const snapshots = change.addedValues.map((v) => (isTreeNode(v) ? getSnapshot(v) : v))\n    return { ...change, addedValues: snapshots }\n  } else if (change.type === DeepChangeType.ArrayUpdate) {\n    const snapshot = isTreeNode(change.newValue) ? getSnapshot(change.newValue) : change.newValue\n    return { ...change, newValue: snapshot }\n  } else if (\n    change.type === DeepChangeType.ObjectAdd ||\n    change.type === DeepChangeType.ObjectUpdate\n  ) {\n    const snapshot = isTreeNode(change.newValue) ? getSnapshot(change.newValue) : change.newValue\n    return { ...change, newValue: snapshot }\n  }\n  return change\n}\n\n/**\n * Creates a bidirectional binding between a Loro data structure and a mobx-keystone model.\n */\nexport function bindLoroToMobxKeystone<\n  TType extends AnyStandardType | ModelClass<AnyModel> | ModelClass<AnyDataModel>,\n>({\n  loroDoc,\n  loroObject,\n  mobxKeystoneType,\n}: {\n  /**\n   * The Loro document.\n   */\n  loroDoc: LoroDoc\n  /**\n   * The bound Loro data structure.\n   */\n  loroObject: BindableLoroContainer\n  /**\n   * The mobx-keystone model type.\n   */\n  mobxKeystoneType: TType\n}): {\n  /**\n   * The bound mobx-keystone instance.\n   */\n  boundObject: TypeToData<TType>\n  /**\n   * Disposes the binding.\n   */\n  dispose: () => void\n  /**\n   * The Loro origin string used for binding transactions.\n   */\n  loroOrigin: string\n} {\n  const loroOrigin = `bindLoroToMobxKeystoneTransactionOrigin-${nanoid()}`\n\n  let applyingLoroChangesToMobxKeystone = 0\n\n  const bindingContext: LoroBindingContext = {\n    loroDoc,\n    loroObject,\n    mobxKeystoneType,\n    loroOrigin,\n    boundObject: undefined, // not yet created\n\n    get isApplyingLoroChangesToMobxKeystone() {\n      return applyingLoroChangesToMobxKeystone > 0\n    },\n  }\n\n  const loroJson = convertLoroDataToJson(loroObject) as SnapshotOutOf<TypeToData<TType>>\n\n  let boundObject: TypeToData<TType>\n\n  // Track if any init changes occurred during fromSnapshot\n  // If they did, we need to sync the model snapshot to the CRDT\n  let hasInitChanges = false\n\n  const createBoundObject = () => {\n    // Set up a temporary global listener to detect init changes during fromSnapshot\n    const disposeGlobalListener = onGlobalDeepChange((_target, change) => {\n      if (change.isInit) {\n        hasInitChanges = true\n      }\n    })\n\n    try {\n      const result = loroBindingContext.apply(\n        () => fromSnapshot(mobxKeystoneType, loroJson),\n        bindingContext\n      )\n      loroBindingContext.set(result, { ...bindingContext, boundObject: result })\n      return result\n    } finally {\n      disposeGlobalListener()\n    }\n  }\n\n  boundObject = createBoundObject()\n\n  // Get the path to the root Loro object for path resolution\n  const rootLoroPath = loroDoc.getPathToContainer(loroObject.id) ?? []\n\n  // bind any changes from Loro to mobx-keystone\n  const loroSubscribeCb = action((eventBatch: LoroEventBatch) => {\n    // Skip changes that originated from this binding\n    if (eventBatch.origin === loroOrigin) {\n      return\n    }\n\n    // Track newly inserted containers to avoid double-processing their events\n    const newlyInsertedContainers = new Set<ContainerID>()\n\n    // Create a map to store reconciliation data for this batch\n    const reconciliationMap: ReconciliationMap = new Map()\n\n    // Collect init changes that occur during event application\n    // (e.g., fromSnapshot calls that trigger onInit hooks)\n    // We store both target and change so we can compute the correct path later\n    // Snapshots are captured immediately to preserve values at init time\n    const initChanges: { target: object; change: DeepChange }[] = []\n    const disposeGlobalListener = onGlobalDeepChange((target, change) => {\n      if (change.isInit) {\n        initChanges.push({ target, change: captureChangeSnapshots(change) })\n      }\n    })\n\n    applyingLoroChangesToMobxKeystone++\n    try {\n      try {\n        for (const event of eventBatch.events) {\n          applyLoroEventToMobx(\n            event,\n            loroDoc,\n            boundObject,\n            rootLoroPath,\n            reconciliationMap,\n            newlyInsertedContainers\n          )\n        }\n      } finally {\n        disposeGlobalListener()\n      }\n\n      // Sync back any init-time mutations from fromSnapshot calls\n      // (e.g., onInit hooks that modify the model)\n      // This is needed because init changes during Loro event handling are not\n      // captured by the main onDeepChange (it skips changes when applyingLoroChangesToMobxKeystone > 0)\n      if (initChanges.length > 0) {\n        loroDoc.setNextCommitOrigin(loroOrigin)\n\n        for (const { target, change } of initChanges) {\n          // Compute the path from boundObject to the target\n          const pathToTarget = getParentToChildPath(boundObject, target)\n          if (pathToTarget !== undefined) {\n            // Create a new change with the correct path from the root\n            const changeWithCorrectPath: DeepChange = {\n              ...change,\n              path: [...pathToTarget, ...change.path],\n            }\n            applyMobxChangeToLoroObject(changeWithCorrectPath, loroObject)\n          }\n        }\n\n        loroDoc.commit()\n      }\n\n      // Update snapshot tracking: the Loro container is now in sync with the current MobX snapshot\n      // This enables the merge optimization to skip unchanged subtrees during reconciliation\n      if (loroObject instanceof LoroMap || loroObject instanceof LoroMovableList) {\n        setLoroContainerSnapshot(loroObject, getSnapshot(boundObject))\n      }\n    } finally {\n      applyingLoroChangesToMobxKeystone--\n    }\n  })\n  const loroUnsubscribe = loroDoc.subscribe(loroSubscribeCb)\n\n  // bind any changes from mobx-keystone to Loro\n  // Collect changes during an action and apply them after the action completes\n  let pendingChanges: (DeepChange | ArrayMoveChange)[] = []\n\n  const disposeOnDeepChange = onDeepChange(boundObject, (change) => {\n    // Skip if we're currently applying Loro changes to MobX\n    if (bindingContext.isApplyingLoroChangesToMobxKeystone) {\n      return\n    }\n\n    // Skip init changes - they are handled by the getSnapshot + merge at the end of binding\n    if (change.isInit) {\n      return\n    }\n\n    // Check if this is part of a moveWithinArray operation\n    if (change.type === DeepChangeType.ArraySplice) {\n      const resolved = resolvePath(boundObject, change.path)\n      if (resolved.resolved && isInMoveContextForArray(resolved.value as unknown[])) {\n        const moveResult = processChangeForMove(change)\n\n        if (moveResult === undefined) {\n          // Intercepted but move not complete - skip this change\n          return\n        }\n\n        // Move complete - add the move change instead\n        pendingChanges.push(moveResult)\n        return\n      }\n    }\n\n    // Capture snapshots now before the values can be mutated within the same transaction.\n    // This is necessary because changes are collected and applied after the action completes,\n    // by which time the original values may have been modified.\n    // Example: `obj.items = [a, b]; obj.items.splice(0, 1)` - without early capture,\n    // the ObjectUpdate for `items` would get the post-splice array state.\n    pendingChanges.push(captureChangeSnapshots(change))\n  })\n\n  // Apply collected changes when snapshot changes (i.e., after action completes)\n  // Also notify that the loro container atoms have been updated\n  const disposeOnSnapshot = onSnapshot(boundObject, () => {\n    if (pendingChanges.length === 0) {\n      return\n    }\n\n    const changesToApply = pendingChanges\n    pendingChanges = []\n\n    // Skip if we're currently applying Loro changes to MobX\n    if (bindingContext.isApplyingLoroChangesToMobxKeystone) {\n      return\n    }\n\n    loroDoc.setNextCommitOrigin(loroOrigin)\n\n    // Apply all changes directly to Loro\n    for (const change of changesToApply) {\n      applyMobxChangeToLoroObject(change, loroObject)\n    }\n\n    loroDoc.commit()\n\n    // Update snapshot tracking: the Loro container is now in sync with the current MobX snapshot\n    if (loroObject instanceof LoroMap || loroObject instanceof LoroMovableList) {\n      setLoroContainerSnapshot(loroObject, getSnapshot(boundObject))\n    }\n\n    // Notify MobX that the Loro container has been updated\n    getOrCreateLoroCollectionAtom(loroObject).reportChanged()\n  })\n\n  // Sync the model snapshot to the CRDT if any init changes occurred.\n  // Init changes include: defaults being applied, onInit hooks mutating the model.\n  // This is an optimization: if no init changes occurred, we skip the sync entirely.\n  const finalSnapshot = getSnapshot(boundObject)\n\n  if (hasInitChanges) {\n    loroDoc.setNextCommitOrigin(loroOrigin)\n\n    if (loroObject instanceof LoroMap) {\n      applyJsonObjectToLoroMap(loroObject, finalSnapshot as PlainObject, { mode: \"merge\" })\n    } else if (loroObject instanceof LoroMovableList) {\n      applyJsonArrayToLoroMovableList(loroObject, finalSnapshot as PlainArray, { mode: \"merge\" })\n    } else if (loroObject instanceof LoroText) {\n      // For LoroText, we need to handle LoroTextModel snapshot\n      const snapshot = finalSnapshot as Record<string, unknown>\n      if (snapshot.$modelType === loroTextModelId) {\n        // Clear existing content and apply deltas\n        if (loroObject.length > 0) {\n          loroObject.delete(0, loroObject.length)\n        }\n        const deltas = extractTextDeltaFromSnapshot(snapshot.deltaList)\n        if (deltas.length > 0) {\n          applyDeltaToLoroText(loroObject, deltas)\n        }\n      }\n    }\n\n    loroDoc.commit()\n  }\n\n  // Always update snapshot tracking after binding initialization\n  // This ensures the merge optimization can skip unchanged subtrees in future reconciliations\n  if (loroObject instanceof LoroMap || loroObject instanceof LoroMovableList) {\n    setLoroContainerSnapshot(loroObject, finalSnapshot)\n  }\n\n  const dispose = () => {\n    loroUnsubscribe()\n    disposeOnDeepChange()\n    disposeOnSnapshot()\n  }\n\n  return {\n    boundObject,\n    dispose,\n    loroOrigin,\n  }\n}\n"],"names":["createAtom","createContext","LoroMap","LoroMovableList","LoroTextModel","Model","tProp","types","frozen","getParentToChildPath","loroObject","LoroText","computed","modelAction","model","getSnapshotModelType","isContainer","result","modelSnapshotOutWithMetadata","toFrozenSnapshot","resolvePath","runUnprotected","isModel","isDataModel","modelIdKey","isFrozenSnapshot","getSnapshotModelId","fromSnapshot","remove","frozenKey","DeepChangeType","isTreeNode","getSnapshot","onGlobalDeepChange","action","onDeepChange","onSnapshot"],"mappings":"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","x_google_ignoreList":[0]}