@liveblocks/core 3.20.0-perm1 → 3.20.0-perm2

package/dist/index.js

@@ -6,7 +6,7 @@ var __export = (target, all) => {
 
 // src/version.ts
 var PKG_NAME = "@liveblocks/core";
-var PKG_VERSION = "3.20.0-perm1";
+var PKG_VERSION = "3.20.0-perm2";
 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)) {
@@ -5723,6 +5737,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({
@@ -5980,12 +5997,112 @@ 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();
+  // opIds of pending ops that were in flight when a connection died, so the
+  // server may already have processed them. See isPossiblyStored().
+  #possiblyStoredOpIds = /* @__PURE__ */ new Set();
+  #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);
+    this.#possiblyStoredOpIds.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();
+  }
+  isPossiblyStored(opId) {
+    return this.#possiblyStoredOpIds.has(opId);
+  }
+  /**
+   * Mark every currently pending op as possibly stored on the server. Called
+   * when the connection dies: all of these ops were in flight, and their
+   * (possibly lost) acks would have been the only way to know their fate.
+   */
+  markAllAsPossiblyStored() {
+    for (const opId of this.#byOpId.keys()) {
+      this.#possiblyStoredOpIds.add(opId);
+    }
+  }
+};
+
 // 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;
@@ -6007,7 +6124,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) {
@@ -6289,11 +6407,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) {
@@ -6323,12 +6439,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) {
@@ -6344,9 +6461,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);
@@ -6388,6 +6505,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);
@@ -6468,13 +6607,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);
@@ -6565,11 +6700,92 @@ var LiveList = class _LiveList extends AbstractCrdt {
       this.#shiftItemPosition(existingItemIndex, key);
     }
     const { newItem, newIndex } = this.#createAttachItemAndSort(op, key);
+    const bumpDeltas = 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.
+   *
+   * Excludes ops that may already be stored on the server (they were in
+   * flight when a connection died, so their fate is unknown): the bump
+   * prediction assumes the server has not processed the op yet, which is only
+   * guaranteed for ops sent on the current connection. For these excluded
+   * ops, the server's (re-)ack states the authoritative position; predicting
+   * locally could produce a wrong position that no ack would correct.
+   *
+   * 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;
+      }
+      if (this._pool.unacknowledgedOps.isPossiblyStored(op.opId)) {
+        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);
@@ -6650,7 +6866,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);
@@ -6660,8 +6875,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)];
@@ -6904,8 +7120,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.
@@ -6913,6 +7128,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(
@@ -6928,8 +7152,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)])]
@@ -7087,13 +7312,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);
@@ -7294,15 +7520,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;
     }
@@ -7954,6 +8176,7 @@ var LiveObject = class _LiveObject extends AbstractCrdt {
       const id = nn(this._id);
       const parentKey = nn(child._parentKey);
       const reverse = child._toOps(id, parentKey);
+      const deletedItem = liveNodeToLson(child);
       for (const [key, value] of this.#synced) {
         if (value === child) {
           this.#synced.delete(key);
@@ -7965,7 +8188,7 @@ var LiveObject = class _LiveObject extends AbstractCrdt {
         node: this,
         type: "LiveObject",
         updates: {
-          [parentKey]: { type: "delete" }
+          [parentKey]: { type: "delete", deletedItem }
         }
       };
       return { modified: storageUpdate, reverse };
@@ -8542,6 +8765,60 @@ 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 isJsonEq(a, b) {
+  if (a === b) {
+    return true;
+  }
+  if (typeof a !== "object" || a === null || typeof b !== "object" || b === null) {
+    return false;
+  }
+  if (Array.isArray(a) || Array.isArray(b)) {
+    if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) {
+      return false;
+    }
+    for (let i = 0; i < a.length; i++) {
+      if (!isJsonEq(a[i], b[i])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  const aKeys = Object.keys(a);
+  if (aKeys.length !== Object.keys(b).length) {
+    return false;
+  }
+  for (const key of aKeys) {
+    if (!isJsonEq(a[key], b[key])) {
+      return false;
+    }
+  }
+  return true;
+}
 function getTreesDiffOperations(currentItems, newItems) {
   const ops = [];
   currentItems.forEach((_, id) => {
@@ -8553,12 +8830,28 @@ function getTreesDiffOperations(currentItems, newItems) {
     const currentCrdt = currentItems.get(id);
     if (currentCrdt) {
       if (crdt.type === CrdtType.OBJECT) {
-        if (currentCrdt.type !== CrdtType.OBJECT || stringifyOrLog(crdt.data) !== stringifyOrLog(currentCrdt.data)) {
-          ops.push({
-            type: OpCode.UPDATE_OBJECT,
-            id,
-            data: crdt.data
-          });
+        if (currentCrdt.type !== CrdtType.OBJECT) {
+          ops.push({ type: OpCode.UPDATE_OBJECT, id, data: crdt.data });
+        } else {
+          const changed = /* @__PURE__ */ new Map();
+          for (const key of Object.keys(crdt.data)) {
+            const value = crdt.data[key];
+            if (value !== void 0 && !isJsonEq(value, currentCrdt.data[key])) {
+              changed.set(key, value);
+            }
+          }
+          if (changed.size > 0) {
+            ops.push({
+              type: OpCode.UPDATE_OBJECT,
+              id,
+              data: Object.fromEntries(changed)
+            });
+          }
+          for (const key of Object.keys(currentCrdt.data)) {
+            if (!(key in crdt.data)) {
+              ops.push({ type: OpCode.DELETE_OBJECT_KEY, id, key });
+            }
+          }
         }
       }
       if (crdt.parentKey !== currentCrdt.parentKey) {
@@ -9551,6 +9844,7 @@ function createRoom(options, config) {
     delegates,
     config.enableDebugLogging
   );
+  const unacknowledgedOps = new UnacknowledgedOps();
   const context = {
     buffer: {
       flushTimerID: void 0,
@@ -9578,14 +9872,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;
@@ -9652,6 +9947,7 @@ function createRoom(options, config) {
   }
   function onDidDisconnect() {
     clearTimeout(context.buffer.flushTimerID);
+    context.unacknowledgedOps.markAllAsPossiblyStored();
   }
   managedSocket.events.onMessage.subscribe(handleServerMessage);
   managedSocket.events.statusDidChange.subscribe(onStatusDidChange);
@@ -10132,12 +10428,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
@@ -10361,7 +10656,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();
     }
@@ -10588,9 +10883,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();
@@ -11179,6 +11474,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"))
@@ -11692,6 +11992,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,
@@ -12362,6 +12663,7 @@ export {
   createManagedPool,
   createNotificationSettings,
   createThreadId,
+  deepLiveify,
   defineAiTool,
   deprecate,
   deprecateIf,