mindoodb-app-sdk 0.0.18 → 0.0.20

package/dist/testing/index.js

@@ -1,3 +1,3790 @@
+import {
+  __commonJS,
+  __require,
+  __toESM
+} from "../chunk-QGM4M3NI.js";
+
+// node_modules/.pnpm/@automerge+automerge@3.2.6/node_modules/@automerge/automerge/dist/mjs/wasm_bindgen_output/nodejs/automerge_wasm.cjs
+var require_automerge_wasm = __commonJS({
+  "node_modules/.pnpm/@automerge+automerge@3.2.6/node_modules/@automerge/automerge/dist/mjs/wasm_bindgen_output/nodejs/automerge_wasm.cjs"(exports) {
+    "use strict";
+    function isNode18() {
+      if (typeof process === "undefined" || typeof process.versions === "undefined" || typeof process.versions.node === "undefined") {
+        return false;
+      }
+      const nodeVersion = process.versions.node;
+      const majorVersion = parseInt(nodeVersion.split(".")[0], 10);
+      return majorVersion == 18;
+    }
+    if (isNode18()) {
+      globalThis.crypto = __require("crypto").webcrypto;
+    }
+    var Automerge2 = class _Automerge {
+      static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(_Automerge.prototype);
+        obj.__wbg_ptr = ptr;
+        AutomergeFinalization2.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+      }
+      __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        AutomergeFinalization2.unregister(this);
+        return ptr;
+      }
+      free() {
+        const ptr = this.__destroy_into_raw();
+        wasm2.__wbg_automerge_free(ptr, 0);
+      }
+      /**
+       * @param {any} object
+       * @param {any} meta
+       * @returns {any}
+       */
+      applyAndReturnPatches(object, meta) {
+        const ret = wasm2.automerge_applyAndReturnPatches(this.__wbg_ptr, object, meta);
+        if (ret[2]) {
+          throw takeFromExternrefTable02(ret[1]);
+        }
+        return takeFromExternrefTable02(ret[0]);
+      }
+      /**
+       * @param {Change[]} changes
+       */
+      applyChanges(changes) {
+        const ret = wasm2.automerge_applyChanges(this.__wbg_ptr, changes);
+        if (ret[1]) {
+          throw takeFromExternrefTable02(ret[0]);
+        }
+      }
+      /**
+       * @param {any} object
+       * @param {any} meta
+       * @returns {any}
+       */
+      applyPatches(object, meta) {
+        const ret = wasm2.automerge_applyPatches(this.__wbg_ptr, object, meta);
+        if (ret[2]) {
+          throw takeFromExternrefTable02(ret[1]);
+        }
+        return takeFromExternrefTable02(ret[0]);
+      }
+      /**
+       * @param {string | null} [actor]
+       * @returns {Automerge}
+       */
+      clone(actor) {
+        var ptr0 = isLikeNone2(actor) ? 0 : passStringToWasm02(actor, wasm2.__wbindgen_malloc, wasm2.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN2;
+        const ret = wasm2.automerge_clone(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+          throw takeFromExternrefTable02(ret[1]);
+        }
+        return _Automerge.__wrap(ret[0]);
+      }
+      /**
+       * @param {string | null} [message]
+       * @param {number | null} [time]
+       * @returns {Hash | null}
+       */
+      commit(message, time) {
+        var ptr0 = isLikeNone2(message) ? 0 : passStringToWasm02(message, wasm2.__wbindgen_malloc, wasm2.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN2;
+        const ret = wasm2.automerge_commit(this.__wbg_ptr, ptr0, len0, !isLikeNone2(time), isLikeNone2(time) ? 0 : time);
+        return ret;
+      }
+      /**
+       * @param {ObjID} obj
+       * @param {Prop} prop
+       */
+      delete(obj, prop) {
+        const ret = wasm2.automerge_delete(this.__wbg_ptr, obj, prop);
+        if (ret[1]) {
+          throw takeFromExternrefTable02(ret[0]);
+        }
+      }
+      /**
+       * @param {Heads} before
+       * @param {Heads} after
+       * @returns {Patch[]}
+       */
+      diff(before, after) {
+        const ret = wasm2.automerge_diff(this.__wbg_ptr, before, after);
+        if (ret[2]) {
+          throw takeFromExternrefTable02(ret[1]);
+        }
+        return takeFromExternrefTable02(ret[0]);
+      }
+      /**
+       * @returns {Patch[]}
+       */
+      diffIncremental() {
+        const ret = wasm2.automerge_diffIncremental(this.__wbg_ptr);
+        if (ret[2]) {
+          throw takeFromExternrefTable02(ret[1]);
+        }
+        return takeFromExternrefTable02(ret[0]);
+      }
+      /**
+       * @param {Prop[] | string} path
+       * @param {Heads} before
+       * @param {Heads} after
+       * @param {any} options
+       * @returns {Array<any>}
+       */
+      diffPath(path, before, after, options) {
+        const ret = wasm2.automerge_diffPath(this.__wbg_ptr, path, before, after, options);
+        if (ret[2]) {
+          throw takeFromExternrefTable02(ret[1]);
+        }
+        return takeFromExternrefTable02(ret[0]);
+      }
+      dump() {
+        wasm2.automerge_dump(this.__wbg_ptr);
+      }
+      /**
+       * @param {string | null} [message]
+       * @param {number | null} [time]
+       * @returns {Hash}
+       */
+      emptyChange(message, time) {
+        var ptr0 = isLikeNone2(message) ? 0 : passStringToWasm02(message, wasm2.__wbindgen_malloc, wasm2.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN2;
+        const ret = wasm2.automerge_emptyChange(this.__wbg_ptr, ptr0, len0, !isLikeNone2(time), isLikeNone2(time) ? 0 : time);
+        return ret;
+      }
+      /**
+       * @param {boolean} enable
+       * @returns {boolean}
+       */
+      enableFreeze(enable) {
+        const ret = wasm2.automerge_enableFreeze(this.__wbg_ptr, enable);
+        if (ret[2]) {
+          throw takeFromExternrefTable02(ret[1]);
+        }
+        return ret[0] !== 0;
+      }
+      /**
+       * @param {string | null | undefined} actor
+       * @param {any} heads
+       * @returns {Automerge}
+       */
+      fork(actor, heads) {
+        var ptr0 = isLikeNone2(actor) ? 0 : passStringToWasm02(actor, wasm2.__wbindgen_malloc, wasm2.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN2;
+        const ret = wasm2.automerge_fork(this.__wbg_ptr, ptr0, len0, heads);
+        if (ret[2]) {
+          throw takeFromExternrefTable02(ret[1]);
+        }
+        return _Automerge.__wrap(ret[0]);
+      }
+      /**
+       * @param {SyncState} state
+       * @returns {SyncMessage | null}
+       */
+      generateSyncMessage(state) {
+        _assertClass2(state, SyncState2);
+        const ret = wasm2.automerge_generateSyncMessage(this.__wbg_ptr, state.__wbg_ptr);
+        return ret;
+      }
+      /**
+       * @param {any} obj
+       * @param {any} prop
+       * @param {any} heads
+       * @returns {any}
+       */
+      get(obj, prop, heads) {
+        const ret = wasm2.automerge_get(this.__wbg_ptr, obj, prop, heads);
+        if (ret[2]) {
+          throw takeFromExternrefTable02(ret[1]);
+        }
+        return takeFromExternrefTable02(ret[0]);
+      }
+      /**
+       * @returns {Actor}
+       */
+      getActorId() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+          const ret = wasm2.automerge_getActorId(this.__wbg_ptr);
+          deferred1_0 = ret[0];
+          deferred1_1 = ret[1];
+          return getStringFromWasm02(ret[0], ret[1]);
+        } finally {
+          wasm2.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+      }
+      /**
+       * @param {any} obj
+       * @param {any} arg
+       * @param {any} heads
+       * @returns {Array<any>}
+       */
+      getAll(obj, arg, heads) {
+        const ret = wasm2.automerge_getAll(this.__wbg_ptr, obj, arg, heads);
+        if (ret[2]) {
+          throw takeFromExternrefTable02(ret[1]);
+        }
+        return takeFromExternrefTable02(ret[0]);
+      }
+      /**
+       * @param {any} text
+       * @param {number} index
+       * @param {any} heads
+       * @returns {any}
+       */
+      getBlock(text, index, heads) {
+        const ret = wasm2.automerge_getBlock(this.__wbg_ptr, text, index, heads);
+        if (ret[2]) {
+          throw takeFromExternrefTable02(ret[1]);
+        }
+        return takeFromExternrefTable02(ret[0]);
+      }
+      /**
+       * @param {Hash} hash
+       * @returns {Change | null}
+       */
+      getChangeByHash(hash) {
+        const ret = wasm2.automerge_getChangeByHash(this.__wbg_ptr, hash);
+        if (ret[2]) {
+          throw takeFromExternrefTable02(ret[1]);
+        }
+        return takeFromExternrefTable02(ret[0]);
+      }
+      /**
+       * @param {Hash} hash
+       * @returns {ChangeMetadata | null}
+       */
+      getChangeMetaByHash(hash) {
+        const ret = wasm2.automerge_getChangeMetaByHash(this.__wbg_ptr, hash);
+        if (ret[2]) {
+          throw takeFromExternrefTable02(ret[1]);
+        }
+        return takeFromExternrefTable02(ret[0]);
+      }
+      /**
+       * @param {Heads} have_deps
+       * @returns {Change[]}
+       */
+      getChanges(have_deps) {
+        const ret = wasm2.automerge_getChanges(this.__wbg_ptr, have_deps);
+        if (ret[2]) {
+          throw takeFromExternrefTable02(ret[1]);
+        }
+        return takeFromExternrefTable02(ret[0]);
+      }
+      /**
+       * @param {Automerge} other
+       * @returns {Change[]}
+       */
+      getChangesAdded(other) {
+        _assertClass2(other, _Automerge);
+        const ret = wasm2.automerge_getChangesAdded(this.__wbg_ptr, other.__wbg_ptr);
+        return ret;
+      }
+      /**
+       * @param {Heads} have_deps
+       * @returns {ChangeMetadata[]}
+       */
+      getChangesMeta(have_deps) {
+        const ret = wasm2.automerge_getChangesMeta(this.__wbg_ptr, have_deps);
+        if (ret[2]) {
+          throw takeFromExternrefTable02(ret[1]);
+        }
+        return takeFromExternrefTable02(ret[0]);
+      }
+      /**
+       * @param {any} obj
+       * @param {any} position
+       * @param {any} heads
+       * @param {any} move_cursor
+       * @returns {string}
+       */
+      getCursor(obj, position, heads, move_cursor) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+          const ret = wasm2.automerge_getCursor(this.__wbg_ptr, obj, position, heads, move_cursor);
+          var ptr1 = ret[0];
+          var len1 = ret[1];
+          if (ret[3]) {
+            ptr1 = 0;
+            len1 = 0;
+            throw takeFromExternrefTable02(ret[2]);
+          }
+          deferred2_0 = ptr1;
+          deferred2_1 = len1;
+          return getStringFromWasm02(ptr1, len1);
+        } finally {
+          wasm2.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+      }
+      /**
+       * @param {any} obj
+       * @param {any} cursor
+       * @param {any} heads
+       * @returns {number}
+       */
+      getCursorPosition(obj, cursor, heads) {
+        const ret = wasm2.automerge_getCursorPosition(this.__wbg_ptr, obj, cursor, heads);
+        if (ret[2]) {
+          throw takeFromExternrefTable02(ret[1]);
+        }
+        return ret[0];
+      }
+      /**
+       * @param {Hash} hash
+       * @returns {DecodedChange | null}
+       */
+      getDecodedChangeByHash(hash) {
+        const ret = wasm2.automerge_getDecodedChangeByHash(this.__wbg_ptr, hash);
+        if (ret[2]) {
+          throw takeFromExternrefTable02(ret[1]);
+        }
+        return takeFromExternrefTable02(ret[0]);
+      }
+      /**
+       * @returns {Heads}
+       */
+      getHeads() {
+        const ret = wasm2.automerge_getHeads(this.__wbg_ptr);
+        return ret;
+      }
+      /**
+       * @returns {Change | null}
+       */
+      getLastLocalChange() {
+        const ret = wasm2.automerge_getLastLocalChange(this.__wbg_ptr);
+        return ret;
+      }
+      /**
+       * @param {any} heads
+       * @returns {Array<any>}
+       */
+      getMissingDeps(heads) {
+        const ret = wasm2.automerge_getMissingDeps(this.__wbg_ptr, heads);
+        if (ret[2]) {
+          throw takeFromExternrefTable02(ret[1]);
+        }
+        return takeFromExternrefTable02(ret[0]);
+      }
+      /**
+       * @param {any} obj
+       * @param {any} prop
+       * @param {any} heads
+       * @returns {any}
+       */
+      getWithType(obj, prop, heads) {
+        const ret = wasm2.automerge_getWithType(this.__wbg_ptr, obj, prop, heads);
+        if (ret[2]) {
+          throw takeFromExternrefTable02(ret[1]);
+        }
+        return takeFromExternrefTable02(ret[0]);
+      }
+      /**
+       * @param {SyncState} state
+       * @returns {boolean}
+       */
+      hasOurChanges(state) {
+        _assertClass2(state, SyncState2);
+        const ret = wasm2.automerge_hasOurChanges(this.__wbg_ptr, state.__wbg_ptr);
+        return ret !== 0;
+      }
+      /**
+       * @param {ObjID} obj
+       * @param {Prop} prop
+       * @param {number} value
+       */
+      increment(obj, prop, value) {
+        const ret = wasm2.automerge_increment(this.__wbg_ptr, obj, prop, value);
+        if (ret[1]) {
+          throw takeFromExternrefTable02(ret[0]);
+        }
+      }
+      /**
+       * Initialize the root object of an empty document from a JS object.
+       * This is much faster than setting keys one at a time for large initial states.
+       * @param {any} value
+       */
+      initRootFromHydrate(value) {
+        const ret = wasm2.automerge_initRootFromHydrate(this.__wbg_ptr, value);
+        if (ret[1]) {
+          throw takeFromExternrefTable02(ret[0]);
+        }
+      }
+      /**
+       * @param {any} obj
+       * @param {number} index
+       * @param {any} value
+       * @param {any} datatype
+       */
+      insert(obj, index, value, datatype) {
+        const ret = wasm2.automerge_insert(this.__wbg_ptr, obj, index, value, datatype);
+        if (ret[1]) {
+          throw takeFromExternrefTable02(ret[0]);
+        }
+      }
+      /**
+       * @param {ObjID} obj
+       * @param {number} index
+       * @param {ObjType} value
+       * @returns {ObjID}
+       */
+      insertObject(obj, index, value) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+          const ret = wasm2.automerge_insertObject(this.__wbg_ptr, obj, index, value);
+          var ptr1 = ret[0];
+          var len1 = ret[1];
+          if (ret[3]) {
+            ptr1 = 0;
+            len1 = 0;
+            throw takeFromExternrefTable02(ret[2]);
+          }
+          deferred2_0 = ptr1;
+          deferred2_1 = len1;
+          return getStringFromWasm02(ptr1, len1);
+        } finally {
+          wasm2.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+      }
+      /**
+       * Insert a nested JavaScript value into a list using batch insertion.
+       * This is much faster than insertObject for large nested objects.
+       * The value is inserted at the given index, shifting subsequent elements.
+       * @param {ObjID} obj
+       * @param {number} index
+       * @param {any} value
+       * @returns {ObjID}
+       */
+      insertObjectFromHydrate(obj, index, value) {
+        const ret = wasm2.automerge_insertObjectFromHydrate(this.__wbg_ptr, obj, index, value);
+        if (ret[2]) {
+          throw takeFromExternrefTable02(ret[1]);
+        }
+        return takeFromExternrefTable02(ret[0]);
+      }
+      integrate() {
+        wasm2.automerge_integrate(this.__wbg_ptr);
+      }
+      /**
+       * @param {Heads} heads
+       */
+      isolate(heads) {
+        const ret = wasm2.automerge_isolate(this.__wbg_ptr, heads);
+        if (ret[1]) {
+          throw takeFromExternrefTable02(ret[0]);
+        }
+      }
+      /**
+       * @param {ObjID} obj
+       * @param {number} index
+       */
+      joinBlock(obj, index) {
+        const ret = wasm2.automerge_joinBlock(this.__wbg_ptr, obj, index);
+        if (ret[1]) {
+          throw takeFromExternrefTable02(ret[0]);
+        }
+      }
+      /**
+       * @param {any} obj
+       * @param {any} heads
+       * @returns {Array<any>}
+       */
+      keys(obj, heads) {
+        const ret = wasm2.automerge_keys(this.__wbg_ptr, obj, heads);
+        if (ret[2]) {
+          throw takeFromExternrefTable02(ret[1]);
+        }
+        return takeFromExternrefTable02(ret[0]);
+      }
+      /**
+       * @param {any} obj
+       * @param {any} heads
+       * @returns {number}
+       */
+      length(obj, heads) {
+        const ret = wasm2.automerge_length(this.__wbg_ptr, obj, heads);
+        if (ret[2]) {
+          throw takeFromExternrefTable02(ret[1]);
+        }
+        return ret[0];
+      }
+      /**
+       * @param {Uint8Array} data
+       * @returns {number}
+       */
+      loadIncremental(data) {
+        const ret = wasm2.automerge_loadIncremental(this.__wbg_ptr, data);
+        if (ret[2]) {
+          throw takeFromExternrefTable02(ret[1]);
+        }
+        return ret[0];
+      }
+      /**
+       * @param {any} obj
+       * @param {any} range
+       * @param {any} name
+       * @param {any} value
+       * @param {any} datatype
+       */
+      mark(obj, range, name, value, datatype) {
+        const ret = wasm2.automerge_mark(this.__wbg_ptr, obj, range, name, value, datatype);
+        if (ret[1]) {
+          throw takeFromExternrefTable02(ret[0]);
+        }
+      }
+      /**
+       * @param {any} obj
+       * @param {any} heads
+       * @returns {any}
+       */
+      marks(obj, heads) {
+        const ret = wasm2.automerge_marks(this.__wbg_ptr, obj, heads);
+        if (ret[2]) {
+          throw takeFromExternrefTable02(ret[1]);
+        }
+        return takeFromExternrefTable02(ret[0]);
+      }
+      /**
+       * @param {any} obj
+       * @param {number} index
+       * @param {any} heads
+       * @returns {object}
+       */
+      marksAt(obj, index, heads) {
+        const ret = wasm2.automerge_marksAt(this.__wbg_ptr, obj, index, heads);
+        if (ret[2]) {
+          throw takeFromExternrefTable02(ret[1]);
+        }
+        return takeFromExternrefTable02(ret[0]);
+      }
+      /**
+       * @param {any} obj
+       * @param {any} heads
+       * @param {any} meta
+       * @returns {any}
+       */
+      materialize(obj, heads, meta) {
+        const ret = wasm2.automerge_materialize(this.__wbg_ptr, obj, heads, meta);
+        if (ret[2]) {
+          throw takeFromExternrefTable02(ret[1]);
+        }
+        return takeFromExternrefTable02(ret[0]);
+      }
+      /**
+       * @param {Automerge} other
+       * @returns {Heads}
+       */
+      merge(other) {
+        _assertClass2(other, _Automerge);
+        const ret = wasm2.automerge_merge(this.__wbg_ptr, other.__wbg_ptr);
+        if (ret[2]) {
+          throw takeFromExternrefTable02(ret[1]);
+        }
+        return takeFromExternrefTable02(ret[0]);
+      }
+      /**
+       * @param {string | null} [actor]
+       * @returns {Automerge}
+       */
+      static new(actor) {
+        var ptr0 = isLikeNone2(actor) ? 0 : passStringToWasm02(actor, wasm2.__wbindgen_malloc, wasm2.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN2;
+        const ret = wasm2.automerge_new(ptr0, len0);
+        if (ret[2]) {
+          throw takeFromExternrefTable02(ret[1]);
+        }
+        return _Automerge.__wrap(ret[0]);
+      }
+      /**
+       * @param {any} obj
+       * @param {any} heads
+       * @returns {object}
+       */
+      objInfo(obj, heads) {
+        const ret = wasm2.automerge_objInfo(this.__wbg_ptr, obj, heads);
+        if (ret[2]) {
+          throw takeFromExternrefTable02(ret[1]);
+        }
+        return takeFromExternrefTable02(ret[0]);
+      }
+      /**
+       * @returns {number}
+       */
+      pendingOps() {
+        const ret = wasm2.automerge_pendingOps(this.__wbg_ptr);
+        return ret;
+      }
+      /**
+       * @param {any} obj
+       * @param {any} value
+       * @param {any} datatype
+       */
+      push(obj, value, datatype) {
+        const ret = wasm2.automerge_push(this.__wbg_ptr, obj, value, datatype);
+        if (ret[1]) {
+          throw takeFromExternrefTable02(ret[0]);
+        }
+      }
+      /**
+       * @param {ObjID} obj
+       * @param {ObjType} value
+       * @returns {ObjID}
+       */
+      pushObject(obj, value) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+          const ret = wasm2.automerge_pushObject(this.__wbg_ptr, obj, value);
+          var ptr1 = ret[0];
+          var len1 = ret[1];
+          if (ret[3]) {
+            ptr1 = 0;
+            len1 = 0;
+            throw takeFromExternrefTable02(ret[2]);
+          }
+          deferred2_0 = ptr1;
+          deferred2_1 = len1;
+          return getStringFromWasm02(ptr1, len1);
+        } finally {
+          wasm2.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+      }
+      /**
+       * @param {any} obj
+       * @param {any} prop
+       * @param {any} value
+       * @param {any} datatype
+       */
+      put(obj, prop, value, datatype) {
+        const ret = wasm2.automerge_put(this.__wbg_ptr, obj, prop, value, datatype);
+        if (ret[1]) {
+          throw takeFromExternrefTable02(ret[0]);
+        }
+      }
+      /**
+       * @param {ObjID} obj
+       * @param {Prop} prop
+       * @param {ObjType} value
+       * @returns {ObjID}
+       */
+      putObject(obj, prop, value) {
+        const ret = wasm2.automerge_putObject(this.__wbg_ptr, obj, prop, value);
+        if (ret[2]) {
+          throw takeFromExternrefTable02(ret[1]);
+        }
+        return takeFromExternrefTable02(ret[0]);
+      }
+      /**
+       * Put a nested JavaScript value as a new object tree using batch insertion.
+       * This is much faster than putObject for large nested objects.
+       * For map keys this overwrites any existing value. For list indices this
+       * overwrites the element at that index.
+       * @param {ObjID} obj
+       * @param {Prop} prop
+       * @param {any} value
+       * @returns {ObjID}
+       */
+      putObjectFromHydrate(obj, prop, value) {
+        const ret = wasm2.automerge_putObjectFromHydrate(this.__wbg_ptr, obj, prop, value);
+        if (ret[2]) {
+          throw takeFromExternrefTable02(ret[1]);
+        }
+        return takeFromExternrefTable02(ret[0]);
+      }
+      /**
+       * @param {SyncState} state
+       * @param {SyncMessage} message
+       */
+      receiveSyncMessage(state, message) {
+        _assertClass2(state, SyncState2);
+        const ret = wasm2.automerge_receiveSyncMessage(this.__wbg_ptr, state.__wbg_ptr, message);
+        if (ret[1]) {
+          throw takeFromExternrefTable02(ret[0]);
+        }
+      }
+      /**
+       * @param {string} datatype
+       * @param {Function} construct
+       * @param {(arg: any) => any | undefined} deconstruct
+       */
+      registerDatatype(datatype, construct, deconstruct) {
+        const ret = wasm2.automerge_registerDatatype(this.__wbg_ptr, datatype, construct, deconstruct);
+        if (ret[1]) {
+          throw takeFromExternrefTable02(ret[0]);
+        }
+      }
+      resetDiffCursor() {
+        wasm2.automerge_resetDiffCursor(this.__wbg_ptr);
+      }
+      /**
+       * @returns {number}
+       */
+      rollback() {
+        const ret = wasm2.automerge_rollback(this.__wbg_ptr);
+        return ret;
+      }
+      /**
+       * @returns {Uint8Array}
+       */
+      save() {
+        const ret = wasm2.automerge_save(this.__wbg_ptr);
+        return ret;
+      }
+      /**
+       * @returns {Uint8Array}
+       */
+      saveAndVerify() {
+        const ret = wasm2.automerge_saveAndVerify(this.__wbg_ptr);
+        if (ret[2]) {
+          throw takeFromExternrefTable02(ret[1]);
+        }
+        return takeFromExternrefTable02(ret[0]);
+      }
+      /**
+       * @param {any} hashes
+       * @returns {Uint8Array}
+       */
+      saveBundle(hashes) {
+        const ret = wasm2.automerge_saveBundle(this.__wbg_ptr, hashes);
+        if (ret[2]) {
+          throw takeFromExternrefTable02(ret[1]);
+        }
+        return takeFromExternrefTable02(ret[0]);
+      }
+      /**
+       * @returns {Uint8Array}
+       */
+      saveIncremental() {
+        const ret = wasm2.automerge_saveIncremental(this.__wbg_ptr);
+        return ret;
+      }
+      /**
+       * @returns {Uint8Array}
+       */
+      saveNoCompress() {
+        const ret = wasm2.automerge_saveNoCompress(this.__wbg_ptr);
+        return ret;
+      }
+      /**
+       * @param {Heads} heads
+       * @returns {Uint8Array}
+       */
+      saveSince(heads) {
+        const ret = wasm2.automerge_saveSince(this.__wbg_ptr, heads);
+        if (ret[2]) {
+          throw takeFromExternrefTable02(ret[1]);
+        }
+        return takeFromExternrefTable02(ret[0]);
+      }
+      /**
+       * @param {any} obj
+       * @param {any} heads
+       * @returns {Array<any>}
+       */
+      spans(obj, heads) {
+        const ret = wasm2.automerge_spans(this.__wbg_ptr, obj, heads);
+        if (ret[2]) {
+          throw takeFromExternrefTable02(ret[1]);
+        }
+        return takeFromExternrefTable02(ret[0]);
+      }
+      /**
+       * @param {any} obj
+       * @param {number} start
+       * @param {number} delete_count
+       * @param {any} text
+       */
+      splice(obj, start, delete_count, text) {
+        const ret = wasm2.automerge_splice(this.__wbg_ptr, obj, start, delete_count, text);
+        if (ret[1]) {
+          throw takeFromExternrefTable02(ret[0]);
+        }
+      }
+      /**
+       * Splice values into a list using batch insertion.
+       * This is much faster than individual insert calls for multiple values.
+       * @param {ObjID} obj
+       * @param {number} index
+       * @param {number} del
+       * @param {any} values
+       */
+      spliceFromHydrate(obj, index, del, values) {
+        const ret = wasm2.automerge_spliceFromHydrate(this.__wbg_ptr, obj, index, del, values);
+        if (ret[1]) {
+          throw takeFromExternrefTable02(ret[0]);
+        }
+      }
+      /**
+       * @param {ObjID} obj
+       * @param {number} index
+       * @param {{[key: string]: MaterializeValue}} block
+       */
+      splitBlock(obj, index, block) {
+        const ret = wasm2.automerge_splitBlock(this.__wbg_ptr, obj, index, block);
+        if (ret[1]) {
+          throw takeFromExternrefTable02(ret[0]);
+        }
+      }
+      /**
+       * @returns {Stats}
+       */
+      stats() {
+        const ret = wasm2.automerge_stats(this.__wbg_ptr);
+        return ret;
+      }
+      /**
+       * @param {any} obj
+       * @param {any} heads
+       * @returns {string}
+       */
+      text(obj, heads) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+          const ret = wasm2.automerge_text(this.__wbg_ptr, obj, heads);
+          var ptr1 = ret[0];
+          var len1 = ret[1];
+          if (ret[3]) {
+            ptr1 = 0;
+            len1 = 0;
+            throw takeFromExternrefTable02(ret[2]);
+          }
+          deferred2_0 = ptr1;
+          deferred2_1 = len1;
+          return getStringFromWasm02(ptr1, len1);
+        } finally {
+          wasm2.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+      }
+      /**
+       * @param {any} meta
+       * @returns {MaterializeValue}
+       */
+      toJS(meta) {
+        const ret = wasm2.automerge_toJS(this.__wbg_ptr, meta);
+        if (ret[2]) {
+          throw takeFromExternrefTable02(ret[1]);
+        }
+        return takeFromExternrefTable02(ret[0]);
+      }
+      /**
+       * @returns {Hash[]}
+       */
+      topoHistoryTraversal() {
+        const ret = wasm2.automerge_topoHistoryTraversal(this.__wbg_ptr);
+        return ret;
+      }
+      /**
+       * @param {ObjID} obj
+       * @param {MarkRange} range
+       * @param {string} name
+       */
+      unmark(obj, range, name) {
+        const ret = wasm2.automerge_unmark(this.__wbg_ptr, obj, range, name);
+        if (ret[1]) {
+          throw takeFromExternrefTable02(ret[0]);
+        }
+      }
+      /**
+       * @param {ObjID} obj
+       * @param {number} index
+       * @param {{[key: string]: MaterializeValue}} block
+       */
+      updateBlock(obj, index, block) {
+        const ret = wasm2.automerge_updateBlock(this.__wbg_ptr, obj, index, block);
+        if (ret[1]) {
+          throw takeFromExternrefTable02(ret[0]);
+        }
+      }
+      updateDiffCursor() {
+        wasm2.automerge_updateDiffCursor(this.__wbg_ptr);
+      }
+      /**
+       * @param {ObjID} obj
+       * @param {Span[]} args
+       * @param {UpdateSpansConfig | undefined | null} config
+       */
+      updateSpans(obj, args, config) {
+        const ret = wasm2.automerge_updateSpans(this.__wbg_ptr, obj, args, config);
+        if (ret[1]) {
+          throw takeFromExternrefTable02(ret[0]);
+        }
+      }
+      /**
+       * @param {ObjID} obj
+       * @param {string} new_text
+       */
+      updateText(obj, new_text) {
+        const ret = wasm2.automerge_updateText(this.__wbg_ptr, obj, new_text);
+        if (ret[1]) {
+          throw takeFromExternrefTable02(ret[0]);
+        }
+      }
+    };
+    if (Symbol.dispose) Automerge2.prototype[Symbol.dispose] = Automerge2.prototype.free;
+    exports.Automerge = Automerge2;
+    var SyncState2 = class _SyncState {
+      static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(_SyncState.prototype);
+        obj.__wbg_ptr = ptr;
+        SyncStateFinalization2.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+      }
+      __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SyncStateFinalization2.unregister(this);
+        return ptr;
+      }
+      free() {
+        const ptr = this.__destroy_into_raw();
+        wasm2.__wbg_syncstate_free(ptr, 0);
+      }
+      /**
+       * @returns {SyncState}
+       */
+      clone() {
+        const ret = wasm2.syncstate_clone(this.__wbg_ptr);
+        return _SyncState.__wrap(ret);
+      }
+      /**
+       * @returns {Heads}
+       */
+      get lastSentHeads() {
+        const ret = wasm2.syncstate_lastSentHeads(this.__wbg_ptr);
+        return ret;
+      }
+      /**
+       * @returns {boolean}
+       */
+      get peerReadOnly() {
+        const ret = wasm2.syncstate_peerReadOnly(this.__wbg_ptr);
+        return ret !== 0;
+      }
+      /**
+       * @returns {boolean}
+       */
+      get readOnly() {
+        const ret = wasm2.syncstate_readOnly(this.__wbg_ptr);
+        return ret !== 0;
+      }
+      /**
+       * @param {Heads} heads
+       */
+      set lastSentHeads(heads) {
+        const ret = wasm2.syncstate_set_lastSentHeads(this.__wbg_ptr, heads);
+        if (ret[1]) {
+          throw takeFromExternrefTable02(ret[0]);
+        }
+      }
+      /**
+       * @param {boolean} read_only
+       */
+      set readOnly(read_only) {
+        wasm2.syncstate_set_readOnly(this.__wbg_ptr, read_only);
+      }
+      /**
+       * @param {Heads} hashes
+       */
+      set sentHashes(hashes) {
+        const ret = wasm2.syncstate_set_sentHashes(this.__wbg_ptr, hashes);
+        if (ret[1]) {
+          throw takeFromExternrefTable02(ret[0]);
+        }
+      }
+      /**
+       * @returns {Heads}
+       */
+      get sharedHeads() {
+        const ret = wasm2.syncstate_sharedHeads(this.__wbg_ptr);
+        return ret;
+      }
+    };
+    if (Symbol.dispose) SyncState2.prototype[Symbol.dispose] = SyncState2.prototype.free;
+    exports.SyncState = SyncState2;
+    function create(options) {
+      const ret = wasm2.create(options);
+      if (ret[2]) {
+        throw takeFromExternrefTable02(ret[1]);
+      }
+      return Automerge2.__wrap(ret[0]);
+    }
+    exports.create = create;
+    function decodeChange(change) {
+      const ret = wasm2.decodeChange(change);
+      if (ret[2]) {
+        throw takeFromExternrefTable02(ret[1]);
+      }
+      return takeFromExternrefTable02(ret[0]);
+    }
+    exports.decodeChange = decodeChange;
+    function decodeSyncMessage(msg) {
+      const ret = wasm2.decodeSyncMessage(msg);
+      if (ret[2]) {
+        throw takeFromExternrefTable02(ret[1]);
+      }
+      return takeFromExternrefTable02(ret[0]);
+    }
+    exports.decodeSyncMessage = decodeSyncMessage;
+    function decodeSyncState(data) {
+      const ret = wasm2.decodeSyncState(data);
+      if (ret[2]) {
+        throw takeFromExternrefTable02(ret[1]);
+      }
+      return SyncState2.__wrap(ret[0]);
+    }
+    exports.decodeSyncState = decodeSyncState;
+    function encodeChange(change) {
+      const ret = wasm2.encodeChange(change);
+      if (ret[2]) {
+        throw takeFromExternrefTable02(ret[1]);
+      }
+      return takeFromExternrefTable02(ret[0]);
+    }
+    exports.encodeChange = encodeChange;
+    function encodeSyncMessage(message) {
+      const ret = wasm2.encodeSyncMessage(message);
+      if (ret[2]) {
+        throw takeFromExternrefTable02(ret[1]);
+      }
+      return takeFromExternrefTable02(ret[0]);
+    }
+    exports.encodeSyncMessage = encodeSyncMessage;
+    function encodeSyncState(state) {
+      _assertClass2(state, SyncState2);
+      const ret = wasm2.encodeSyncState(state.__wbg_ptr);
+      return ret;
+    }
+    exports.encodeSyncState = encodeSyncState;
+    function exportSyncState(state) {
+      _assertClass2(state, SyncState2);
+      const ret = wasm2.exportSyncState(state.__wbg_ptr);
+      return ret;
+    }
+    exports.exportSyncState = exportSyncState;
+    function importSyncState(state) {
+      const ret = wasm2.importSyncState(state);
+      if (ret[2]) {
+        throw takeFromExternrefTable02(ret[1]);
+      }
+      return SyncState2.__wrap(ret[0]);
+    }
+    exports.importSyncState = importSyncState;
+    function initSyncState() {
+      const ret = wasm2.initSyncState();
+      return SyncState2.__wrap(ret);
+    }
+    exports.initSyncState = initSyncState;
+    function load2(data, options) {
+      const ret = wasm2.load(data, options);
+      if (ret[2]) {
+        throw takeFromExternrefTable02(ret[1]);
+      }
+      return Automerge2.__wrap(ret[0]);
+    }
+    exports.load = load2;
+    function readBundle(bundle) {
+      const ret = wasm2.readBundle(bundle);
+      if (ret[2]) {
+        throw takeFromExternrefTable02(ret[1]);
+      }
+      return takeFromExternrefTable02(ret[0]);
+    }
+    exports.readBundle = readBundle;
+    function wasmReleaseInfo() {
+      const ret = wasm2.wasmReleaseInfo();
+      return ret;
+    }
+    exports.wasmReleaseInfo = wasmReleaseInfo;
+    function __wbg_get_imports() {
+      const import0 = {
+        __proto__: null,
+        __wbg_BigInt_65bcea251e788083: function(arg0) {
+          const ret = BigInt(arg0);
+          return ret;
+        },
+        __wbg_Error_960c155d3d49e4c2: function(arg0, arg1) {
+          const ret = Error(getStringFromWasm02(arg0, arg1));
+          return ret;
+        },
+        __wbg_String_8564e559799eccda: function(arg0, arg1) {
+          const ret = String(arg1);
+          const ptr1 = passStringToWasm02(ret, wasm2.__wbindgen_malloc, wasm2.__wbindgen_realloc);
+          const len1 = WASM_VECTOR_LEN2;
+          getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+          getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg___wbindgen_boolean_get_6ea149f0a8dcc5ff: function(arg0) {
+          const v = arg0;
+          const ret = typeof v === "boolean" ? v : void 0;
+          return isLikeNone2(ret) ? 16777215 : ret ? 1 : 0;
+        },
+        __wbg___wbindgen_debug_string_ab4b34d23d6778bd: function(arg0, arg1) {
+          const ret = debugString(arg1);
+          const ptr1 = passStringToWasm02(ret, wasm2.__wbindgen_malloc, wasm2.__wbindgen_realloc);
+          const len1 = WASM_VECTOR_LEN2;
+          getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+          getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg___wbindgen_gt_fd08d8cbe0a8551c: function(arg0, arg1) {
+          const ret = arg0 > arg1;
+          return ret;
+        },
+        __wbg___wbindgen_is_bigint_ec25c7f91b4d9e93: function(arg0) {
+          const ret = typeof arg0 === "bigint";
+          return ret;
+        },
+        __wbg___wbindgen_is_function_3baa9db1a987f47d: function(arg0) {
+          const ret = typeof arg0 === "function";
+          return ret;
+        },
+        __wbg___wbindgen_is_null_52ff4ec04186736f: function(arg0) {
+          const ret = arg0 === null;
+          return ret;
+        },
+        __wbg___wbindgen_is_object_63322ec0cd6ea4ef: function(arg0) {
+          const val = arg0;
+          const ret = typeof val === "object" && val !== null;
+          return ret;
+        },
+        __wbg___wbindgen_is_string_6df3bf7ef1164ed3: function(arg0) {
+          const ret = typeof arg0 === "string";
+          return ret;
+        },
+        __wbg___wbindgen_is_undefined_29a43b4d42920abd: function(arg0) {
+          const ret = arg0 === void 0;
+          return ret;
+        },
+        __wbg___wbindgen_jsval_loose_eq_cac3565e89b4134c: function(arg0, arg1) {
+          const ret = arg0 == arg1;
+          return ret;
+        },
+        __wbg___wbindgen_lt_78bab382628fb48f: function(arg0, arg1) {
+          const ret = arg0 < arg1;
+          return ret;
+        },
+        __wbg___wbindgen_neg_8d39d23ef65c9fdb: function(arg0) {
+          const ret = -arg0;
+          return ret;
+        },
+        __wbg___wbindgen_number_get_c7f42aed0525c451: function(arg0, arg1) {
+          const obj = arg1;
+          const ret = typeof obj === "number" ? obj : void 0;
+          getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone2(ret) ? 0 : ret, true);
+          getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone2(ret), true);
+        },
+        __wbg___wbindgen_string_get_7ed5322991caaec5: function(arg0, arg1) {
+          const obj = arg1;
+          const ret = typeof obj === "string" ? obj : void 0;
+          var ptr1 = isLikeNone2(ret) ? 0 : passStringToWasm02(ret, wasm2.__wbindgen_malloc, wasm2.__wbindgen_realloc);
+          var len1 = WASM_VECTOR_LEN2;
+          getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+          getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg___wbindgen_throw_6b64449b9b9ed33c: function(arg0, arg1) {
+          throw new Error(getStringFromWasm02(arg0, arg1));
+        },
+        __wbg_apply_329b2a440415c2e6: function() {
+          return handleError(function(arg0, arg1, arg2) {
+            const ret = Reflect.apply(arg0, arg1, arg2);
+            return ret;
+          }, arguments);
+        },
+        __wbg_assign_752c2af1512cc7fd: function(arg0, arg1) {
+          const ret = Object.assign(arg0, arg1);
+          return ret;
+        },
+        __wbg_call_14b169f759b26747: function() {
+          return handleError(function(arg0, arg1) {
+            const ret = arg0.call(arg1);
+            return ret;
+          }, arguments);
+        },
+        __wbg_call_a24592a6f349a97e: function() {
+          return handleError(function(arg0, arg1, arg2) {
+            const ret = arg0.call(arg1, arg2);
+            return ret;
+          }, arguments);
+        },
+        __wbg_concat_1cef5380372e969d: function(arg0, arg1) {
+          const ret = arg0.concat(arg1);
+          return ret;
+        },
+        __wbg_defineProperty_aeb95d0434ce03d0: function(arg0, arg1, arg2) {
+          const ret = Object.defineProperty(arg0, arg1, arg2);
+          return ret;
+        },
+        __wbg_deleteProperty_d5f7bd763acbdb44: function() {
+          return handleError(function(arg0, arg1) {
+            const ret = Reflect.deleteProperty(arg0, arg1);
+            return ret;
+          }, arguments);
+        },
+        __wbg_done_9158f7cc8751ba32: function(arg0) {
+          const ret = arg0.done;
+          return ret;
+        },
+        __wbg_entries_e0b73aa8571ddb56: function(arg0) {
+          const ret = Object.entries(arg0);
+          return ret;
+        },
+        __wbg_error_a6fa202b58aa1cd3: function(arg0, arg1) {
+          let deferred0_0;
+          let deferred0_1;
+          try {
+            deferred0_0 = arg0;
+            deferred0_1 = arg1;
+            console.error(getStringFromWasm02(arg0, arg1));
+          } finally {
+            wasm2.__wbindgen_free(deferred0_0, deferred0_1, 1);
+          }
+        },
+        __wbg_for_b0616d1de7774be9: function(arg0, arg1) {
+          const ret = Symbol.for(getStringFromWasm02(arg0, arg1));
+          return ret;
+        },
+        __wbg_freeze_c79f45721998bbbc: function(arg0) {
+          const ret = Object.freeze(arg0);
+          return ret;
+        },
+        __wbg_from_0dbf29f09e7fb200: function(arg0) {
+          const ret = Array.from(arg0);
+          return ret;
+        },
+        __wbg_getRandomValues_76dfc69825c9c552: function() {
+          return handleError(function(arg0, arg1) {
+            globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
+          }, arguments);
+        },
+        __wbg_getTime_da7c55f52b71e8c6: function(arg0) {
+          const ret = arg0.getTime();
+          return ret;
+        },
+        __wbg_get_1affdbdd5573b16a: function() {
+          return handleError(function(arg0, arg1) {
+            const ret = Reflect.get(arg0, arg1);
+            return ret;
+          }, arguments);
+        },
+        __wbg_get_6011fa3a58f61074: function() {
+          return handleError(function(arg0, arg1) {
+            const ret = Reflect.get(arg0, arg1);
+            return ret;
+          }, arguments);
+        },
+        __wbg_get_8360291721e2339f: function(arg0, arg1) {
+          const ret = arg0[arg1 >>> 0];
+          return ret;
+        },
+        __wbg_get_unchecked_17f53dad852b9588: function(arg0, arg1) {
+          const ret = arg0[arg1 >>> 0];
+          return ret;
+        },
+        __wbg_instanceof_ArrayBuffer_7c8433c6ed14ffe3: function(arg0) {
+          let result;
+          try {
+            result = arg0 instanceof ArrayBuffer;
+          } catch (_) {
+            result = false;
+          }
+          const ret = result;
+          return ret;
+        },
+        __wbg_instanceof_Date_81b75f5ed36b30ea: function(arg0) {
+          let result;
+          try {
+            result = arg0 instanceof Date;
+          } catch (_) {
+            result = false;
+          }
+          const ret = result;
+          return ret;
+        },
+        __wbg_instanceof_Object_7c99480a1cdfb911: function(arg0) {
+          let result;
+          try {
+            result = arg0 instanceof Object;
+          } catch (_) {
+            result = false;
+          }
+          const ret = result;
+          return ret;
+        },
+        __wbg_instanceof_Uint8Array_152ba1f289edcf3f: function(arg0) {
+          let result;
+          try {
+            result = arg0 instanceof Uint8Array;
+          } catch (_) {
+            result = false;
+          }
+          const ret = result;
+          return ret;
+        },
+        __wbg_isArray_2790516aa848bf18: function(arg0) {
+          const ret = Array.isArray(arg0);
+          return ret;
+        },
+        __wbg_isArray_c3109d14ffc06469: function(arg0) {
+          const ret = Array.isArray(arg0);
+          return ret;
+        },
+        __wbg_iterator_013bc09ec998c2a7: function() {
+          const ret = Symbol.iterator;
+          return ret;
+        },
+        __wbg_keys_2fd1bfdda7e278ca: function(arg0) {
+          const ret = Object.keys(arg0);
+          return ret;
+        },
+        __wbg_length_3d4ecd04bd8d22f1: function(arg0) {
+          const ret = arg0.length;
+          return ret;
+        },
+        __wbg_length_6a846b3b23b74aca: function(arg0) {
+          const ret = arg0.length;
+          return ret;
+        },
+        __wbg_length_9f1775224cf1d815: function(arg0) {
+          const ret = arg0.length;
+          return ret;
+        },
+        __wbg_log_7e1aa9064a1dbdbd: function(arg0) {
+          console.log(arg0);
+        },
+        __wbg_log_dfa1efedf266562e: function(arg0, arg1) {
+          console.log(arg0, arg1);
+        },
+        __wbg_new_0c7403db6e782f19: function(arg0) {
+          const ret = new Uint8Array(arg0);
+          return ret;
+        },
+        __wbg_new_191521fecb171639: function(arg0, arg1) {
+          const ret = new RangeError(getStringFromWasm02(arg0, arg1));
+          return ret;
+        },
+        __wbg_new_227d7c05414eb861: function() {
+          const ret = new Error();
+          return ret;
+        },
+        __wbg_new_5e360d2ff7b9e1c3: function(arg0, arg1) {
+          const ret = new Error(getStringFromWasm02(arg0, arg1));
+          return ret;
+        },
+        __wbg_new_682678e2f47e32bc: function() {
+          const ret = new Array();
+          return ret;
+        },
+        __wbg_new_7913666fe5070684: function(arg0) {
+          const ret = new Date(arg0);
+          return ret;
+        },
+        __wbg_new_aa8d0fa9762c29bd: function() {
+          const ret = new Object();
+          return ret;
+        },
+        __wbg_new_from_slice_b5ea43e23f6008c0: function(arg0, arg1) {
+          const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
+          return ret;
+        },
+        __wbg_next_0340c4ae324393c3: function() {
+          return handleError(function(arg0) {
+            const ret = arg0.next();
+            return ret;
+          }, arguments);
+        },
+        __wbg_next_7646edaa39458ef7: function(arg0) {
+          const ret = arg0.next;
+          return ret;
+        },
+        __wbg_ownKeys_0231887680f0f945: function() {
+          return handleError(function(arg0) {
+            const ret = Reflect.ownKeys(arg0);
+            return ret;
+          }, arguments);
+        },
+        __wbg_prototypesetcall_a6b02eb00b0f4ce2: function(arg0, arg1, arg2) {
+          Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
+        },
+        __wbg_push_471a5b068a5295f6: function(arg0, arg1) {
+          const ret = arg0.push(arg1);
+          return ret;
+        },
+        __wbg_set_022bee52d0b05b19: function() {
+          return handleError(function(arg0, arg1, arg2) {
+            const ret = Reflect.set(arg0, arg1, arg2);
+            return ret;
+          }, arguments);
+        },
+        __wbg_set_3bf1de9fab0cd644: function(arg0, arg1, arg2) {
+          arg0[arg1 >>> 0] = arg2;
+        },
+        __wbg_set_6be42768c690e380: function(arg0, arg1, arg2) {
+          arg0[arg1] = arg2;
+        },
+        __wbg_slice_45916ed2fae7e0ea: function(arg0, arg1, arg2) {
+          const ret = arg0.slice(arg1 >>> 0, arg2 >>> 0);
+          return ret;
+        },
+        __wbg_stack_3b0d974bbf31e44f: function(arg0, arg1) {
+          const ret = arg1.stack;
+          const ptr1 = passStringToWasm02(ret, wasm2.__wbindgen_malloc, wasm2.__wbindgen_realloc);
+          const len1 = WASM_VECTOR_LEN2;
+          getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+          getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg_stringify_057c4027271f8007: function(arg0, arg1) {
+          const ret = JSON.stringify(arg1);
+          var ptr1 = isLikeNone2(ret) ? 0 : passStringToWasm02(ret, wasm2.__wbindgen_malloc, wasm2.__wbindgen_realloc);
+          var len1 = WASM_VECTOR_LEN2;
+          getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+          getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg_toString_5a84b8552b34a19d: function(arg0) {
+          const ret = arg0.toString();
+          return ret;
+        },
+        __wbg_toString_c3061af2bf859d19: function() {
+          return handleError(function(arg0, arg1) {
+            const ret = arg0.toString(arg1);
+            return ret;
+          }, arguments);
+        },
+        __wbg_toString_c96dc76d5547a715: function(arg0, arg1, arg2) {
+          const ret = arg1.toString(arg2);
+          const ptr1 = passStringToWasm02(ret, wasm2.__wbindgen_malloc, wasm2.__wbindgen_realloc);
+          const len1 = WASM_VECTOR_LEN2;
+          getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+          getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg_unshift_951ea71d9d2dc660: function(arg0, arg1) {
+          const ret = arg0.unshift(arg1);
+          return ret;
+        },
+        __wbg_value_ee3a06f4579184fa: function(arg0) {
+          const ret = arg0.value;
+          return ret;
+        },
+        __wbg_values_301a77363cf6c773: function(arg0) {
+          const ret = Object.values(arg0);
+          return ret;
+        },
+        __wbindgen_cast_0000000000000001: function(arg0) {
+          const ret = arg0;
+          return ret;
+        },
+        __wbindgen_cast_0000000000000002: function(arg0) {
+          const ret = arg0;
+          return ret;
+        },
+        __wbindgen_cast_0000000000000003: function(arg0, arg1) {
+          const ret = getStringFromWasm02(arg0, arg1);
+          return ret;
+        },
+        __wbindgen_cast_0000000000000004: function(arg0) {
+          const ret = BigInt.asUintN(64, arg0);
+          return ret;
+        },
+        __wbindgen_init_externref_table: function() {
+          const table = wasm2.__wbindgen_externrefs;
+          const offset = table.grow(4);
+          table.set(0, void 0);
+          table.set(offset + 0, void 0);
+          table.set(offset + 1, null);
+          table.set(offset + 2, true);
+          table.set(offset + 3, false);
+        }
+      };
+      return {
+        __proto__: null,
+        "./automerge_wasm_bg.js": import0
+      };
+    }
+    var AutomergeFinalization2 = typeof FinalizationRegistry === "undefined" ? { register: () => {
+    }, unregister: () => {
+    } } : new FinalizationRegistry((ptr) => wasm2.__wbg_automerge_free(ptr >>> 0, 1));
+    var SyncStateFinalization2 = typeof FinalizationRegistry === "undefined" ? { register: () => {
+    }, unregister: () => {
+    } } : new FinalizationRegistry((ptr) => wasm2.__wbg_syncstate_free(ptr >>> 0, 1));
+    function addToExternrefTable0(obj) {
+      const idx = wasm2.__externref_table_alloc();
+      wasm2.__wbindgen_externrefs.set(idx, obj);
+      return idx;
+    }
+    function _assertClass2(instance, klass) {
+      if (!(instance instanceof klass)) {
+        throw new Error(`expected instance of ${klass.name}`);
+      }
+    }
+    function debugString(val) {
+      const type = typeof val;
+      if (type == "number" || type == "boolean" || val == null) {
+        return `${val}`;
+      }
+      if (type == "string") {
+        return `"${val}"`;
+      }
+      if (type == "symbol") {
+        const description = val.description;
+        if (description == null) {
+          return "Symbol";
+        } else {
+          return `Symbol(${description})`;
+        }
+      }
+      if (type == "function") {
+        const name = val.name;
+        if (typeof name == "string" && name.length > 0) {
+          return `Function(${name})`;
+        } else {
+          return "Function";
+        }
+      }
+      if (Array.isArray(val)) {
+        const length = val.length;
+        let debug = "[";
+        if (length > 0) {
+          debug += debugString(val[0]);
+        }
+        for (let i = 1; i < length; i++) {
+          debug += ", " + debugString(val[i]);
+        }
+        debug += "]";
+        return debug;
+      }
+      const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
+      let className;
+      if (builtInMatches && builtInMatches.length > 1) {
+        className = builtInMatches[1];
+      } else {
+        return toString.call(val);
+      }
+      if (className == "Object") {
+        try {
+          return "Object(" + JSON.stringify(val) + ")";
+        } catch (_) {
+          return "Object";
+        }
+      }
+      if (val instanceof Error) {
+        return `${val.name}: ${val.message}
+${val.stack}`;
+      }
+      return className;
+    }
+    function getArrayU8FromWasm0(ptr, len) {
+      ptr = ptr >>> 0;
+      return getUint8ArrayMemory02().subarray(ptr / 1, ptr / 1 + len);
+    }
+    var cachedDataViewMemory0 = null;
+    function getDataViewMemory0() {
+      if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || cachedDataViewMemory0.buffer.detached === void 0 && cachedDataViewMemory0.buffer !== wasm2.memory.buffer) {
+        cachedDataViewMemory0 = new DataView(wasm2.memory.buffer);
+      }
+      return cachedDataViewMemory0;
+    }
+    function getStringFromWasm02(ptr, len) {
+      ptr = ptr >>> 0;
+      return decodeText2(ptr, len);
+    }
+    var cachedUint8ArrayMemory02 = null;
+    function getUint8ArrayMemory02() {
+      if (cachedUint8ArrayMemory02 === null || cachedUint8ArrayMemory02.byteLength === 0) {
+        cachedUint8ArrayMemory02 = new Uint8Array(wasm2.memory.buffer);
+      }
+      return cachedUint8ArrayMemory02;
+    }
+    function handleError(f, args) {
+      try {
+        return f.apply(this, args);
+      } catch (e) {
+        const idx = addToExternrefTable0(e);
+        wasm2.__wbindgen_exn_store(idx);
+      }
+    }
+    function isLikeNone2(x) {
+      return x === void 0 || x === null;
+    }
+    function passStringToWasm02(arg, malloc, realloc) {
+      if (realloc === void 0) {
+        const buf = cachedTextEncoder2.encode(arg);
+        const ptr2 = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory02().subarray(ptr2, ptr2 + buf.length).set(buf);
+        WASM_VECTOR_LEN2 = buf.length;
+        return ptr2;
+      }
+      let len = arg.length;
+      let ptr = malloc(len, 1) >>> 0;
+      const mem = getUint8ArrayMemory02();
+      let offset = 0;
+      for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 127) break;
+        mem[ptr + offset] = code;
+      }
+      if (offset !== len) {
+        if (offset !== 0) {
+          arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory02().subarray(ptr + offset, ptr + len);
+        const ret = cachedTextEncoder2.encodeInto(arg, view);
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+      }
+      WASM_VECTOR_LEN2 = offset;
+      return ptr;
+    }
+    function takeFromExternrefTable02(idx) {
+      const value = wasm2.__wbindgen_externrefs.get(idx);
+      wasm2.__externref_table_dealloc(idx);
+      return value;
+    }
+    var cachedTextDecoder2 = new TextDecoder("utf-8", { ignoreBOM: true, fatal: true });
+    cachedTextDecoder2.decode();
+    function decodeText2(ptr, len) {
+      return cachedTextDecoder2.decode(getUint8ArrayMemory02().subarray(ptr, ptr + len));
+    }
+    var cachedTextEncoder2 = new TextEncoder();
+    if (!("encodeInto" in cachedTextEncoder2)) {
+      cachedTextEncoder2.encodeInto = function(arg, view) {
+        const buf = cachedTextEncoder2.encode(arg);
+        view.set(buf);
+        return {
+          read: arg.length,
+          written: buf.length
+        };
+      };
+    }
+    var WASM_VECTOR_LEN2 = 0;
+    var wasmPath = `${__dirname}/automerge_wasm_bg.wasm`;
+    var wasmBytes = __require("fs").readFileSync(wasmPath);
+    var wasmModule = new WebAssembly.Module(wasmBytes);
+    var wasm2 = new WebAssembly.Instance(wasmModule, __wbg_get_imports()).exports;
+    wasm2.__wbindgen_start();
+  }
+});
+
+// node_modules/.pnpm/@automerge+automerge@3.2.6/node_modules/@automerge/automerge/dist/mjs/wasm_bindgen_output/web/automerge_wasm.js
+var Automerge = class _Automerge {
+  static __wrap(ptr) {
+    ptr = ptr >>> 0;
+    const obj = Object.create(_Automerge.prototype);
+    obj.__wbg_ptr = ptr;
+    AutomergeFinalization.register(obj, obj.__wbg_ptr, obj);
+    return obj;
+  }
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    AutomergeFinalization.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_automerge_free(ptr, 0);
+  }
+  /**
+   * @param {any} object
+   * @param {any} meta
+   * @returns {any}
+   */
+  applyAndReturnPatches(object, meta) {
+    const ret = wasm.automerge_applyAndReturnPatches(this.__wbg_ptr, object, meta);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+  }
+  /**
+   * @param {Change[]} changes
+   */
+  applyChanges(changes) {
+    const ret = wasm.automerge_applyChanges(this.__wbg_ptr, changes);
+    if (ret[1]) {
+      throw takeFromExternrefTable0(ret[0]);
+    }
+  }
+  /**
+   * @param {any} object
+   * @param {any} meta
+   * @returns {any}
+   */
+  applyPatches(object, meta) {
+    const ret = wasm.automerge_applyPatches(this.__wbg_ptr, object, meta);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+  }
+  /**
+   * @param {string | null} [actor]
+   * @returns {Automerge}
+   */
+  clone(actor) {
+    var ptr0 = isLikeNone(actor) ? 0 : passStringToWasm0(actor, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len0 = WASM_VECTOR_LEN;
+    const ret = wasm.automerge_clone(this.__wbg_ptr, ptr0, len0);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return _Automerge.__wrap(ret[0]);
+  }
+  /**
+   * @param {string | null} [message]
+   * @param {number | null} [time]
+   * @returns {Hash | null}
+   */
+  commit(message, time) {
+    var ptr0 = isLikeNone(message) ? 0 : passStringToWasm0(message, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len0 = WASM_VECTOR_LEN;
+    const ret = wasm.automerge_commit(this.__wbg_ptr, ptr0, len0, !isLikeNone(time), isLikeNone(time) ? 0 : time);
+    return ret;
+  }
+  /**
+   * @param {ObjID} obj
+   * @param {Prop} prop
+   */
+  delete(obj, prop) {
+    const ret = wasm.automerge_delete(this.__wbg_ptr, obj, prop);
+    if (ret[1]) {
+      throw takeFromExternrefTable0(ret[0]);
+    }
+  }
+  /**
+   * @param {Heads} before
+   * @param {Heads} after
+   * @returns {Patch[]}
+   */
+  diff(before, after) {
+    const ret = wasm.automerge_diff(this.__wbg_ptr, before, after);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+  }
+  /**
+   * @returns {Patch[]}
+   */
+  diffIncremental() {
+    const ret = wasm.automerge_diffIncremental(this.__wbg_ptr);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+  }
+  /**
+   * @param {Prop[] | string} path
+   * @param {Heads} before
+   * @param {Heads} after
+   * @param {any} options
+   * @returns {Array<any>}
+   */
+  diffPath(path, before, after, options) {
+    const ret = wasm.automerge_diffPath(this.__wbg_ptr, path, before, after, options);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+  }
+  dump() {
+    wasm.automerge_dump(this.__wbg_ptr);
+  }
+  /**
+   * @param {string | null} [message]
+   * @param {number | null} [time]
+   * @returns {Hash}
+   */
+  emptyChange(message, time) {
+    var ptr0 = isLikeNone(message) ? 0 : passStringToWasm0(message, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len0 = WASM_VECTOR_LEN;
+    const ret = wasm.automerge_emptyChange(this.__wbg_ptr, ptr0, len0, !isLikeNone(time), isLikeNone(time) ? 0 : time);
+    return ret;
+  }
+  /**
+   * @param {boolean} enable
+   * @returns {boolean}
+   */
+  enableFreeze(enable) {
+    const ret = wasm.automerge_enableFreeze(this.__wbg_ptr, enable);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0] !== 0;
+  }
+  /**
+   * @param {string | null | undefined} actor
+   * @param {any} heads
+   * @returns {Automerge}
+   */
+  fork(actor, heads) {
+    var ptr0 = isLikeNone(actor) ? 0 : passStringToWasm0(actor, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len0 = WASM_VECTOR_LEN;
+    const ret = wasm.automerge_fork(this.__wbg_ptr, ptr0, len0, heads);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return _Automerge.__wrap(ret[0]);
+  }
+  /**
+   * @param {SyncState} state
+   * @returns {SyncMessage | null}
+   */
+  generateSyncMessage(state) {
+    _assertClass(state, SyncState);
+    const ret = wasm.automerge_generateSyncMessage(this.__wbg_ptr, state.__wbg_ptr);
+    return ret;
+  }
+  /**
+   * @param {any} obj
+   * @param {any} prop
+   * @param {any} heads
+   * @returns {any}
+   */
+  get(obj, prop, heads) {
+    const ret = wasm.automerge_get(this.__wbg_ptr, obj, prop, heads);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+  }
+  /**
+   * @returns {Actor}
+   */
+  getActorId() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const ret = wasm.automerge_getActorId(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+      wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+  }
+  /**
+   * @param {any} obj
+   * @param {any} arg
+   * @param {any} heads
+   * @returns {Array<any>}
+   */
+  getAll(obj, arg, heads) {
+    const ret = wasm.automerge_getAll(this.__wbg_ptr, obj, arg, heads);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+  }
+  /**
+   * @param {any} text
+   * @param {number} index
+   * @param {any} heads
+   * @returns {any}
+   */
+  getBlock(text, index, heads) {
+    const ret = wasm.automerge_getBlock(this.__wbg_ptr, text, index, heads);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+  }
+  /**
+   * @param {Hash} hash
+   * @returns {Change | null}
+   */
+  getChangeByHash(hash) {
+    const ret = wasm.automerge_getChangeByHash(this.__wbg_ptr, hash);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+  }
+  /**
+   * @param {Hash} hash
+   * @returns {ChangeMetadata | null}
+   */
+  getChangeMetaByHash(hash) {
+    const ret = wasm.automerge_getChangeMetaByHash(this.__wbg_ptr, hash);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+  }
+  /**
+   * @param {Heads} have_deps
+   * @returns {Change[]}
+   */
+  getChanges(have_deps) {
+    const ret = wasm.automerge_getChanges(this.__wbg_ptr, have_deps);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+  }
+  /**
+   * @param {Automerge} other
+   * @returns {Change[]}
+   */
+  getChangesAdded(other) {
+    _assertClass(other, _Automerge);
+    const ret = wasm.automerge_getChangesAdded(this.__wbg_ptr, other.__wbg_ptr);
+    return ret;
+  }
+  /**
+   * @param {Heads} have_deps
+   * @returns {ChangeMetadata[]}
+   */
+  getChangesMeta(have_deps) {
+    const ret = wasm.automerge_getChangesMeta(this.__wbg_ptr, have_deps);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+  }
+  /**
+   * @param {any} obj
+   * @param {any} position
+   * @param {any} heads
+   * @param {any} move_cursor
+   * @returns {string}
+   */
+  getCursor(obj, position, heads, move_cursor) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+      const ret = wasm.automerge_getCursor(this.__wbg_ptr, obj, position, heads, move_cursor);
+      var ptr1 = ret[0];
+      var len1 = ret[1];
+      if (ret[3]) {
+        ptr1 = 0;
+        len1 = 0;
+        throw takeFromExternrefTable0(ret[2]);
+      }
+      deferred2_0 = ptr1;
+      deferred2_1 = len1;
+      return getStringFromWasm0(ptr1, len1);
+    } finally {
+      wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+  }
+  /**
+   * @param {any} obj
+   * @param {any} cursor
+   * @param {any} heads
+   * @returns {number}
+   */
+  getCursorPosition(obj, cursor, heads) {
+    const ret = wasm.automerge_getCursorPosition(this.__wbg_ptr, obj, cursor, heads);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+  }
+  /**
+   * @param {Hash} hash
+   * @returns {DecodedChange | null}
+   */
+  getDecodedChangeByHash(hash) {
+    const ret = wasm.automerge_getDecodedChangeByHash(this.__wbg_ptr, hash);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+  }
+  /**
+   * @returns {Heads}
+   */
+  getHeads() {
+    const ret = wasm.automerge_getHeads(this.__wbg_ptr);
+    return ret;
+  }
+  /**
+   * @returns {Change | null}
+   */
+  getLastLocalChange() {
+    const ret = wasm.automerge_getLastLocalChange(this.__wbg_ptr);
+    return ret;
+  }
+  /**
+   * @param {any} heads
+   * @returns {Array<any>}
+   */
+  getMissingDeps(heads) {
+    const ret = wasm.automerge_getMissingDeps(this.__wbg_ptr, heads);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+  }
+  /**
+   * @param {any} obj
+   * @param {any} prop
+   * @param {any} heads
+   * @returns {any}
+   */
+  getWithType(obj, prop, heads) {
+    const ret = wasm.automerge_getWithType(this.__wbg_ptr, obj, prop, heads);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+  }
+  /**
+   * @param {SyncState} state
+   * @returns {boolean}
+   */
+  hasOurChanges(state) {
+    _assertClass(state, SyncState);
+    const ret = wasm.automerge_hasOurChanges(this.__wbg_ptr, state.__wbg_ptr);
+    return ret !== 0;
+  }
+  /**
+   * @param {ObjID} obj
+   * @param {Prop} prop
+   * @param {number} value
+   */
+  increment(obj, prop, value) {
+    const ret = wasm.automerge_increment(this.__wbg_ptr, obj, prop, value);
+    if (ret[1]) {
+      throw takeFromExternrefTable0(ret[0]);
+    }
+  }
+  /**
+   * Initialize the root object of an empty document from a JS object.
+   * This is much faster than setting keys one at a time for large initial states.
+   * @param {any} value
+   */
+  initRootFromHydrate(value) {
+    const ret = wasm.automerge_initRootFromHydrate(this.__wbg_ptr, value);
+    if (ret[1]) {
+      throw takeFromExternrefTable0(ret[0]);
+    }
+  }
+  /**
+   * @param {any} obj
+   * @param {number} index
+   * @param {any} value
+   * @param {any} datatype
+   */
+  insert(obj, index, value, datatype) {
+    const ret = wasm.automerge_insert(this.__wbg_ptr, obj, index, value, datatype);
+    if (ret[1]) {
+      throw takeFromExternrefTable0(ret[0]);
+    }
+  }
+  /**
+   * @param {ObjID} obj
+   * @param {number} index
+   * @param {ObjType} value
+   * @returns {ObjID}
+   */
+  insertObject(obj, index, value) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+      const ret = wasm.automerge_insertObject(this.__wbg_ptr, obj, index, value);
+      var ptr1 = ret[0];
+      var len1 = ret[1];
+      if (ret[3]) {
+        ptr1 = 0;
+        len1 = 0;
+        throw takeFromExternrefTable0(ret[2]);
+      }
+      deferred2_0 = ptr1;
+      deferred2_1 = len1;
+      return getStringFromWasm0(ptr1, len1);
+    } finally {
+      wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+  }
+  /**
+   * Insert a nested JavaScript value into a list using batch insertion.
+   * This is much faster than insertObject for large nested objects.
+   * The value is inserted at the given index, shifting subsequent elements.
+   * @param {ObjID} obj
+   * @param {number} index
+   * @param {any} value
+   * @returns {ObjID}
+   */
+  insertObjectFromHydrate(obj, index, value) {
+    const ret = wasm.automerge_insertObjectFromHydrate(this.__wbg_ptr, obj, index, value);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+  }
+  integrate() {
+    wasm.automerge_integrate(this.__wbg_ptr);
+  }
+  /**
+   * @param {Heads} heads
+   */
+  isolate(heads) {
+    const ret = wasm.automerge_isolate(this.__wbg_ptr, heads);
+    if (ret[1]) {
+      throw takeFromExternrefTable0(ret[0]);
+    }
+  }
+  /**
+   * @param {ObjID} obj
+   * @param {number} index
+   */
+  joinBlock(obj, index) {
+    const ret = wasm.automerge_joinBlock(this.__wbg_ptr, obj, index);
+    if (ret[1]) {
+      throw takeFromExternrefTable0(ret[0]);
+    }
+  }
+  /**
+   * @param {any} obj
+   * @param {any} heads
+   * @returns {Array<any>}
+   */
+  keys(obj, heads) {
+    const ret = wasm.automerge_keys(this.__wbg_ptr, obj, heads);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+  }
+  /**
+   * @param {any} obj
+   * @param {any} heads
+   * @returns {number}
+   */
+  length(obj, heads) {
+    const ret = wasm.automerge_length(this.__wbg_ptr, obj, heads);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+  }
+  /**
+   * @param {Uint8Array} data
+   * @returns {number}
+   */
+  loadIncremental(data) {
+    const ret = wasm.automerge_loadIncremental(this.__wbg_ptr, data);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+  }
+  /**
+   * @param {any} obj
+   * @param {any} range
+   * @param {any} name
+   * @param {any} value
+   * @param {any} datatype
+   */
+  mark(obj, range, name, value, datatype) {
+    const ret = wasm.automerge_mark(this.__wbg_ptr, obj, range, name, value, datatype);
+    if (ret[1]) {
+      throw takeFromExternrefTable0(ret[0]);
+    }
+  }
+  /**
+   * @param {any} obj
+   * @param {any} heads
+   * @returns {any}
+   */
+  marks(obj, heads) {
+    const ret = wasm.automerge_marks(this.__wbg_ptr, obj, heads);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+  }
+  /**
+   * @param {any} obj
+   * @param {number} index
+   * @param {any} heads
+   * @returns {object}
+   */
+  marksAt(obj, index, heads) {
+    const ret = wasm.automerge_marksAt(this.__wbg_ptr, obj, index, heads);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+  }
+  /**
+   * @param {any} obj
+   * @param {any} heads
+   * @param {any} meta
+   * @returns {any}
+   */
+  materialize(obj, heads, meta) {
+    const ret = wasm.automerge_materialize(this.__wbg_ptr, obj, heads, meta);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+  }
+  /**
+   * @param {Automerge} other
+   * @returns {Heads}
+   */
+  merge(other) {
+    _assertClass(other, _Automerge);
+    const ret = wasm.automerge_merge(this.__wbg_ptr, other.__wbg_ptr);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+  }
+  /**
+   * @param {string | null} [actor]
+   * @returns {Automerge}
+   */
+  static new(actor) {
+    var ptr0 = isLikeNone(actor) ? 0 : passStringToWasm0(actor, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len0 = WASM_VECTOR_LEN;
+    const ret = wasm.automerge_new(ptr0, len0);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return _Automerge.__wrap(ret[0]);
+  }
+  /**
+   * @param {any} obj
+   * @param {any} heads
+   * @returns {object}
+   */
+  objInfo(obj, heads) {
+    const ret = wasm.automerge_objInfo(this.__wbg_ptr, obj, heads);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+  }
+  /**
+   * @returns {number}
+   */
+  pendingOps() {
+    const ret = wasm.automerge_pendingOps(this.__wbg_ptr);
+    return ret;
+  }
+  /**
+   * @param {any} obj
+   * @param {any} value
+   * @param {any} datatype
+   */
+  push(obj, value, datatype) {
+    const ret = wasm.automerge_push(this.__wbg_ptr, obj, value, datatype);
+    if (ret[1]) {
+      throw takeFromExternrefTable0(ret[0]);
+    }
+  }
+  /**
+   * @param {ObjID} obj
+   * @param {ObjType} value
+   * @returns {ObjID}
+   */
+  pushObject(obj, value) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+      const ret = wasm.automerge_pushObject(this.__wbg_ptr, obj, value);
+      var ptr1 = ret[0];
+      var len1 = ret[1];
+      if (ret[3]) {
+        ptr1 = 0;
+        len1 = 0;
+        throw takeFromExternrefTable0(ret[2]);
+      }
+      deferred2_0 = ptr1;
+      deferred2_1 = len1;
+      return getStringFromWasm0(ptr1, len1);
+    } finally {
+      wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+  }
+  /**
+   * @param {any} obj
+   * @param {any} prop
+   * @param {any} value
+   * @param {any} datatype
+   */
+  put(obj, prop, value, datatype) {
+    const ret = wasm.automerge_put(this.__wbg_ptr, obj, prop, value, datatype);
+    if (ret[1]) {
+      throw takeFromExternrefTable0(ret[0]);
+    }
+  }
+  /**
+   * @param {ObjID} obj
+   * @param {Prop} prop
+   * @param {ObjType} value
+   * @returns {ObjID}
+   */
+  putObject(obj, prop, value) {
+    const ret = wasm.automerge_putObject(this.__wbg_ptr, obj, prop, value);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+  }
+  /**
+   * Put a nested JavaScript value as a new object tree using batch insertion.
+   * This is much faster than putObject for large nested objects.
+   * For map keys this overwrites any existing value. For list indices this
+   * overwrites the element at that index.
+   * @param {ObjID} obj
+   * @param {Prop} prop
+   * @param {any} value
+   * @returns {ObjID}
+   */
+  putObjectFromHydrate(obj, prop, value) {
+    const ret = wasm.automerge_putObjectFromHydrate(this.__wbg_ptr, obj, prop, value);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+  }
+  /**
+   * @param {SyncState} state
+   * @param {SyncMessage} message
+   */
+  receiveSyncMessage(state, message) {
+    _assertClass(state, SyncState);
+    const ret = wasm.automerge_receiveSyncMessage(this.__wbg_ptr, state.__wbg_ptr, message);
+    if (ret[1]) {
+      throw takeFromExternrefTable0(ret[0]);
+    }
+  }
+  /**
+   * @param {string} datatype
+   * @param {Function} construct
+   * @param {(arg: any) => any | undefined} deconstruct
+   */
+  registerDatatype(datatype, construct, deconstruct) {
+    const ret = wasm.automerge_registerDatatype(this.__wbg_ptr, datatype, construct, deconstruct);
+    if (ret[1]) {
+      throw takeFromExternrefTable0(ret[0]);
+    }
+  }
+  resetDiffCursor() {
+    wasm.automerge_resetDiffCursor(this.__wbg_ptr);
+  }
+  /**
+   * @returns {number}
+   */
+  rollback() {
+    const ret = wasm.automerge_rollback(this.__wbg_ptr);
+    return ret;
+  }
+  /**
+   * @returns {Uint8Array}
+   */
+  save() {
+    const ret = wasm.automerge_save(this.__wbg_ptr);
+    return ret;
+  }
+  /**
+   * @returns {Uint8Array}
+   */
+  saveAndVerify() {
+    const ret = wasm.automerge_saveAndVerify(this.__wbg_ptr);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+  }
+  /**
+   * @param {any} hashes
+   * @returns {Uint8Array}
+   */
+  saveBundle(hashes) {
+    const ret = wasm.automerge_saveBundle(this.__wbg_ptr, hashes);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+  }
+  /**
+   * @returns {Uint8Array}
+   */
+  saveIncremental() {
+    const ret = wasm.automerge_saveIncremental(this.__wbg_ptr);
+    return ret;
+  }
+  /**
+   * @returns {Uint8Array}
+   */
+  saveNoCompress() {
+    const ret = wasm.automerge_saveNoCompress(this.__wbg_ptr);
+    return ret;
+  }
+  /**
+   * @param {Heads} heads
+   * @returns {Uint8Array}
+   */
+  saveSince(heads) {
+    const ret = wasm.automerge_saveSince(this.__wbg_ptr, heads);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+  }
+  /**
+   * @param {any} obj
+   * @param {any} heads
+   * @returns {Array<any>}
+   */
+  spans(obj, heads) {
+    const ret = wasm.automerge_spans(this.__wbg_ptr, obj, heads);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+  }
+  /**
+   * @param {any} obj
+   * @param {number} start
+   * @param {number} delete_count
+   * @param {any} text
+   */
+  splice(obj, start, delete_count, text) {
+    const ret = wasm.automerge_splice(this.__wbg_ptr, obj, start, delete_count, text);
+    if (ret[1]) {
+      throw takeFromExternrefTable0(ret[0]);
+    }
+  }
+  /**
+   * Splice values into a list using batch insertion.
+   * This is much faster than individual insert calls for multiple values.
+   * @param {ObjID} obj
+   * @param {number} index
+   * @param {number} del
+   * @param {any} values
+   */
+  spliceFromHydrate(obj, index, del, values) {
+    const ret = wasm.automerge_spliceFromHydrate(this.__wbg_ptr, obj, index, del, values);
+    if (ret[1]) {
+      throw takeFromExternrefTable0(ret[0]);
+    }
+  }
+  /**
+   * @param {ObjID} obj
+   * @param {number} index
+   * @param {{[key: string]: MaterializeValue}} block
+   */
+  splitBlock(obj, index, block) {
+    const ret = wasm.automerge_splitBlock(this.__wbg_ptr, obj, index, block);
+    if (ret[1]) {
+      throw takeFromExternrefTable0(ret[0]);
+    }
+  }
+  /**
+   * @returns {Stats}
+   */
+  stats() {
+    const ret = wasm.automerge_stats(this.__wbg_ptr);
+    return ret;
+  }
+  /**
+   * @param {any} obj
+   * @param {any} heads
+   * @returns {string}
+   */
+  text(obj, heads) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+      const ret = wasm.automerge_text(this.__wbg_ptr, obj, heads);
+      var ptr1 = ret[0];
+      var len1 = ret[1];
+      if (ret[3]) {
+        ptr1 = 0;
+        len1 = 0;
+        throw takeFromExternrefTable0(ret[2]);
+      }
+      deferred2_0 = ptr1;
+      deferred2_1 = len1;
+      return getStringFromWasm0(ptr1, len1);
+    } finally {
+      wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+  }
+  /**
+   * @param {any} meta
+   * @returns {MaterializeValue}
+   */
+  toJS(meta) {
+    const ret = wasm.automerge_toJS(this.__wbg_ptr, meta);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+  }
+  /**
+   * @returns {Hash[]}
+   */
+  topoHistoryTraversal() {
+    const ret = wasm.automerge_topoHistoryTraversal(this.__wbg_ptr);
+    return ret;
+  }
+  /**
+   * @param {ObjID} obj
+   * @param {MarkRange} range
+   * @param {string} name
+   */
+  unmark(obj, range, name) {
+    const ret = wasm.automerge_unmark(this.__wbg_ptr, obj, range, name);
+    if (ret[1]) {
+      throw takeFromExternrefTable0(ret[0]);
+    }
+  }
+  /**
+   * @param {ObjID} obj
+   * @param {number} index
+   * @param {{[key: string]: MaterializeValue}} block
+   */
+  updateBlock(obj, index, block) {
+    const ret = wasm.automerge_updateBlock(this.__wbg_ptr, obj, index, block);
+    if (ret[1]) {
+      throw takeFromExternrefTable0(ret[0]);
+    }
+  }
+  updateDiffCursor() {
+    wasm.automerge_updateDiffCursor(this.__wbg_ptr);
+  }
+  /**
+   * @param {ObjID} obj
+   * @param {Span[]} args
+   * @param {UpdateSpansConfig | undefined | null} config
+   */
+  updateSpans(obj, args, config) {
+    const ret = wasm.automerge_updateSpans(this.__wbg_ptr, obj, args, config);
+    if (ret[1]) {
+      throw takeFromExternrefTable0(ret[0]);
+    }
+  }
+  /**
+   * @param {ObjID} obj
+   * @param {string} new_text
+   */
+  updateText(obj, new_text) {
+    const ret = wasm.automerge_updateText(this.__wbg_ptr, obj, new_text);
+    if (ret[1]) {
+      throw takeFromExternrefTable0(ret[0]);
+    }
+  }
+};
+if (Symbol.dispose) Automerge.prototype[Symbol.dispose] = Automerge.prototype.free;
+var SyncState = class _SyncState {
+  static __wrap(ptr) {
+    ptr = ptr >>> 0;
+    const obj = Object.create(_SyncState.prototype);
+    obj.__wbg_ptr = ptr;
+    SyncStateFinalization.register(obj, obj.__wbg_ptr, obj);
+    return obj;
+  }
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    SyncStateFinalization.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_syncstate_free(ptr, 0);
+  }
+  /**
+   * @returns {SyncState}
+   */
+  clone() {
+    const ret = wasm.syncstate_clone(this.__wbg_ptr);
+    return _SyncState.__wrap(ret);
+  }
+  /**
+   * @returns {Heads}
+   */
+  get lastSentHeads() {
+    const ret = wasm.syncstate_lastSentHeads(this.__wbg_ptr);
+    return ret;
+  }
+  /**
+   * @returns {boolean}
+   */
+  get peerReadOnly() {
+    const ret = wasm.syncstate_peerReadOnly(this.__wbg_ptr);
+    return ret !== 0;
+  }
+  /**
+   * @returns {boolean}
+   */
+  get readOnly() {
+    const ret = wasm.syncstate_readOnly(this.__wbg_ptr);
+    return ret !== 0;
+  }
+  /**
+   * @param {Heads} heads
+   */
+  set lastSentHeads(heads) {
+    const ret = wasm.syncstate_set_lastSentHeads(this.__wbg_ptr, heads);
+    if (ret[1]) {
+      throw takeFromExternrefTable0(ret[0]);
+    }
+  }
+  /**
+   * @param {boolean} read_only
+   */
+  set readOnly(read_only) {
+    wasm.syncstate_set_readOnly(this.__wbg_ptr, read_only);
+  }
+  /**
+   * @param {Heads} hashes
+   */
+  set sentHashes(hashes) {
+    const ret = wasm.syncstate_set_sentHashes(this.__wbg_ptr, hashes);
+    if (ret[1]) {
+      throw takeFromExternrefTable0(ret[0]);
+    }
+  }
+  /**
+   * @returns {Heads}
+   */
+  get sharedHeads() {
+    const ret = wasm.syncstate_sharedHeads(this.__wbg_ptr);
+    return ret;
+  }
+};
+if (Symbol.dispose) SyncState.prototype[Symbol.dispose] = SyncState.prototype.free;
+var AutomergeFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+}, unregister: () => {
+} } : new FinalizationRegistry((ptr) => wasm.__wbg_automerge_free(ptr >>> 0, 1));
+var SyncStateFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+}, unregister: () => {
+} } : new FinalizationRegistry((ptr) => wasm.__wbg_syncstate_free(ptr >>> 0, 1));
+function _assertClass(instance, klass) {
+  if (!(instance instanceof klass)) {
+    throw new Error(`expected instance of ${klass.name}`);
+  }
+}
+function getStringFromWasm0(ptr, len) {
+  ptr = ptr >>> 0;
+  return decodeText(ptr, len);
+}
+var cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+  if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+    cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+  }
+  return cachedUint8ArrayMemory0;
+}
+function isLikeNone(x) {
+  return x === void 0 || x === null;
+}
+function passStringToWasm0(arg, malloc, realloc) {
+  if (realloc === void 0) {
+    const buf = cachedTextEncoder.encode(arg);
+    const ptr2 = malloc(buf.length, 1) >>> 0;
+    getUint8ArrayMemory0().subarray(ptr2, ptr2 + buf.length).set(buf);
+    WASM_VECTOR_LEN = buf.length;
+    return ptr2;
+  }
+  let len = arg.length;
+  let ptr = malloc(len, 1) >>> 0;
+  const mem = getUint8ArrayMemory0();
+  let offset = 0;
+  for (; offset < len; offset++) {
+    const code = arg.charCodeAt(offset);
+    if (code > 127) break;
+    mem[ptr + offset] = code;
+  }
+  if (offset !== len) {
+    if (offset !== 0) {
+      arg = arg.slice(offset);
+    }
+    ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+    const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+    const ret = cachedTextEncoder.encodeInto(arg, view);
+    offset += ret.written;
+    ptr = realloc(ptr, len, offset, 1) >>> 0;
+  }
+  WASM_VECTOR_LEN = offset;
+  return ptr;
+}
+function takeFromExternrefTable0(idx) {
+  const value = wasm.__wbindgen_externrefs.get(idx);
+  wasm.__externref_table_dealloc(idx);
+  return value;
+}
+var cachedTextDecoder = new TextDecoder("utf-8", { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+var MAX_SAFARI_DECODE_BYTES = 2146435072;
+var numBytesDecoded = 0;
+function decodeText(ptr, len) {
+  numBytesDecoded += len;
+  if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+    cachedTextDecoder = new TextDecoder("utf-8", { ignoreBOM: true, fatal: true });
+    cachedTextDecoder.decode();
+    numBytesDecoded = len;
+  }
+  return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+var cachedTextEncoder = new TextEncoder();
+if (!("encodeInto" in cachedTextEncoder)) {
+  cachedTextEncoder.encodeInto = function(arg, view) {
+    const buf = cachedTextEncoder.encode(arg);
+    view.set(buf);
+    return {
+      read: arg.length,
+      written: buf.length
+    };
+  };
+}
+var WASM_VECTOR_LEN = 0;
+var wasm;
+
+// node_modules/.pnpm/@automerge+automerge@3.2.6/node_modules/@automerge/automerge/dist/mjs/low_level.js
+var _initialized = false;
+var _initializeListeners = [];
+function UseApi(api2) {
+  for (const k in api2) {
+    ;
+    ApiHandler[k] = api2[k];
+  }
+  _initialized = true;
+  for (const listener of _initializeListeners) {
+    listener();
+  }
+}
+var ApiHandler = {
+  create(options) {
+    throw new RangeError("Automerge.use() not called");
+  },
+  load(data, options) {
+    throw new RangeError("Automerge.use() not called (load)");
+  },
+  encodeChange(change) {
+    throw new RangeError("Automerge.use() not called (encodeChange)");
+  },
+  decodeChange(change) {
+    throw new RangeError("Automerge.use() not called (decodeChange)");
+  },
+  initSyncState() {
+    throw new RangeError("Automerge.use() not called (initSyncState)");
+  },
+  encodeSyncMessage(message) {
+    throw new RangeError("Automerge.use() not called (encodeSyncMessage)");
+  },
+  decodeSyncMessage(msg) {
+    throw new RangeError("Automerge.use() not called (decodeSyncMessage)");
+  },
+  encodeSyncState(state) {
+    throw new RangeError("Automerge.use() not called (encodeSyncState)");
+  },
+  decodeSyncState(data) {
+    throw new RangeError("Automerge.use() not called (decodeSyncState)");
+  },
+  exportSyncState(state) {
+    throw new RangeError("Automerge.use() not called (exportSyncState)");
+  },
+  importSyncState(state) {
+    throw new RangeError("Automerge.use() not called (importSyncState)");
+  },
+  readBundle(data) {
+    throw new RangeError("Automerge.use() not called (readBundle)");
+  },
+  wasmReleaseInfo() {
+    throw new RangeError("Automerge.use() not called (wasmReleaseInfo)");
+  }
+};
+
+// node_modules/.pnpm/@automerge+automerge@3.2.6/node_modules/@automerge/automerge/dist/mjs/entrypoints/fullfat_node.js
+var api = __toESM(require_automerge_wasm(), 1);
+
+// node_modules/.pnpm/@automerge+automerge@3.2.6/node_modules/@automerge/automerge/dist/mjs/constants.js
+var STATE = /* @__PURE__ */ Symbol.for("_am_meta");
+var TRACE = /* @__PURE__ */ Symbol.for("_am_trace");
+var OBJECT_ID = /* @__PURE__ */ Symbol.for("_am_objectId");
+var IS_PROXY = /* @__PURE__ */ Symbol.for("_am_isProxy");
+var CLEAR_CACHE = /* @__PURE__ */ Symbol.for("_am_clearCache");
+var UINT = /* @__PURE__ */ Symbol.for("_am_uint");
+var INT = /* @__PURE__ */ Symbol.for("_am_int");
+var F64 = /* @__PURE__ */ Symbol.for("_am_f64");
+var COUNTER = /* @__PURE__ */ Symbol.for("_am_counter");
+var IMMUTABLE_STRING = /* @__PURE__ */ Symbol.for("_am_immutableString");
+
+// node_modules/.pnpm/@automerge+automerge@3.2.6/node_modules/@automerge/automerge/dist/mjs/counter.js
+var Counter = class {
+  constructor(value) {
+    this.value = value || 0;
+    Reflect.defineProperty(this, COUNTER, { value: true });
+  }
+  /**
+   * A peculiar JavaScript language feature from its early days: if the object
+   * `x` has a `valueOf()` method that returns a number, you can use numerical
+   * operators on the object `x` directly, such as `x + 1` or `x < 4`.
+   * This method is also called when coercing a value to a string by
+   * concatenating it with another string, as in `x + ''`.
+   * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/valueOf
+   */
+  valueOf() {
+    return this.value;
+  }
+  /**
+   * Returns the counter value as a decimal string. If `x` is a counter object,
+   * this method is called e.g. when you do `['value: ', x].join('')` or when
+   * you use string interpolation: `value: ${x}`.
+   */
+  toString() {
+    return this.valueOf().toString();
+  }
+  /**
+   * Returns the counter value, so that a JSON serialization of an Automerge
+   * document represents the counter simply as an integer.
+   */
+  toJSON() {
+    return this.value;
+  }
+  /**
+   * Increases the value of the counter by `delta`. If `delta` is not given,
+   * increases the value of the counter by 1.
+   *
+   * Will throw an error if used outside of a change callback.
+   */
+  increment(_delta) {
+    throw new Error("Counters should not be incremented outside of a change callback");
+  }
+  /**
+   * Decreases the value of the counter by `delta`. If `delta` is not given,
+   * decreases the value of the counter by 1.
+   *
+   * Will throw an error if used outside of a change callback.
+   */
+  decrement(_delta) {
+    throw new Error("Counters should not be decremented outside of a change callback");
+  }
+};
+var WriteableCounter = class extends Counter {
+  constructor(value, context, path, objectId, key) {
+    super(value);
+    this.context = context;
+    this.path = path;
+    this.objectId = objectId;
+    this.key = key;
+  }
+  /**
+   * Increases the value of the counter by `delta`. If `delta` is not given,
+   * increases the value of the counter by 1.
+   */
+  increment(delta) {
+    delta = typeof delta === "number" ? delta : 1;
+    this.context.increment(this.objectId, this.key, delta);
+    this.value += delta;
+    return this.value;
+  }
+  /**
+   * Decreases the value of the counter by `delta`. If `delta` is not given,
+   * decreases the value of the counter by 1.
+   */
+  decrement(delta) {
+    return this.increment(typeof delta === "number" ? -delta : -1);
+  }
+};
+function getWriteableCounter(value, context, path, objectId, key) {
+  return new WriteableCounter(value, context, path, objectId, key);
+}
+
+// node_modules/.pnpm/@automerge+automerge@3.2.6/node_modules/@automerge/automerge/dist/mjs/immutable_string.js
+var _a;
+var ImmutableString = class {
+  constructor(val) {
+    this[_a] = true;
+    this.val = val;
+  }
+  /**
+   * Returns the content of the ImmutableString object as a simple string
+   */
+  toString() {
+    return this.val;
+  }
+  toJSON() {
+    return this.val;
+  }
+};
+_a = IMMUTABLE_STRING;
+
+// node_modules/.pnpm/@automerge+automerge@3.2.6/node_modules/@automerge/automerge/dist/mjs/proxies.js
+var MAX_I64 = BigInt("9223372036854775807");
+function validateForBatchInsert(value, context, path) {
+  if (value === void 0) {
+    throw new RangeError([
+      `Cannot assign undefined value at ${printPath(path)}, `,
+      "You might consider setting the property's value to `null`, ",
+      "or using `delete` to remove it altogether."
+    ].join(""));
+  }
+  if (value === null)
+    return;
+  const type = typeof value;
+  if (type !== "object")
+    return;
+  if (context && isSameDocument(value, context)) {
+    throw new RangeError("Cannot create a reference to an existing document object");
+  }
+  if (value instanceof Array) {
+    for (let i = 0; i < value.length; i++) {
+      validateForBatchInsert(value[i], context, [...path, i]);
+    }
+  } else if (Object.prototype.toString.call(value) === "[object Object]") {
+    for (const k in value) {
+      validateForBatchInsert(value[k], context, [...path, k]);
+    }
+  }
+}
+function parseListIndex(key) {
+  if (typeof key === "string" && /^[0-9]+$/.test(key))
+    key = parseInt(key, 10);
+  if (typeof key !== "number") {
+    return key;
+  }
+  if (key < 0 || isNaN(key) || key === Infinity || key === -Infinity) {
+    throw new RangeError("A list index must be positive, but you passed " + key);
+  }
+  return key;
+}
+function valueAt(target, prop) {
+  const { context, objectId, path } = target;
+  const value = context.getWithType(objectId, prop);
+  if (value === null) {
+    return;
+  }
+  const datatype = value[0];
+  const val = value[1];
+  switch (datatype) {
+    case void 0:
+      return;
+    case "map":
+      return mapProxy(context, val, [...path, prop]);
+    case "list":
+      return listProxy(context, val, [...path, prop]);
+    case "text":
+      return context.text(val);
+    case "str":
+      return new ImmutableString(val);
+    case "uint":
+      return val;
+    case "int":
+      return val;
+    case "f64":
+      return val;
+    case "boolean":
+      return val;
+    case "null":
+      return null;
+    case "bytes":
+      return val;
+    case "timestamp":
+      return val;
+    case "counter": {
+      const counter = getWriteableCounter(val, context, path, objectId, prop);
+      return counter;
+    }
+    default:
+      throw RangeError(`datatype ${datatype} unimplemented`);
+  }
+}
+function import_value(value, path, context) {
+  const type = typeof value;
+  switch (type) {
+    case "object":
+      if (value == null) {
+        return [null, "null"];
+      } else if (value[UINT]) {
+        return [value.value, "uint"];
+      } else if (value[INT]) {
+        return [value.value, "int"];
+      } else if (value[F64]) {
+        return [value.value, "f64"];
+      } else if (value[COUNTER]) {
+        return [value.value, "counter"];
+      } else if (value instanceof Date) {
+        return [value.getTime(), "timestamp"];
+      } else if (isImmutableString(value)) {
+        return [value.toString(), "str"];
+      } else if (value instanceof Uint8Array) {
+        return [value, "bytes"];
+      } else if (value instanceof Array) {
+        return [value, "list"];
+      } else if (Object.prototype.toString.call(value) === "[object Object]") {
+        return [value, "map"];
+      } else if (isSameDocument(value, context)) {
+        throw new RangeError("Cannot create a reference to an existing document object");
+      } else {
+        throw new RangeError(`Cannot assign unknown object: ${value}`);
+      }
+    case "boolean":
+      return [value, "boolean"];
+    case "bigint":
+      if (value > MAX_I64) {
+        return [value, "uint"];
+      } else {
+        return [value, "int"];
+      }
+    case "number":
+      if (Number.isInteger(value)) {
+        return [value, "int"];
+      } else {
+        return [value, "f64"];
+      }
+    case "string":
+      return [value, "text"];
+    case "undefined":
+      throw new RangeError([
+        `Cannot assign undefined value at ${printPath(path)}, `,
+        "because `undefined` is not a valid JSON data type. ",
+        "You might consider setting the property's value to `null`, ",
+        "or using `delete` to remove it altogether."
+      ].join(""));
+    default:
+      throw new RangeError([
+        `Cannot assign ${type} value at ${printPath(path)}. `,
+        `All JSON primitive datatypes (object, array, string, number, boolean, null) `,
+        `are supported in an Automerge document; ${type} values are not. `
+      ].join(""));
+  }
+}
+function isSameDocument(val, context) {
+  var _b, _c;
+  if (val instanceof Date) {
+    return false;
+  }
+  if (val && ((_c = (_b = val[STATE]) === null || _b === void 0 ? void 0 : _b.handle) === null || _c === void 0 ? void 0 : _c.__wbg_ptr) === context.__wbg_ptr) {
+    return true;
+  }
+  return false;
+}
+var MapHandler = {
+  get(target, key) {
+    const { context, objectId, cache } = target;
+    if (key === Symbol.toStringTag) {
+      return target[Symbol.toStringTag];
+    }
+    if (key === OBJECT_ID)
+      return objectId;
+    if (key === IS_PROXY)
+      return true;
+    if (key === TRACE)
+      return target.trace;
+    if (key === STATE)
+      return { handle: context };
+    if (!cache[key]) {
+      cache[key] = valueAt(target, key);
+    }
+    return cache[key];
+  },
+  set(target, key, val) {
+    const { context, objectId, path } = target;
+    target.cache = {};
+    if (isSameDocument(val, context)) {
+      throw new RangeError("Cannot create a reference to an existing document object");
+    }
+    if (key === TRACE) {
+      target.trace = val;
+      return true;
+    }
+    if (key === CLEAR_CACHE) {
+      return true;
+    }
+    const [value, datatype] = import_value(val, [...path, key], context);
+    switch (datatype) {
+      case "list":
+      case "map": {
+        validateForBatchInsert(value, context, [...path, key]);
+        context.putObjectFromHydrate(objectId, key, value);
+        break;
+      }
+      case "text": {
+        context.putObject(objectId, key, value);
+        break;
+      }
+      default:
+        context.put(objectId, key, value, datatype);
+    }
+    return true;
+  },
+  deleteProperty(target, key) {
+    const { context, objectId } = target;
+    target.cache = {};
+    context.delete(objectId, key);
+    return true;
+  },
+  has(target, key) {
+    const value = this.get(target, key);
+    return value !== void 0;
+  },
+  getOwnPropertyDescriptor(target, key) {
+    const value = this.get(target, key);
+    if (typeof value !== "undefined") {
+      return {
+        configurable: true,
+        enumerable: true,
+        value
+      };
+    }
+  },
+  ownKeys(target) {
+    const { context, objectId } = target;
+    const keys = context.keys(objectId);
+    return [...new Set(keys)];
+  }
+};
+var ListHandler = {
+  get(target, index) {
+    const { context, objectId } = target;
+    index = parseListIndex(index);
+    if (index === Symbol.hasInstance) {
+      return (instance) => {
+        return Array.isArray(instance);
+      };
+    }
+    if (index === Symbol.toStringTag) {
+      return target[Symbol.toStringTag];
+    }
+    if (index === OBJECT_ID)
+      return objectId;
+    if (index === IS_PROXY)
+      return true;
+    if (index === TRACE)
+      return target.trace;
+    if (index === STATE)
+      return { handle: context };
+    if (index === "length")
+      return context.length(objectId);
+    if (typeof index === "number") {
+      return valueAt(target, index);
+    } else {
+      return listMethods(target)[index];
+    }
+  },
+  set(target, index, val) {
+    const { context, objectId, path } = target;
+    index = parseListIndex(index);
+    if (isSameDocument(val, context)) {
+      throw new RangeError("Cannot create a reference to an existing document object");
+    }
+    if (index === CLEAR_CACHE) {
+      return true;
+    }
+    if (index === TRACE) {
+      target.trace = val;
+      return true;
+    }
+    if (typeof index == "string") {
+      throw new RangeError("list index must be a number");
+    }
+    const [value, datatype] = import_value(val, [...path, index], context);
+    switch (datatype) {
+      case "list":
+      case "map": {
+        validateForBatchInsert(value, context, [...path, index]);
+        if (index >= context.length(objectId)) {
+          context.insertObjectFromHydrate(objectId, index, value);
+        } else {
+          context.putObjectFromHydrate(objectId, index, value);
+        }
+        break;
+      }
+      case "text": {
+        if (index >= context.length(objectId)) {
+          context.insertObject(objectId, index, value);
+        } else {
+          context.putObject(objectId, index, value);
+        }
+        break;
+      }
+      default:
+        if (index >= context.length(objectId)) {
+          context.insert(objectId, index, value, datatype);
+        } else {
+          context.put(objectId, index, value, datatype);
+        }
+    }
+    return true;
+  },
+  deleteProperty(target, index) {
+    const { context, objectId } = target;
+    index = parseListIndex(index);
+    const elem = context.get(objectId, index);
+    if (elem != null && elem[0] == "counter") {
+      throw new TypeError("Unsupported operation: deleting a counter from a list");
+    }
+    context.delete(objectId, index);
+    return true;
+  },
+  has(target, index) {
+    const { context, objectId } = target;
+    index = parseListIndex(index);
+    if (typeof index === "number") {
+      return index < context.length(objectId);
+    }
+    return index === "length";
+  },
+  getOwnPropertyDescriptor(target, index) {
+    const { context, objectId } = target;
+    if (index === "length")
+      return { writable: true, value: context.length(objectId) };
+    if (index === OBJECT_ID)
+      return { configurable: false, enumerable: false, value: objectId };
+    index = parseListIndex(index);
+    const value = valueAt(target, index);
+    return { configurable: true, enumerable: true, value };
+  },
+  getPrototypeOf(target) {
+    return Object.getPrototypeOf(target);
+  },
+  ownKeys() {
+    const keys = [];
+    keys.push("length");
+    return keys;
+  }
+};
+function mapProxy(context, objectId, path) {
+  const target = {
+    context,
+    objectId,
+    path: path || [],
+    cache: {}
+  };
+  const proxied = {};
+  Object.assign(proxied, target);
+  const result = new Proxy(proxied, MapHandler);
+  return result;
+}
+function listProxy(context, objectId, path) {
+  const target = {
+    context,
+    objectId,
+    path: path || [],
+    cache: {}
+  };
+  const proxied = [];
+  Object.assign(proxied, target);
+  return new Proxy(proxied, ListHandler);
+}
+function rootProxy(context) {
+  return mapProxy(context, "_root", []);
+}
+function listMethods(target) {
+  const { context, objectId, path } = target;
+  const methods = {
+    at(index) {
+      return valueAt(target, index);
+    },
+    deleteAt(index, numDelete) {
+      if (typeof numDelete === "number") {
+        context.splice(objectId, index, numDelete);
+      } else {
+        context.delete(objectId, index);
+      }
+      return this;
+    },
+    fill(val, start, end) {
+      const [value, datatype] = import_value(val, [...path, start], context);
+      const length = context.length(objectId);
+      start = parseListIndex(start || 0);
+      end = parseListIndex(end || length);
+      for (let i = start; i < Math.min(end, length); i++) {
+        if (datatype === "list" || datatype === "map") {
+          context.putObject(objectId, i, value);
+        } else if (datatype === "text") {
+          context.putObject(objectId, i, value);
+        } else {
+          context.put(objectId, i, value, datatype);
+        }
+      }
+      return this;
+    },
+    indexOf(searchElement, start = 0) {
+      const length = context.length(objectId);
+      for (let i = start; i < length; i++) {
+        const valueWithType = context.getWithType(objectId, i);
+        if (!valueWithType) {
+          continue;
+        }
+        const [valType, value] = valueWithType;
+        const isObject = ["map", "list", "text"].includes(valType);
+        if (!isObject) {
+          if (value === searchElement) {
+            return i;
+          } else {
+            continue;
+          }
+        }
+        if (valType === "text" && typeof searchElement === "string") {
+          if (searchElement === valueAt(target, i)) {
+            return i;
+          }
+        }
+        if (searchElement[OBJECT_ID] === value) {
+          return i;
+        }
+      }
+      return -1;
+    },
+    insertAt(index, ...values) {
+      this.splice(index, 0, ...values);
+      return this;
+    },
+    pop() {
+      const length = context.length(objectId);
+      if (length == 0) {
+        return void 0;
+      }
+      const last = valueAt(target, length - 1);
+      context.delete(objectId, length - 1);
+      return last;
+    },
+    push(...values) {
+      const len = context.length(objectId);
+      this.splice(len, 0, ...values);
+      return context.length(objectId);
+    },
+    shift() {
+      if (context.length(objectId) == 0)
+        return;
+      const first = valueAt(target, 0);
+      context.delete(objectId, 0);
+      return first;
+    },
+    splice(index, del, ...vals) {
+      index = parseListIndex(index);
+      if (typeof del !== "number") {
+        del = context.length(objectId) - index;
+      }
+      del = parseListIndex(del);
+      for (const val of vals) {
+        if (isSameDocument(val, context)) {
+          throw new RangeError("Cannot create a reference to an existing document object");
+        }
+      }
+      const result = [];
+      for (let i = 0; i < del; i++) {
+        const value = valueAt(target, index + i);
+        if (value !== void 0) {
+          result.push(value);
+        }
+      }
+      for (let i = 0; i < vals.length; i++) {
+        try {
+          validateForBatchInsert(vals[i], context, [...path, index + i]);
+        } catch (e) {
+          if (e instanceof RangeError) {
+            throw new RangeError(`${e.message} (at index ${i} in the input)`);
+          } else {
+            throw e;
+          }
+        }
+      }
+      context.spliceFromHydrate(objectId, index, del, vals);
+      return result;
+    },
+    unshift(...values) {
+      this.splice(0, 0, ...values);
+      return context.length(objectId);
+    },
+    entries() {
+      let i = 0;
+      const iterator = {
+        next: () => {
+          const value = valueAt(target, i);
+          if (value === void 0) {
+            return { value: void 0, done: true };
+          } else {
+            return { value: [i++, value], done: false };
+          }
+        },
+        [Symbol.iterator]() {
+          return this;
+        }
+      };
+      return iterator;
+    },
+    keys() {
+      let i = 0;
+      const len = context.length(objectId);
+      const iterator = {
+        next: () => {
+          if (i < len) {
+            return { value: i++, done: false };
+          }
+          return { value: void 0, done: true };
+        },
+        [Symbol.iterator]() {
+          return this;
+        }
+      };
+      return iterator;
+    },
+    values() {
+      let i = 0;
+      const iterator = {
+        next: () => {
+          const value = valueAt(target, i++);
+          if (value === void 0) {
+            return { value: void 0, done: true };
+          } else {
+            return { value, done: false };
+          }
+        },
+        [Symbol.iterator]() {
+          return this;
+        }
+      };
+      return iterator;
+    },
+    toArray() {
+      const list = [];
+      let value;
+      do {
+        value = valueAt(target, list.length);
+        if (value !== void 0) {
+          list.push(value);
+        }
+      } while (value !== void 0);
+      return list;
+    },
+    map(f) {
+      return this.toArray().map(f);
+    },
+    toString() {
+      return this.toArray().toString();
+    },
+    toLocaleString() {
+      return this.toArray().toLocaleString();
+    },
+    forEach(f) {
+      return this.toArray().forEach(f);
+    },
+    // todo: real concat function is different
+    concat(other) {
+      return this.toArray().concat(other);
+    },
+    every(f) {
+      return this.toArray().every(f);
+    },
+    filter(f) {
+      return this.toArray().filter(f);
+    },
+    find(f) {
+      let index = 0;
+      for (const v of this) {
+        if (f(v, index)) {
+          return v;
+        }
+        index += 1;
+      }
+    },
+    findIndex(f) {
+      let index = 0;
+      for (const v of this) {
+        if (f(v, index)) {
+          return index;
+        }
+        index += 1;
+      }
+      return -1;
+    },
+    includes(elem) {
+      return this.find((e) => e === elem) !== void 0;
+    },
+    join(sep) {
+      return this.toArray().join(sep);
+    },
+    reduce(f, initialValue) {
+      return this.toArray().reduce(f, initialValue);
+    },
+    reduceRight(f, initialValue) {
+      return this.toArray().reduceRight(f, initialValue);
+    },
+    lastIndexOf(search, fromIndex = Infinity) {
+      return this.toArray().lastIndexOf(search, fromIndex);
+    },
+    slice(index, num) {
+      return this.toArray().slice(index, num);
+    },
+    some(f) {
+      let index = 0;
+      for (const v of this) {
+        if (f(v, index)) {
+          return true;
+        }
+        index += 1;
+      }
+      return false;
+    },
+    [Symbol.iterator]: function* () {
+      let i = 0;
+      let value = valueAt(target, i);
+      while (value !== void 0) {
+        yield value;
+        i += 1;
+        value = valueAt(target, i);
+      }
+    }
+  };
+  return methods;
+}
+function printPath(path) {
+  const jsonPointerComponents = path.map((component) => {
+    if (typeof component === "number") {
+      return component.toString();
+    } else if (typeof component === "string") {
+      return component.replace(/~/g, "~0").replace(/\//g, "~1");
+    }
+  });
+  if (path.length === 0) {
+    return "";
+  } else {
+    return "/" + jsonPointerComponents.join("/");
+  }
+}
+function isImmutableString(obj) {
+  return typeof obj === "object" && obj !== null && Object.prototype.hasOwnProperty.call(obj, IMMUTABLE_STRING);
+}
+
+// node_modules/.pnpm/@automerge+automerge@3.2.6/node_modules/@automerge/automerge/dist/mjs/internal_state.js
+function _state(doc, checkroot = true) {
+  if (typeof doc !== "object") {
+    throw new RangeError("must be the document root");
+  }
+  const state = Reflect.get(doc, STATE);
+  if (state === void 0 || state == null || checkroot && _obj(doc) !== "_root") {
+    throw new RangeError("must be the document root");
+  }
+  return state;
+}
+function _trace(doc) {
+  return Reflect.get(doc, TRACE);
+}
+function _obj(doc) {
+  if (!(typeof doc === "object") || doc === null) {
+    return null;
+  }
+  return Reflect.get(doc, OBJECT_ID);
+}
+function _is_proxy(doc) {
+  return !!Reflect.get(doc, IS_PROXY);
+}
+
+// node_modules/.pnpm/@automerge+automerge@3.2.6/node_modules/@automerge/automerge/dist/mjs/implementation.js
+function importOpts(_actor) {
+  if (typeof _actor === "object") {
+    return _actor;
+  } else {
+    return { actor: _actor };
+  }
+}
+function getChangesSince(state, heads) {
+  const n = _state(state);
+  return n.handle.getChanges(heads);
+}
+function init(_opts) {
+  const opts = importOpts(_opts);
+  const freeze = !!opts.freeze;
+  const patchCallback = opts.patchCallback;
+  const actor = opts.actor;
+  const handle = ApiHandler.create({ actor });
+  handle.enableFreeze(!!opts.freeze);
+  registerDatatypes(handle);
+  const doc = handle.materialize("/", void 0, {
+    handle,
+    heads: void 0,
+    freeze,
+    patchCallback
+  });
+  return doc;
+}
+function from(initialState, _opts) {
+  const opts = importOpts(_opts);
+  if (typeof initialState !== "object" || Array.isArray(initialState)) {
+    initialState = Object.assign({}, initialState);
+  }
+  validateForBatchInsert(initialState, null, []);
+  const doc = init(_opts);
+  return _change(doc, "from", {}, (d) => {
+    _state(doc).handle.initRootFromHydrate(initialState);
+    return d;
+  }).newDoc;
+}
+function progressDocument(doc, source, heads, callback) {
+  if (heads == null) {
+    return doc;
+  }
+  const state = _state(doc);
+  const nextState = Object.assign(Object.assign({}, state), { heads: void 0 });
+  const { value: nextDoc, patches } = state.handle.applyAndReturnPatches(doc, nextState);
+  if (patches.length > 0) {
+    if (callback != null) {
+      callback(patches, { before: doc, after: nextDoc, source });
+    }
+    const newState = _state(nextDoc);
+    newState.mostRecentPatch = {
+      before: _state(doc).heads,
+      after: newState.handle.getHeads(),
+      patches
+    };
+  }
+  state.heads = heads;
+  return nextDoc;
+}
+function _change(doc, source, options, callback, scope) {
+  if (typeof callback !== "function") {
+    throw new RangeError("invalid change function");
+  }
+  const state = _state(doc);
+  if (doc === void 0 || state === void 0) {
+    throw new RangeError("must be the document root");
+  }
+  if (state.heads) {
+    throw new RangeError("Attempting to change an outdated document.  Use Automerge.clone() if you wish to make a writable copy.");
+  }
+  if (_is_proxy(doc)) {
+    throw new RangeError("Calls to Automerge.change cannot be nested");
+  }
+  let heads = state.handle.getHeads();
+  if (scope && headsEqual(scope, heads)) {
+    scope = void 0;
+  }
+  if (scope) {
+    state.handle.isolate(scope);
+    heads = scope;
+  }
+  if (!("time" in options)) {
+    options.time = Math.floor(Date.now() / 1e3);
+  }
+  try {
+    state.heads = heads;
+    const root = rootProxy(state.handle);
+    callback(root);
+    if (state.handle.pendingOps() === 0) {
+      state.heads = void 0;
+      if (scope) {
+        state.handle.integrate();
+      }
+      return {
+        newDoc: doc,
+        newHeads: null
+      };
+    } else {
+      const newHead = state.handle.commit(options.message, options.time);
+      state.handle.integrate();
+      return {
+        newDoc: progressDocument(doc, source, heads, options.patchCallback || state.patchCallback),
+        newHeads: newHead != null ? [newHead] : null
+      };
+    }
+  } catch (e) {
+    state.heads = void 0;
+    state.handle.rollback();
+    throw e;
+  }
+}
+function load(data, _opts) {
+  const opts = importOpts(_opts);
+  if (opts.patchCallback) {
+    return loadIncremental(init(opts), data);
+  }
+  const actor = opts.actor;
+  const patchCallback = opts.patchCallback;
+  const unchecked = opts.unchecked || false;
+  const allowMissingDeps = opts.allowMissingChanges || false;
+  const convertImmutableStringsToText = opts.convertImmutableStringsToText || false;
+  const handle = ApiHandler.load(data, {
+    actor,
+    unchecked,
+    allowMissingDeps,
+    convertImmutableStringsToText
+  });
+  handle.enableFreeze(!!opts.freeze);
+  registerDatatypes(handle);
+  const doc = handle.materialize("/", void 0, {
+    handle,
+    heads: void 0,
+    patchCallback
+  });
+  return doc;
+}
+function loadIncremental(doc, data, opts) {
+  if (!opts) {
+    opts = {};
+  }
+  const state = _state(doc);
+  if (state.heads) {
+    throw new RangeError("Attempting to change an out of date document - set at: " + _trace(doc));
+  }
+  if (_is_proxy(doc)) {
+    throw new RangeError("Calls to Automerge.change cannot be nested");
+  }
+  const heads = state.handle.getHeads();
+  state.handle.loadIncremental(data);
+  return progressDocument(doc, "loadIncremental", heads, opts.patchCallback || state.patchCallback);
+}
+function save(doc) {
+  return _state(doc).handle.save();
+}
+function applyChanges(doc, changes, opts) {
+  const state = _state(doc);
+  if (!opts) {
+    opts = {};
+  }
+  if (state.heads) {
+    throw new RangeError("Attempting to change an outdated document.  Use Automerge.clone() if you wish to make a writable copy.");
+  }
+  if (_is_proxy(doc)) {
+    throw new RangeError("Calls to Automerge.change cannot be nested");
+  }
+  const heads = state.handle.getHeads();
+  state.handle.applyChanges(changes);
+  state.heads = heads;
+  return [
+    progressDocument(doc, "applyChanges", heads, opts.patchCallback || state.patchCallback)
+  ];
+}
+function headsEqual(heads1, heads2) {
+  if (heads1.length !== heads2.length) {
+    return false;
+  }
+  for (let i = 0; i < heads1.length; i++) {
+    if (heads1[i] !== heads2[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+function getHeads(doc) {
+  const state = _state(doc);
+  return state.heads || state.handle.getHeads();
+}
+function registerDatatypes(handle) {
+  handle.registerDatatype("counter", (n) => new Counter(n), (n) => {
+    if (n instanceof Counter) {
+      return n.value;
+    }
+  });
+  handle.registerDatatype("str", (n) => {
+    return new ImmutableString(n);
+  }, (s) => {
+    if (isImmutableString(s)) {
+      return s.val;
+    }
+  });
+}
+
+// node_modules/.pnpm/@automerge+automerge@3.2.6/node_modules/@automerge/automerge/dist/mjs/entrypoints/fullfat_node.js
+UseApi(api);
+
 // src/testing/index.ts
 var PROTOCOL = "mindoodb-app-bridge";
 function createBridgeErrorPayload(error, fallbackCode = "bridge-error") {
@@ -26,6 +3813,13 @@ function applyDocumentUpdatePatch(current, patch) {
   for (const textPatch of patch.text ?? []) {
     applyMockTextPatch(next, textPatch.path, textPatch.edits);
   }
+  for (const richTextPatch of patch.richText ?? []) {
+    const spans = richTextPatch.spansSequence?.at(-1) ?? richTextPatch.spans ?? [];
+    setValueAtPath(next, richTextPatch.path, structuredClone(spans));
+  }
+  for (const richTextStepPatch of patch.richTextSteps ?? []) {
+    applyMockRichTextSteps(next, richTextStepPatch.path, richTextStepPatch.steps);
+  }
   return next;
 }
 function applyMockJsonPatch(target, patch) {
@@ -46,6 +3840,19 @@ function applyMockJsonPatch(target, patch) {
     const list = readListAtPath(target, operation.path);
     list.splice(operation.index, 0, ...structuredClone(operation.values));
   }
+  for (const operation of patch.textSplice ?? []) {
+    applyMockTextPatch(target, operation.path, [{
+      index: operation.index,
+      deleteCount: operation.deleteCount,
+      ...operation.insert !== void 0 ? { insert: operation.insert } : {}
+    }]);
+  }
+  for (const operation of patch.textMark ?? []) {
+    applyMockTextMarks(target, operation.path, operation.index, operation.length, operation.marks, false);
+  }
+  for (const operation of patch.textUnmark ?? []) {
+    applyMockTextMarks(target, operation.path, operation.index, operation.length, Object.fromEntries(operation.names.map((name) => [name, null])), true);
+  }
 }
 function setValueAtPath(target, path, value) {
   if (path.length === 0) {
@@ -125,6 +3932,61 @@ function applyMockTextPatch(target, path, edits) {
   }
   parent[leaf] = value;
 }
+function applyMockTextMarks(target, path, index, length, marks, remove) {
+  const parent = ensureParentAtPath(target, path);
+  const leaf = path[path.length - 1];
+  const marksKey = `${String(leaf)}__marks`;
+  const existing = Array.isArray(parent[marksKey]) ? parent[marksKey] : [];
+  parent[marksKey] = [
+    ...existing,
+    {
+      index,
+      length,
+      marks: structuredClone(marks),
+      remove
+    }
+  ];
+}
+function readRichTextSpansAtPath(target, path) {
+  let value = target;
+  for (const segment of path) {
+    if (value == null || typeof value !== "object") {
+      return [];
+    }
+    value = value[segment];
+  }
+  if (typeof value === "string") {
+    return value.length > 0 ? [{ type: "text", value }] : [];
+  }
+  return Array.isArray(value) ? value : [];
+}
+function applyMockRichTextSteps(target, path, steps) {
+  if (path.length === 0) {
+    throw new Error("Rich-text steps path must contain at least one segment");
+  }
+  const parent = ensureParentAtPath(target, path);
+  const leaf = path[path.length - 1];
+  let text = materializeMockRichTextValue(parent[leaf]);
+  for (const step of steps) {
+    text = text.slice(0, step.index) + (step.insert ?? "") + text.slice(step.index + step.deleteCount);
+  }
+  parent[leaf] = text;
+}
+function materializeMockRichTextValue(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (!Array.isArray(value)) {
+    return "";
+  }
+  return value.map((span) => {
+    if (!span || typeof span !== "object") {
+      return "";
+    }
+    const record = span;
+    return record.type === "text" && typeof record.value === "string" ? record.value : "";
+  }).join("");
+}
 function mergeLaunchContext(current, patch) {
   if (!patch) {
     return {
@@ -278,6 +4140,22 @@ function createDefaultWritableAttachmentStream() {
     }
   };
 }
+function loadMockAutomergeDocument(document) {
+  if (document.automergeBinary) {
+    return load(document.automergeBinary);
+  }
+  const initialDoc = from({
+    ...structuredClone(document.data),
+    body: typeof document.data.body === "string" ? document.data.body : ""
+  });
+  document.automergeBinary = save(initialDoc);
+  return initialDoc;
+}
+function persistMockAutomergeDocument(document, automergeDoc) {
+  document.automergeBinary = save(automergeDoc);
+  document.data = structuredClone(automergeDoc);
+  document.heads = getHeads(automergeDoc);
+}
 function getFieldValue(source, field) {
   return field.split(".").reduce((current, part) => {
     if (current && typeof current === "object" && part in current) {
@@ -567,6 +4445,64 @@ function createDatabaseHandle(definition) {
         updatedAt: document.updatedAt
       };
     },
+    async getRichText(docId, path, _options) {
+      const document = storedDocuments.get(docId);
+      if (!document || document.isDeleted) {
+        throw new Error(`Document ${docId} was not found.`);
+      }
+      return {
+        path: [...path],
+        heads: document.heads ? [...document.heads] : void 0,
+        spans: structuredClone(readRichTextSpansAtPath(document.data, path))
+      };
+    },
+    async getAutomergeSnapshot(docId, _options) {
+      const document = storedDocuments.get(docId);
+      if (!document || document.isDeleted) {
+        throw new Error(`Document ${docId} was not found.`);
+      }
+      const automergeDoc = loadMockAutomergeDocument(document);
+      return {
+        binary: save(automergeDoc),
+        heads: getHeads(automergeDoc)
+      };
+    },
+    async applyAutomergeChanges(docId, patch) {
+      const document = storedDocuments.get(docId);
+      if (!document || document.isDeleted) {
+        throw new Error(`Document ${docId} was not found.`);
+      }
+      const currentDoc = loadMockAutomergeDocument(document);
+      const [mergedDoc] = applyChanges(
+        currentDoc,
+        patch.changes.map((change) => new Uint8Array(change))
+      );
+      persistMockAutomergeDocument(document, mergedDoc);
+      document.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const mergedHeads = document.heads ? [...document.heads] : [];
+      let changesSince;
+      if (patch.replicaHeads?.length) {
+        const missingChanges = getChangesSince(
+          mergedDoc,
+          patch.replicaHeads
+        );
+        changesSince = {
+          sinceHeads: [...patch.replicaHeads],
+          changes: missingChanges.map((change) => cloneBytes(new Uint8Array(change)))
+        };
+      }
+      return {
+        document: {
+          id: document.id,
+          data: structuredClone(document.data),
+          heads: mergedHeads,
+          attachments: document.attachments ? structuredClone(document.attachments) : [],
+          updatedAt: document.updatedAt
+        },
+        heads: mergedHeads,
+        changesSince
+      };
+    },
     async create(input) {
       const callerId = typeof input.id === "string" && input.id.length > 0 ? input.id : null;
       if (callerId) {
@@ -625,7 +4561,8 @@ function createDatabaseHandle(definition) {
         ...updated,
         data: structuredClone(updated.data),
         attachments: updated.attachments ? structuredClone(updated.attachments) : [],
-        isDeleted: false
+        isDeleted: false,
+        automergeBinary: void 0
       });
       return updated;
     },
@@ -820,13 +4757,13 @@ function createMockSessionState(options = {}) {
           "At least one test database is required for view creation."
         );
       }
-      const api = databaseViewApis.get(firstDatabaseId);
-      if (!api) {
+      const api2 = databaseViewApis.get(firstDatabaseId);
+      if (!api2) {
         throw new Error(
           `Unknown test database for view creation: ${firstDatabaseId}`
         );
       }
-      const view = await api.create(input);
+      const view = await api2.create(input);
       const viewId = input.definition.id || crypto.randomUUID();
       sessionViews.set(viewId, view);
       return view;
@@ -842,13 +4779,13 @@ function createMockSessionState(options = {}) {
       if (!sourceDatabaseId) {
         throw new Error(`Unknown test view: ${viewId}`);
       }
-      const api = databaseViewApis.get(sourceDatabaseId);
-      if (!api) {
+      const api2 = databaseViewApis.get(sourceDatabaseId);
+      if (!api2) {
         throw new Error(
           `Unknown test database for view ${viewId}: ${sourceDatabaseId}`
         );
       }
-      const view = await api.open(viewId, options2);
+      const view = await api2.open(viewId, options2);
       sessionViews.set(viewId, view);
       return view;
     },
@@ -1140,6 +5077,21 @@ function createFakeBridgeHost(options = {}) {
         return await state.getDatabase(String(params.databaseId)).documents.getHeadCursor();
       case "documents.get":
         return await state.getDatabase(String(params.databaseId)).documents.get(String(params.docId));
+      case "documents.richText.get":
+        return await state.getDatabase(String(params.databaseId)).documents.getRichText(
+          String(params.docId),
+          params.path
+        );
+      case "documents.automerge.getSnapshot":
+        return await state.getDatabase(String(params.databaseId)).documents.getAutomergeSnapshot(
+          String(params.docId),
+          { revisionId: params.revisionId }
+        );
+      case "documents.automerge.applyChanges":
+        return await state.getDatabase(String(params.databaseId)).documents.applyAutomergeChanges(
+          String(params.docId),
+          params.patch
+        );
       case "documents.create":
         return await state.getDatabase(String(params.databaseId)).documents.create(
           params.input