@liveblocks/core 3.19.2 → 3.19.4-rc1

package/dist/index.js

@@ -6,7 +6,7 @@ var __export = (target, all) => {
 
 // src/version.ts
 var PKG_NAME = "@liveblocks/core";
-var PKG_VERSION = "3.19.2";
+var PKG_VERSION = "3.19.4-rc1";
 var PKG_FORMAT = "esm";
 
 // src/dupe-detection.ts
@@ -701,6 +701,20 @@ var SortedList = class _SortedList {
   get length() {
     return this.#data.length;
   }
+  /**
+   * Whether the given value is present, by identity. O(log n) plus the length
+   * of any run of items that share its sort key (normally 1). Bisects on the
+   * value's own key, so it only finds values sitting at their sorted position,
+   * which is true for any item currently in the list.
+   */
+  includes(value) {
+    for (let i = bisectRight(this.#data, value, this.#lt) - 1; i >= 0 && !this.#lt(this.#data[i], value); i--) {
+      if (this.#data[i] === value) {
+        return true;
+      }
+    }
+    return false;
+  }
   *filter(predicate) {
     for (const item of this.#data) {
       if (predicate(item)) {
@@ -2715,6 +2729,7 @@ var HttpClient = class {
 };
 
 // src/lib/fsm.ts
+var IGNORE = /* @__PURE__ */ Symbol("fsm.ignore");
 function distance(state1, state2) {
   if (state1 === state2) {
     return [0, 0];
@@ -2887,7 +2902,7 @@ var FSM = class {
     this.#eventHub = {
       didReceiveEvent: makeEventSource(),
       willTransition: makeEventSource(),
-      didIgnoreEvent: makeEventSource(),
+      didIgnoreUnexpectedEvent: makeEventSource(),
       willExitState: makeEventSource(),
       didEnterState: makeEventSource(),
       didExitState: makeEventSource()
@@ -2895,7 +2910,7 @@ var FSM = class {
     this.events = {
       didReceiveEvent: this.#eventHub.didReceiveEvent.observable,
       willTransition: this.#eventHub.willTransition.observable,
-      didIgnoreEvent: this.#eventHub.didIgnoreEvent.observable,
+      didIgnoreUnexpectedEvent: this.#eventHub.didIgnoreUnexpectedEvent.observable,
       willExitState: this.#eventHub.willExitState.observable,
       didEnterState: this.#eventHub.didEnterState.observable,
       didExitState: this.#eventHub.didExitState.observable
@@ -3018,9 +3033,14 @@ var FSM = class {
    * `context` params to conditionally decide which next state to transition
    * to.
    *
-   * If you set it to `null`, then the transition will be explicitly forbidden
-   * and throw an error. If you don't define a target for a transition, then
-   * such events will get ignored.
+   * If you don't define a target for a transition, the event is treated
+   * as unhandled in this state: `didIgnoreUnexpectedEvent` fires and the
+   * state does not change.
+   *
+   * To declare an event as an intentional silent no-op in this state, use
+   * the {@link IGNORE} sentinel — either statically (`{ EVENT: IGNORE }`)
+   * or as a return value from a target function. IGNORE'd events do not
+   * fire `didIgnoreUnexpectedEvent`.
    */
   addTransitions(nameOrPattern, mapping) {
     if (this.#runningState !== 0 /* NOT_STARTED_YET */) {
@@ -3040,7 +3060,12 @@ var FSM = class {
         }
         const target = target_;
         this.#knownEventTypes.add(type);
-        if (target !== void 0) {
+        if (target === void 0) {
+          continue;
+        }
+        if (target === IGNORE) {
+          map.set(type, IGNORE);
+        } else {
           const targetFn = typeof target === "function" ? target : () => target;
           map.set(type, targetFn);
         }
@@ -3139,12 +3164,14 @@ var FSM = class {
     if (this.#runningState === 2 /* STOPPED */) {
       return;
     }
-    const targetFn = this.#getTargetFn(event.type);
-    if (targetFn !== void 0) {
-      return this.#transition(event, targetFn);
-    } else {
-      this.#eventHub.didIgnoreEvent.notify(event);
+    const entry = this.#getTargetFn(event.type);
+    if (entry === IGNORE) {
+      return;
     }
+    if (entry !== void 0) {
+      return this.#transition(event, entry);
+    }
+    this.#eventHub.didIgnoreUnexpectedEvent.notify(event);
   }
   #transition(event, target) {
     this.#eventHub.didReceiveEvent.notify(event);
@@ -3153,8 +3180,7 @@ var FSM = class {
     const nextTarget = targetFn(event, this.#currentContext.current);
     let nextState;
     let effects = void 0;
-    if (nextTarget === null) {
-      this.#eventHub.didIgnoreEvent.notify(event);
+    if (nextTarget === IGNORE) {
       return;
     }
     if (typeof nextTarget === "string") {
@@ -3373,8 +3399,8 @@ function enableTracing(machine) {
     machine.events.didExitState.subscribe(
       ({ state, durationMs }) => log2(`Exited ${state} after ${durationMs.toFixed(0)}ms`)
     ),
-    machine.events.didIgnoreEvent.subscribe(
-      (e) => log2("Ignored event", e.type, e, "(current state won't handle it)")
+    machine.events.didIgnoreUnexpectedEvent.subscribe(
+      (e) => log2("Ignored unexpected event", e.type, e, "(no transition declared)")
     )
   ];
   return () => {
@@ -3486,7 +3512,12 @@ function createConnectionStateMachine(delegates, options) {
   );
   const onSocketError = (event) => machine.send({ type: "EXPLICIT_SOCKET_ERROR", event });
   const onSocketClose = (event) => machine.send({ type: "EXPLICIT_SOCKET_CLOSE", event });
-  const onSocketMessage = (event) => event.data === "pong" ? machine.send({ type: "PONG" }) : onMessage.notify(event);
+  const onSocketMessage = (event) => {
+    machine.send({ type: "ALIVE" });
+    if (event.data !== "pong") {
+      onMessage.notify(event);
+    }
+  };
   function teardownSocket(socket) {
     if (socket) {
       socket.removeEventListener("error", onSocketError);
@@ -3656,7 +3687,13 @@ function createConnectionStateMachine(delegates, options) {
         effect: [increaseBackoffDelay, logPrematureErrorOrCloseEvent(err)]
       };
     }
-  );
+  ).addTransitions("@connecting.busy", {
+    // The socket message listener is attached during @connecting.busy (see
+    // onEnterAsync above), so server frames (most notably the actor-id
+    // handshake) can fire onSocketMessage and emit a ALIVE before we
+    // reach @ok.*. That's fine. Heartbeat only matters in @ok.*.
+    ALIVE: IGNORE
+  });
   const sendHeartbeat = {
     target: "@ok.awaiting-pong",
     effect: (ctx) => {
@@ -3671,7 +3708,8 @@ function createConnectionStateMachine(delegates, options) {
   machine.addTimedTransition("@ok.connected", HEARTBEAT_INTERVAL, maybeHeartbeat).addTransitions("@ok.connected", {
     NAVIGATOR_OFFLINE: maybeHeartbeat,
     // Don't take the browser's word for it when it says it's offline. Do a ping/pong to make sure.
-    WINDOW_GOT_FOCUS: sendHeartbeat
+    WINDOW_GOT_FOCUS: sendHeartbeat,
+    ALIVE: IGNORE
   });
   machine.addTransitions("@idle.zombie", {
     WINDOW_GOT_FOCUS: "@connecting.backoff"
@@ -3692,7 +3730,7 @@ function createConnectionStateMachine(delegates, options) {
       clearTimeout(timerID);
       onMessage.pause();
     };
-  }).addTransitions("@ok.awaiting-pong", { PONG: "@ok.connected" }).addTimedTransition("@ok.awaiting-pong", PONG_TIMEOUT, {
+  }).addTransitions("@ok.awaiting-pong", { ALIVE: "@ok.connected" }).addTimedTransition("@ok.awaiting-pong", PONG_TIMEOUT, {
     target: "@connecting.busy",
     // Log implicit connection loss and drop the current open socket
     effect: log(
@@ -3705,7 +3743,7 @@ function createConnectionStateMachine(delegates, options) {
     // not. When still OPEN, don't transition.
     EXPLICIT_SOCKET_ERROR: (_, context) => {
       if (context.socket?.readyState === 1) {
-        return null;
+        return IGNORE;
       }
       return {
         target: "@connecting.backoff",
@@ -5478,6 +5516,9 @@ var OpCode = Object.freeze({
 function isIgnoredOp(op) {
   return op.type === OpCode.DELETE_CRDT && op.id === "ACK";
 }
+function isCreateOp(op) {
+  return op.type === OpCode.CREATE_OBJECT || op.type === OpCode.CREATE_REGISTER || op.type === OpCode.CREATE_MAP || op.type === OpCode.CREATE_LIST;
+}
 
 // src/protocol/StorageNode.ts
 var CrdtType = Object.freeze({
@@ -5735,12 +5776,95 @@ function asPos(str) {
   return isPos(str) ? str : convertToPos(str);
 }
 
+// src/crdts/UnacknowledgedOps.ts
+var UnacknowledgedOps = class {
+  // opId -> op
+  #byOpId = /* @__PURE__ */ new Map();
+  // position -> (opId -> Create op)
+  #createOpsByPosition = /* @__PURE__ */ new Map();
+  // parentId -> (opId -> Create op)
+  #createOpsByParent = /* @__PURE__ */ new Map();
+  #posKey(parentId, parentKey) {
+    return `${parentId}
+${parentKey}`;
+  }
+  get size() {
+    return this.#byOpId.size;
+  }
+  /**
+   * Mark the given Op as still unacknowledged.
+   */
+  add(op) {
+    this.#byOpId.set(op.opId, op);
+    if (isCreateOp(op)) {
+      const posKey = this.#posKey(op.parentId, op.parentKey);
+      let atPosition = this.#createOpsByPosition.get(posKey);
+      if (atPosition === void 0) {
+        atPosition = /* @__PURE__ */ new Map();
+        this.#createOpsByPosition.set(posKey, atPosition);
+      }
+      atPosition.set(op.opId, op);
+      let inParent = this.#createOpsByParent.get(op.parentId);
+      if (inParent === void 0) {
+        inParent = /* @__PURE__ */ new Map();
+        this.#createOpsByParent.set(op.parentId, inParent);
+      }
+      inParent.set(op.opId, op);
+    }
+  }
+  /**
+   * Drop the op with the given opId from the set, because the server has
+   * acknowledged it (confirmed our own op, or signalled it was seen but
+   * ignored).
+   */
+  delete(opId) {
+    const op = this.#byOpId.get(opId);
+    if (op === void 0) {
+      return;
+    }
+    this.#byOpId.delete(opId);
+    if (isCreateOp(op)) {
+      const posKey = this.#posKey(op.parentId, op.parentKey);
+      const atPosition = this.#createOpsByPosition.get(posKey);
+      atPosition?.delete(opId);
+      if (atPosition !== void 0 && atPosition.size === 0) {
+        this.#createOpsByPosition.delete(posKey);
+      }
+      const inParent = this.#createOpsByParent.get(op.parentId);
+      inParent?.delete(opId);
+      if (inParent !== void 0 && inParent.size === 0) {
+        this.#createOpsByParent.delete(op.parentId);
+      }
+    }
+  }
+  /**
+   * The still-unacknowledged Create ops with the given `parentId` and
+   * `parentKey` (targeting one exact position), in dispatch order. O(1) lookup.
+   * Empty if none.
+   */
+  getByParentIdAndKey(parentId, parentKey) {
+    return this.#createOpsByPosition.get(this.#posKey(parentId, parentKey))?.values() ?? [];
+  }
+  /**
+   * The still-unacknowledged Create ops with the given `parentId` (across all
+   * positions), in dispatch order. O(1) lookup. Empty if none.
+   */
+  getByParentId(parentId) {
+    return this.#createOpsByParent.get(parentId)?.values() ?? [];
+  }
+  /** All still-unacknowledged ops, in dispatch order. */
+  values() {
+    return this.#byOpId.values();
+  }
+};
+
 // src/crdts/AbstractCrdt.ts
 function createManagedPool(roomId, options) {
   const {
     getCurrentConnectionId,
     onDispatch,
-    isStorageWritable = () => true
+    isStorageWritable = () => true,
+    unacknowledgedOps = new UnacknowledgedOps()
   } = options;
   let clock = 0;
   let opClock = 0;
@@ -5762,7 +5886,8 @@ function createManagedPool(roomId, options) {
           "Cannot write to storage with a read only user, please ensure the user has write permissions"
         );
       }
-    }
+    },
+    unacknowledgedOps
   };
 }
 function crdtAsLiveNode(value) {
@@ -6044,11 +6169,9 @@ function childNodeLt(a, b) {
 var LiveList = class _LiveList extends AbstractCrdt {
   #items;
   #implicitlyDeletedItems;
-  #unacknowledgedSets;
   constructor(items) {
     super();
     this.#implicitlyDeletedItems = /* @__PURE__ */ new WeakSet();
-    this.#unacknowledgedSets = /* @__PURE__ */ new Map();
     const nodes = [];
     let lastPos;
     for (const item of items) {
@@ -6078,12 +6201,13 @@ var LiveList = class _LiveList extends AbstractCrdt {
   }
   /**
    * @internal
-   * This function assumes that the resulting ops will be sent to the server if they have an 'opId'
-   * so we mutate _unacknowledgedSets to avoid potential flickering
-   * https://github.com/liveblocks/liveblocks/pull/1177
+   * Serializes this list (and its children) into Create ops. Each child's
+   * create is tagged with the "set" intent (in the loop below) so that a list
+   * created and immediately mutated doesn't transiently re-show its initial
+   * items (flicker, https://github.com/liveblocks/liveblocks/pull/1177).
    *
-   * This is quite unintuitive and should disappear as soon as
-   * we introduce an explicit LiveList.Set operation
+   * This is quite unintuitive and should disappear as soon as we introduce an
+   * explicit LiveList.Set operation.
    */
   _toOps(parentId, parentKey) {
     if (this._id === void 0) {
@@ -6099,9 +6223,9 @@ var LiveList = class _LiveList extends AbstractCrdt {
     ops.push(op);
     for (const item of this.#items) {
       const parentKey2 = item._getParentKeyOrThrow();
-      const childOps = HACK_addIntentAndDeletedIdToOperation(
+      const childOps = addIntentToRootOp(
         item._toOps(this._id, parentKey2),
-        void 0
+        "set"
       );
       for (const childOp of childOps) {
         ops.push(childOp);
@@ -6143,6 +6267,28 @@ var LiveList = class _LiveList extends AbstractCrdt {
       (item) => item._getParentKeyOrThrow() === position
     );
   }
+  /**
+   * The opId of this list's still-unacknowledged "set" op at the given position,
+   * or undefined if none. Derived from the room's unacknowledgedOps (the single
+   * source of truth) rather than tracked in a per-instance map. The pool's
+   * position index already scopes to this list's (parentId, position); the last
+   * match wins, matching the original last-write-wins map semantics.
+   */
+  #unacknowledgedSetOpIdAt(position) {
+    if (this._pool === void 0 || this._id === void 0) {
+      return void 0;
+    }
+    let opId;
+    for (const op of this._pool.unacknowledgedOps.getByParentIdAndKey(
+      this._id,
+      position
+    )) {
+      if (op.intent === "set") {
+        opId = op.opId;
+      }
+    }
+    return opId;
+  }
   /** @internal */
   _attach(id, pool) {
     super._attach(id, pool);
@@ -6223,13 +6369,9 @@ var LiveList = class _LiveList extends AbstractCrdt {
     if (deletedDelta) {
       delta.push(deletedDelta);
     }
-    const unacknowledgedOpId = this.#unacknowledgedSets.get(op.parentKey);
-    if (unacknowledgedOpId !== void 0) {
-      if (unacknowledgedOpId !== op.opId) {
-        return delta.length === 0 ? { modified: false } : { modified: makeUpdate(this, delta), reverse: [] };
-      } else {
-        this.#unacknowledgedSets.delete(op.parentKey);
-      }
+    const unacknowledgedOpId = this.#unacknowledgedSetOpIdAt(op.parentKey);
+    if (unacknowledgedOpId !== void 0 && unacknowledgedOpId !== op.opId) {
+      return delta.length === 0 ? { modified: false } : { modified: makeUpdate(this, delta), reverse: [] };
     }
     const indexOfItemWithSamePosition = this._indexOfPosition(op.parentKey);
     const existingItem = this.#items.find((item) => item._id === op.id);
@@ -6310,7 +6452,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
     }
     return result.modified.updates[0];
   }
-  #applyRemoteInsert(op) {
+  #applyRemoteInsert(op, fromSnapshot) {
     if (this._pool === void 0) {
       throw new Error("Can't attach child if managed pool is not present");
     }
@@ -6320,11 +6462,82 @@ var LiveList = class _LiveList extends AbstractCrdt {
       this.#shiftItemPosition(existingItemIndex, key);
     }
     const { newItem, newIndex } = this.#createAttachItemAndSort(op, key);
+    const bumpDeltas = fromSnapshot ? [] : this.#bumpUnackedPushesAbove(key);
     return {
-      modified: makeUpdate(this, [insertDelta(newIndex, newItem)]),
+      modified: makeUpdate(this, [
+        insertDelta(newIndex, newItem),
+        ...bumpDeltas
+      ]),
       reverse: []
     };
   }
+  /**
+   * This list's own still-unacknowledged pushed items (their `intent: "push"`
+   * Create op is still pending in the room's unacknowledgedOps). Derived from
+   * the single source of truth, so an item drops out the instant its op is
+   * acked, with no per-instance membership to leak. Yielded in push order.
+   *
+   * Restricted to items currently in `#items`: a pushed node whose op is still
+   * pending may have been pulled out of the list (e.g. implicitly deleted by a
+   * remote set, or removed by an undo) while still living in the pool, and such
+   * a node must not be repositioned.
+   */
+  *#unackedPushNodes() {
+    if (this._pool === void 0 || this._id === void 0) {
+      return;
+    }
+    for (const op of this._pool.unacknowledgedOps.getByParentId(this._id)) {
+      if (op.intent !== "push") {
+        continue;
+      }
+      const node = this._pool.getNode(op.id);
+      if (node !== void 0 && this.#items.includes(node)) {
+        yield node;
+      }
+    }
+  }
+  /**
+   * Optimistic no-flip for pushed items. When a remote op lands at or below my
+   * still-unacked pushed items, those items must end up *after* it: FIFO plus
+   * the room's serial processing guarantee the remote was processed first, so
+   * my unacked pushes belong behind it. Re-chain the whole unacked-push block,
+   * in push order, to sit after the highest confirmed sibling, so it keeps
+   * rendering as a contiguous tail instead of getting interleaved. Local-only;
+   * the real acks overwrite these keys with the (identical) server keys.
+   */
+  #bumpUnackedPushesAbove(remoteKey) {
+    const pending = new Set(this.#unackedPushNodes());
+    if (pending.size === 0) {
+      return [];
+    }
+    let minPending;
+    for (const node of pending) {
+      const pos = node._parentPos;
+      if (minPending === void 0 || pos < minPending) {
+        minPending = pos;
+      }
+    }
+    if (remoteKey < nn(minPending)) {
+      return [];
+    }
+    let base;
+    for (const item of this.#items) {
+      if (!pending.has(item)) {
+        base = item._parentPos;
+      }
+    }
+    const deltas = [];
+    for (const node of pending) {
+      const previousIndex = this.#items.findIndex((item) => item === node);
+      base = makePosition(base);
+      this.#updateItemPosition(node, base);
+      const index = this.#items.findIndex((item) => item === node);
+      if (index !== previousIndex) {
+        deltas.push(moveDelta(previousIndex, index, node));
+      }
+    }
+    return deltas;
+  }
   #applyInsertAck(op) {
     const existingItem = this.#items.find((item) => item._id === op.id);
     const key = asPos(op.parentKey);
@@ -6405,7 +6618,6 @@ var LiveList = class _LiveList extends AbstractCrdt {
     if (this._pool?.getNode(id) !== void 0) {
       return { modified: false };
     }
-    this.#unacknowledgedSets.set(key, nn(op.opId));
     const indexOfItemWithSameKey = this._indexOfPosition(key);
     child._attach(id, nn(this._pool));
     child._setParentLink(this, key);
@@ -6415,8 +6627,9 @@ var LiveList = class _LiveList extends AbstractCrdt {
       existingItem._detach();
       this.#items.remove(existingItem);
       this.#items.add(child);
-      const reverse = HACK_addIntentAndDeletedIdToOperation(
+      const reverse = addIntentToRootOp(
         existingItem._toOps(nn(this._id), key),
+        "set",
         op.id
       );
       const delta = [setDelta(indexOfItemWithSameKey, child)];
@@ -6441,7 +6654,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
     }
   }
   /** @internal */
-  _attachChild(op, source) {
+  _attachChild(op, source, fromSnapshot = false) {
     if (this._pool === void 0) {
       throw new Error("Can't attach child if managed pool is not present");
     }
@@ -6456,7 +6669,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
       }
     } else {
       if (source === 1 /* THEIRS */) {
-        result = this.#applyRemoteInsert(op);
+        result = this.#applyRemoteInsert(op, fromSnapshot);
       } else if (source === 2 /* OURS */) {
         result = this.#applyInsertAck(op);
       } else {
@@ -6659,8 +6872,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
    * @param element The element to add to the end of the LiveList.
    */
   push(element) {
-    this._pool?.assertStorageIsWritable();
-    return this.insert(element, this.length);
+    return this.#injectAt(element, this.length, "push");
   }
   /**
    * Inserts one element at a specified index.
@@ -6668,6 +6880,15 @@ var LiveList = class _LiveList extends AbstractCrdt {
    * @param index The index at which you want to insert the element.
    */
   insert(element, index) {
+    return this.#injectAt(element, index, "insert");
+  }
+  /**
+   * Shared implementation of `insert` and `push`. A `"push"` intent leaves the
+   * client-computed position untouched (so optimistic rendering is unchanged),
+   * but tags the Op so the server appends it to the true end of the list
+   * instead of resolving its position against the client's stale view.
+   */
+  #injectAt(element, index, intent) {
     this._pool?.assertStorageIsWritable();
     if (index < 0 || index > this.#items.length) {
       throw new Error(
@@ -6683,8 +6904,9 @@ var LiveList = class _LiveList extends AbstractCrdt {
     if (this._pool && this._id) {
       const id = this._pool.generateId();
       value._attach(id, this._pool);
+      const ops = value._toOpsWithOpId(this._id, position, this._pool);
       this._pool.dispatch(
-        value._toOpsWithOpId(this._id, position, this._pool),
+        intent === "push" ? addIntentToRootOp(ops, "push") : ops,
         [{ type: OpCode.DELETE_CRDT, id }],
         /* @__PURE__ */ new Map([
           [this._id, makeUpdate(this, [insertDelta(index, value)])]
@@ -6842,13 +7064,14 @@ var LiveList = class _LiveList extends AbstractCrdt {
       value._attach(id, this._pool);
       const storageUpdates = /* @__PURE__ */ new Map();
       storageUpdates.set(this._id, makeUpdate(this, [setDelta(index, value)]));
-      const ops = HACK_addIntentAndDeletedIdToOperation(
+      const ops = addIntentToRootOp(
         value._toOpsWithOpId(this._id, position, this._pool),
+        "set",
         existingId
       );
-      this.#unacknowledgedSets.set(position, nn(ops[0].opId));
-      const reverseOps = HACK_addIntentAndDeletedIdToOperation(
+      const reverseOps = addIntentToRootOp(
         existingItem._toOps(this._id, position),
+        "set",
         id
       );
       this._pool.dispatch(ops, reverseOps, storageUpdates);
@@ -7049,15 +7272,11 @@ function moveDelta(previousIndex, index, item) {
     previousIndex
   };
 }
-function HACK_addIntentAndDeletedIdToOperation(ops, deletedId) {
+function addIntentToRootOp(ops, intent, deletedId) {
   return ops.map((op, index) => {
     if (index === 0) {
       const firstOp = op;
-      return {
-        ...firstOp,
-        intent: "set",
-        deletedId
-      };
+      return { ...firstOp, intent, deletedId };
     } else {
       return op;
     }
@@ -8297,6 +8516,31 @@ function lsonToLiveNode(value) {
     return new LiveRegister(value);
   }
 }
+function dumpPool(pool) {
+  const rows = Array.from(pool.nodes.values(), (node) => {
+    const parent = node.parent;
+    const parentId = parent.type === "HasParent" ? parent.node._id ?? "?" : parent.type === "Orphaned" ? "<orphaned>" : "-";
+    let value;
+    if (node instanceof LiveRegister) {
+      value = stringifyOrLog(node.data);
+    } else if (node instanceof LiveList) {
+      value = "<LiveList>";
+    } else if (node instanceof LiveMap) {
+      value = "<LiveMap>";
+    } else {
+      value = "<LiveObject>";
+    }
+    return { id: nn(node._id), parentId, key: node._parentKey ?? "", value };
+  });
+  rows.sort((a, b) => {
+    if (a.parentId !== b.parentId) return a.parentId < b.parentId ? -1 : 1;
+    if (a.key !== b.key) return a.key < b.key ? -1 : 1;
+    return 0;
+  });
+  return rows.map(
+    (r) => `  ${r.id}  parent=${r.parentId}  key=${r.key || "\u2014"}  ${r.value}`
+  ).join("\n");
+}
 function getTreesDiffOperations(currentItems, newItems) {
   const ops = [];
   currentItems.forEach((_, id) => {
@@ -9306,6 +9550,7 @@ function createRoom(options, config) {
     delegates,
     config.enableDebugLogging
   );
+  const unacknowledgedOps = new UnacknowledgedOps();
   const context = {
     buffer: {
       flushTimerID: void 0,
@@ -9333,14 +9578,15 @@ function createRoom(options, config) {
     pool: createManagedPool(roomId, {
       getCurrentConnectionId,
       onDispatch,
-      isStorageWritable
+      isStorageWritable,
+      unacknowledgedOps
     }),
     root: void 0,
     undoStack: [],
     redoStack: [],
     pausedHistory: null,
     activeBatch: null,
-    unacknowledgedOps: /* @__PURE__ */ new Map()
+    unacknowledgedOps
   };
   const nodeMapBuffer = makeNodeMapBuffer();
   const stopwatch = config.enableDebugLogging ? makeStopWatch() : void 0;
@@ -9548,7 +9794,11 @@ function createRoom(options, config) {
         currentItems.set(id, crdt._serialize());
       }
       const ops = getTreesDiffOperations(currentItems, nodes);
-      const result = applyRemoteOps(ops);
+      const result = applyRemoteOps(
+        ops,
+        /* fromSnapshot */
+        true
+      );
       notify(result.updates);
     } else {
       context.root = LiveObject._fromItems(
@@ -9630,15 +9880,16 @@ function createRoom(options, config) {
     );
     return { opsToEmit: opsWithOpIds, reverse, updates };
   }
-  function applyRemoteOps(ops) {
+  function applyRemoteOps(ops, fromSnapshot = false) {
     return applyOps(
       [],
       ops,
       /* isLocal */
-      false
+      false,
+      fromSnapshot
     );
   }
-  function applyOps(pframes, ops, isLocal) {
+  function applyOps(pframes, ops, isLocal, fromSnapshot = false) {
     const output = {
       reverse: new Deque(),
       storageUpdates: /* @__PURE__ */ new Map(),
@@ -9674,7 +9925,7 @@ function createRoom(options, config) {
       } else {
         source = 1 /* THEIRS */;
       }
-      const applyOpResult = applyOp(op, source);
+      const applyOpResult = applyOp(op, source, fromSnapshot);
       if (applyOpResult.modified) {
         const nodeId = applyOpResult.modified.node._id;
         if (!(nodeId && createdNodeIds.has(nodeId))) {
@@ -9700,7 +9951,7 @@ function createRoom(options, config) {
       }
     };
   }
-  function applyOp(op, source) {
+  function applyOp(op, source, fromSnapshot = false) {
     if (isIgnoredOp(op)) {
       return { modified: false };
     }
@@ -9739,7 +9990,7 @@ function createRoom(options, config) {
         if (parentNode === void 0) {
           return { modified: false };
         }
-        return parentNode._attachChild(op, source);
+        return parentNode._attachChild(op, source, fromSnapshot);
       }
     }
   }
@@ -9879,12 +10130,11 @@ function createRoom(options, config) {
     }
   }
   function applyAndSendOfflineOps(unackedOps) {
-    if (unackedOps.size === 0) {
+    if (unackedOps.length === 0) {
       return;
     }
     const messages = [];
-    const inOps = Array.from(unackedOps.values());
-    const result = applyLocalOps(inOps);
+    const result = applyLocalOps(unackedOps);
     messages.push({
       type: ClientMsgCode.UPDATE_STORAGE,
       ops: result.opsToEmit
@@ -10108,7 +10358,7 @@ function createRoom(options, config) {
     const storageOps = context.buffer.storageOperations;
     if (storageOps.length > 0) {
       for (const op of storageOps) {
-        context.unacknowledgedOps.set(op.opId, op);
+        context.unacknowledgedOps.add(op);
       }
       notifyStorageStatus();
     }
@@ -10335,9 +10585,9 @@ function createRoom(options, config) {
     }
   }
   function processInitialStorage(nodes) {
-    const unacknowledgedOps = new Map(context.unacknowledgedOps);
+    const unacknowledgedOps2 = [...context.unacknowledgedOps.values()];
     createOrUpdateRootFromMessage(nodes);
-    applyAndSendOfflineOps(unacknowledgedOps);
+    applyAndSendOfflineOps(unacknowledgedOps2);
     _resolveStoragePromise?.();
     notifyStorageStatus();
     eventHub.storageDidLoad.notify();
@@ -10926,6 +11176,11 @@ function createRoom(options, config) {
       connect: () => managedSocket.connect(),
       reconnect: () => managedSocket.reconnect(),
       disconnect: () => managedSocket.disconnect(),
+      _dump: () => {
+        const n = context.pool.nodes.size;
+        return `Room "${roomId}" (${n} node${n === 1 ? "" : "s"}):
+${dumpPool(context.pool)}`;
+      },
       destroy: () => {
         pendingFeedsRequests.forEach(
           (request) => request.reject(new Error("Room destroyed"))
@@ -11433,6 +11688,7 @@ function createClient(options) {
     {
       enterRoom,
       getRoom,
+      _dump: () => Array.from(roomsById.values(), ({ room }) => room._dump()).join("\n\n"),
       logout,
       // Public inbox notifications API
       getInboxNotifications: httpClient.getInboxNotifications,