@liveblocks/server 1.5.0 → 1.6.0

package/dist/index.cjs

@@ -812,11 +812,11 @@ function makeInMemorySnapshot(values) {
 
 // src/MetadataDB.ts
 function makeMetadataDB(driver) {
-  async function get(a1, a2) {
+  function get(a1, a2) {
     if (a2 === void 0) {
-      return await driver.get_meta(a1);
+      return driver.get_meta(a1);
     } else {
-      return a1.value(await driver.get_meta(a2));
+      return a1.value(driver.get_meta(a2));
     }
   }
   return {
@@ -1039,6 +1039,7 @@ var InMemoryDriver = class {
   constructor(options) {
     __publicField(this, "_nextActor");
     __publicField(this, "_nodes");
+    __publicField(this, "_nodesApi");
     __publicField(this, "_metadb");
     __publicField(this, "_ydb");
     __publicField(this, "_leasedSessions");
@@ -1058,32 +1059,36 @@ var InMemoryDriver = class {
   raw_iter_nodes() {
     return this._nodes[Symbol.iterator]();
   }
+  reinitialize() {
+    this._nodesApi = void 0;
+  }
   /** Deletes all nodes and replaces them with the given document. */
   DANGEROUSLY_reset_nodes(doc) {
+    this.reinitialize();
     this._nodes.clear();
     for (const [id, node] of plainLsonToNodeStream(doc)) {
       this._nodes.set(id, node);
     }
   }
-  async get_meta(key) {
+  get_meta(key) {
     return this._metadb.get(key);
   }
-  async put_meta(key, value) {
+  put_meta(key, value) {
     this._metadb.set(key, value);
   }
-  async delete_meta(key) {
+  delete_meta(key) {
     this._metadb.delete(key);
   }
-  async list_leased_sessions() {
+  list_leased_sessions() {
     return this._leasedSessions.entries();
   }
-  async get_leased_session(sessionId) {
+  get_leased_session(sessionId) {
     return this._leasedSessions.get(sessionId);
   }
-  async put_leased_session(session) {
+  put_leased_session(session) {
     this._leasedSessions.set(session.sessionId, session);
   }
-  async delete_leased_session(sessionId) {
+  delete_leased_session(sessionId) {
     this._leasedSessions.delete(sessionId);
   }
   takeRowsWritten() {
@@ -1092,7 +1097,7 @@ var InMemoryDriver = class {
   // ---------------------------------------------------------------------------
   // Feed APIs
   // ---------------------------------------------------------------------------
-  async list_feeds(options) {
+  list_feeds(options) {
     const limit = Math.min(_nullishCoalesce(_optionalChain([options, 'optionalAccess', _37 => _37.limit]), () => ( 20)), 100);
     const since = _optionalChain([options, 'optionalAccess', _38 => _38.since]);
     const cursor = _optionalChain([options, 'optionalAccess', _39 => _39.cursor]);
@@ -1148,14 +1153,14 @@ var InMemoryDriver = class {
     }
     return { feeds, nextCursor };
   }
-  async get_feed(feedId) {
+  get_feed(feedId) {
     const feed = this._feeds.get(feedId);
     if (feed === void 0) {
       return void 0;
     }
     return feed;
   }
-  async create_feed(feed) {
+  create_feed(feed) {
     if (this._feeds.has(feed.feedId)) {
       throw new Error(`Feed ${feed.feedId} already exists`);
     }
@@ -1166,7 +1171,7 @@ var InMemoryDriver = class {
       updatedAt: feed.updatedAt
     });
   }
-  async update_feed_metadata(feedId, metadata) {
+  update_feed_metadata(feedId, metadata) {
     const existing = this._feeds.get(feedId);
     if (existing === void 0) {
       throw new Error(`Feed ${feedId} not found`);
@@ -1176,7 +1181,7 @@ var InMemoryDriver = class {
       metadata
     });
   }
-  async delete_feed(feedId) {
+  delete_feed(feedId) {
     const messageKeys = [];
     for (const [key] of this._feedMessages.entries()) {
       if (key.startsWith(`${feedId}:`)) {
@@ -1188,7 +1193,7 @@ var InMemoryDriver = class {
     }
     this._feeds.delete(feedId);
   }
-  async list_feed_messages(feedId, options) {
+  list_feed_messages(feedId, options) {
     const limit = Math.min(_nullishCoalesce(_optionalChain([options, 'optionalAccess', _41 => _41.limit]), () => ( 20)), 100);
     const since = _optionalChain([options, 'optionalAccess', _42 => _42.since]);
     const cursor = _optionalChain([options, 'optionalAccess', _43 => _43.cursor]);
@@ -1235,14 +1240,14 @@ var InMemoryDriver = class {
     }
     return { messages, nextCursor };
   }
-  async add_feed_message(feedId, message) {
+  add_feed_message(feedId, message) {
     const feed = this._feeds.get(feedId);
     if (feed === void 0) {
       throw new Error(`Feed ${feedId} not found`);
     }
     this._feedMessages.set(`${feedId}:${message.id}`, message);
   }
-  async update_feed_message(feedId, messageId, data, timestamp) {
+  update_feed_message(feedId, messageId, data, timestamp) {
     const key = `${feedId}:${messageId}`;
     const message = this._feedMessages.get(key);
     if (message === void 0) {
@@ -1260,33 +1265,85 @@ var InMemoryDriver = class {
     this._feedMessages.set(key, updatedMessage);
     return updatedMessage;
   }
-  async delete_feed_message(feedId, messageId) {
+  delete_feed_message(feedId, messageId) {
     this._feedMessages.delete(`${feedId}:${messageId}`);
   }
   next_actor() {
     return ++this._nextActor;
   }
-  async iter_y_updates(docId) {
+  iter_y_updates(docId) {
     const prefix = `${docId}@|@`;
     return _itertools.imap.call(void 0, 
       _itertools.ifilter.call(void 0, this._ydb.entries(), ([k]) => k.startsWith(prefix)),
       ([k, v]) => [k.slice(prefix.length), v]
     );
   }
-  async write_y_updates(docId, key, data) {
+  write_y_updates(docId, key, data) {
     this._ydb.set(`${docId}@|@${key}`, data);
   }
-  async delete_y_updates(docId, keys) {
+  delete_y_updates(docId, keys) {
     for (const key of keys) {
       this._ydb.delete(`${docId}@|@${key}`);
     }
   }
   /** @private Only use this in unit tests, never in production. */
-  async DANGEROUSLY_wipe_all_y_updates() {
+  DANGEROUSLY_wipe_all_y_updates() {
     this._ydb.clear();
   }
-  // Intercept load_nodes_api to add caching layer
-  load_nodes_api() {
+  // ---------------------------------------------------------------------------
+  // Node APIs
+  // ---------------------------------------------------------------------------
+  /**
+   * The lazily-built node API. Building it ensures the root node exists and
+   * constructs the reverse-lookup index. Invalidated by
+   * DANGEROUSLY_reset_nodes(), after which the next access rebuilds it.
+   */
+  get loadedApi() {
+    return _nullishCoalesce(this._nodesApi, () => ( (this._nodesApi = this._loadNodesApi())));
+  }
+  get_node(id) {
+    return this.loadedApi.get_node(id);
+  }
+  iter_nodes() {
+    return this.loadedApi.iter_nodes();
+  }
+  iter_nodes_optimized() {
+    return this.loadedApi.iter_nodes_optimized();
+  }
+  has_node(id) {
+    return this.loadedApi.has_node(id);
+  }
+  get_child_at(parentId, parentKey) {
+    return this.loadedApi.get_child_at(parentId, parentKey);
+  }
+  has_child_at(parentId, parentKey) {
+    return this.loadedApi.has_child_at(parentId, parentKey);
+  }
+  get_next_sibling(parentId, pos) {
+    return this.loadedApi.get_next_sibling(parentId, pos);
+  }
+  get_last_sibling(parentId) {
+    return this.loadedApi.get_last_sibling(parentId);
+  }
+  set_child(id, node, allowOverwrite) {
+    this.loadedApi.set_child(id, node, allowOverwrite);
+  }
+  move_sibling(id, newPos) {
+    this.loadedApi.move_sibling(id, newPos);
+  }
+  delete_node(id) {
+    this.loadedApi.delete_node(id);
+  }
+  delete_child_key(id, key) {
+    this.loadedApi.delete_child_key(id, key);
+  }
+  set_object_data(id, data, allowOverwrite) {
+    this.loadedApi.set_object_data(id, data, allowOverwrite);
+  }
+  get_snapshot(lowMemory) {
+    return this.loadedApi.get_snapshot(lowMemory);
+  }
+  _loadNodesApi() {
     const nodes = this._nodes;
     if (!nodes.has("root")) {
       nodes.set("root", { type: _core.CrdtType.OBJECT, data: {} });
@@ -1312,7 +1369,7 @@ var InMemoryDriver = class {
       }
       return lastPos;
     }
-    async function set_child(id, node, allowOverwrite = false) {
+    function set_child(id, node, allowOverwrite = false) {
       const parentNode = nodes.get(node.parentId);
       if (parentNode === void 0) {
         throw new Error(`No such parent ${quote(node.parentId)}`);
@@ -1335,7 +1392,7 @@ var InMemoryDriver = class {
       }
       nodes.set(id, node);
     }
-    async function move_sibling(id, newPos) {
+    function move_sibling(id, newPos) {
       const node = nodes.get(id);
       if (_optionalChain([node, 'optionalAccess', _44 => _44.parentId]) === void 0) {
         return;
@@ -1347,7 +1404,7 @@ var InMemoryDriver = class {
       nodes.set(id, newNode);
       revNodes.set(node.parentId, newPos, id);
     }
-    async function set_object_data(id, data, allowOverwrite = false) {
+    function set_object_data(id, data, allowOverwrite = false) {
       const node = nodes.get(id);
       if (_optionalChain([node, 'optionalAccess', _45 => _45.type]) !== _core.CrdtType.OBJECT) {
         return;
@@ -1540,45 +1597,26 @@ function nodeFromCreateChildOp(op2) {
   }
 }
 var Storage = class {
-  constructor(coreDriver) {
+  constructor(driver) {
     // The actual underlying storage API (could be backed by in-memory store,
-    // SQLite, Redis, Postgres, Cloudflare Durable Object Storage, etc.)
-    __publicField(this, "coreDriver");
-    __publicField(this, "_loadedDriver");
-    this.coreDriver = coreDriver;
+    // SQLite, Postgres, etc.)
+    __publicField(this, "driver");
+    this.driver = driver;
   }
   // -------------------------------------------------------------------------
   // Public API (for Storage)
   // -------------------------------------------------------------------------
-  get loadedDriver() {
-    if (this._loadedDriver === void 0) {
-      throw new Error("Cannot access tree before it's been loaded");
-    }
-    return this._loadedDriver;
-  }
   // REFACTOR NOTE: Eventually raw_iter_nodes has to be removed here
   raw_iter_nodes() {
-    return this.coreDriver.raw_iter_nodes();
-  }
-  /**
-   * Load the room data from object storage into memory. Persisted room
-   * data consists of the main node map, which represents the Liveblocks
-   * Storage tree, and special keys where we store usage metrics, or room
-   * metadata.
-   */
-  async load(logger) {
-    this._loadedDriver = await this.coreDriver.load_nodes_api(logger);
-  }
-  unload() {
-    this._loadedDriver = void 0;
+    return this.driver.raw_iter_nodes();
   }
   /**
    * Applies a batch of Ops.
    */
-  async applyOps(ops) {
+  applyOps(ops) {
     const results = [];
     for (const op2 of ops) {
-      results.push(await this.applyOp(op2));
+      results.push(this.applyOp(op2));
     }
     return results;
   }
@@ -1588,21 +1626,21 @@ var Storage = class {
   /**
    * Applies a single Op.
    */
-  async applyOp(op2) {
+  applyOp(op2) {
     switch (op2.type) {
       case _core.OpCode.CREATE_LIST:
       case _core.OpCode.CREATE_MAP:
       case _core.OpCode.CREATE_REGISTER:
       case _core.OpCode.CREATE_OBJECT:
-        return await this.applyCreateOp(op2);
+        return this.applyCreateOp(op2);
       case _core.OpCode.UPDATE_OBJECT:
-        return await this.applyUpdateObjectOp(op2);
+        return this.applyUpdateObjectOp(op2);
       case _core.OpCode.SET_PARENT_KEY:
-        return await this.applySetParentKeyOp(op2);
+        return this.applySetParentKeyOp(op2);
       case _core.OpCode.DELETE_OBJECT_KEY:
-        return await this.applyDeleteObjectKeyOp(op2);
+        return this.applyDeleteObjectKeyOp(op2);
       case _core.OpCode.DELETE_CRDT:
-        return await this.applyDeleteCrdtOp(op2);
+        return this.applyDeleteCrdtOp(op2);
       // istanbul ignore next
       default:
         if (process.env.NODE_ENV === "production") {
@@ -1612,12 +1650,12 @@ var Storage = class {
         }
     }
   }
-  async applyCreateOp(op2) {
-    if (this.loadedDriver.has_node(op2.id)) {
+  applyCreateOp(op2) {
+    if (this.driver.has_node(op2.id)) {
       return ignore(op2);
     }
     const node = nodeFromCreateChildOp(op2);
-    const parent = this.loadedDriver.get_node(node.parentId);
+    const parent = this.driver.get_node(node.parentId);
     if (parent === void 0) {
       return ignore(op2);
     }
@@ -1628,7 +1666,7 @@ var Storage = class {
         }
       // fall through
       case _core.CrdtType.MAP:
-        await this.loadedDriver.set_child(op2.id, node, true);
+        this.driver.set_child(op2.id, node, true);
         return accept(op2);
       case _core.CrdtType.LIST:
         return this.createChildAsListItem(op2, node);
@@ -1639,23 +1677,19 @@ var Storage = class {
         return _core.assertNever.call(void 0, parent, "Unhandled CRDT type");
     }
   }
-  async createChildAsListItem(op2, node) {
+  createChildAsListItem(op2, node) {
     const intent2 = _nullishCoalesce(op2.intent, () => ( "insert"));
     if (intent2 === "insert") {
-      return this.acceptAndFix(
-        op2,
-        node,
-        await this.insertIntoList(op2.id, node)
-      );
+      return this.acceptAndFix(op2, node, this.insertIntoList(op2.id, node));
     } else if (intent2 === "push") {
-      return this.acceptAndFix(op2, node, await this.appendToList(op2.id, node));
+      return this.acceptAndFix(op2, node, this.appendToList(op2.id, node));
     } else if (intent2 === "set") {
       let fix;
-      const deletedId = op2.deletedId !== void 0 && op2.deletedId !== op2.id && _optionalChain([this, 'access', _47 => _47.loadedDriver, 'access', _48 => _48.get_node, 'call', _49 => _49(op2.deletedId), 'optionalAccess', _50 => _50.parentId]) === node.parentId ? op2.deletedId : void 0;
+      const deletedId = op2.deletedId !== void 0 && op2.deletedId !== op2.id && _optionalChain([this, 'access', _47 => _47.driver, 'access', _48 => _48.get_node, 'call', _49 => _49(op2.deletedId), 'optionalAccess', _50 => _50.parentId]) === node.parentId ? op2.deletedId : void 0;
       if (deletedId !== void 0) {
-        await this.loadedDriver.delete_node(deletedId);
+        this.driver.delete_node(deletedId);
       }
-      const prevItemId = this.loadedDriver.get_child_at(
+      const prevItemId = this.driver.get_child_at(
         node.parentId,
         node.parentKey
       );
@@ -1665,7 +1699,7 @@ var Storage = class {
           id: prevItemId
         };
       }
-      await this.loadedDriver.set_child(op2.id, node, true);
+      this.driver.set_child(op2.id, node, true);
       return accept(op2, fix);
     } else {
       return _core.assertNever.call(void 0, intent2, "Invalid intent");
@@ -1685,20 +1719,20 @@ var Storage = class {
     }
     return accept(op2);
   }
-  async applyDeleteObjectKeyOp(op2) {
-    await this.loadedDriver.delete_child_key(op2.id, op2.key);
+  applyDeleteObjectKeyOp(op2) {
+    this.driver.delete_child_key(op2.id, op2.key);
     return accept(op2);
   }
-  async applyUpdateObjectOp(op2) {
-    await this.loadedDriver.set_object_data(op2.id, op2.data, true);
+  applyUpdateObjectOp(op2) {
+    this.driver.set_object_data(op2.id, op2.data, true);
     return accept(op2);
   }
-  async applyDeleteCrdtOp(op2) {
-    await this.loadedDriver.delete_node(op2.id);
+  applyDeleteCrdtOp(op2) {
+    this.driver.delete_node(op2.id);
     return accept(op2);
   }
-  async applySetParentKeyOp(op2) {
-    const newPosition = await this.moveToPosInList(op2.id, op2.parentKey);
+  applySetParentKeyOp(op2) {
+    const newPosition = this.moveToPosInList(op2.id, op2.parentKey);
     if (newPosition === void 0) {
       return ignore(op2);
     }
@@ -1722,12 +1756,12 @@ var Storage = class {
    *
    * Returns the key that was used for the insertion.
    */
-  async insertIntoList(id, node) {
+  insertIntoList(id, node) {
     const key = this.findFreeListPosition(node.parentId, _core.asPos.call(void 0, node.parentKey));
     if (key !== node.parentKey) {
       node = { ...node, parentKey: key };
     }
-    await this.loadedDriver.set_child(id, node);
+    this.driver.set_child(id, node);
     return node.parentKey;
   }
   /**
@@ -1740,11 +1774,11 @@ var Storage = class {
    *
    * Returns the final key that was used for the insertion.
    */
-  async appendToList(id, node) {
-    const lastPos = this.loadedDriver.get_last_sibling(node.parentId);
+  appendToList(id, node) {
+    const lastPos = this.driver.get_last_sibling(node.parentId);
     const preferredPos = _core.asPos.call(void 0, node.parentKey);
     const finalKey = lastPos === void 0 || preferredPos > lastPos ? preferredPos : _core.makePosition.call(void 0, lastPos);
-    await this.loadedDriver.set_child(
+    this.driver.set_child(
       id,
       finalKey !== node.parentKey ? { ...node, parentKey: finalKey } : node
     );
@@ -1762,12 +1796,12 @@ var Storage = class {
    * Will return `undefined` if this action could not be interpreted. Will be
    * a no-op for non-list items.
    */
-  async moveToPosInList(id, targetKey) {
-    const node = this.loadedDriver.get_node(id);
+  moveToPosInList(id, targetKey) {
+    const node = this.driver.get_node(id);
     if (_optionalChain([node, 'optionalAccess', _51 => _51.parentId]) === void 0) {
       return;
     }
-    if (_optionalChain([this, 'access', _52 => _52.loadedDriver, 'access', _53 => _53.get_node, 'call', _54 => _54(node.parentId), 'optionalAccess', _55 => _55.type]) !== _core.CrdtType.LIST) {
+    if (_optionalChain([this, 'access', _52 => _52.driver, 'access', _53 => _53.get_node, 'call', _54 => _54(node.parentId), 'optionalAccess', _55 => _55.type]) !== _core.CrdtType.LIST) {
       return;
     }
     if (node.parentKey === targetKey) {
@@ -1775,7 +1809,7 @@ var Storage = class {
     }
     const key = this.findFreeListPosition(node.parentId, _core.asPos.call(void 0, targetKey));
     if (key !== node.parentKey) {
-      await this.loadedDriver.move_sibling(id, key);
+      this.driver.move_sibling(id, key);
     }
     return key;
   }
@@ -1787,11 +1821,11 @@ var Storage = class {
    * to use as parentKey.
    */
   findFreeListPosition(parentId, parentPos) {
-    if (!this.loadedDriver.has_child_at(parentId, parentPos)) {
+    if (!this.driver.has_child_at(parentId, parentPos)) {
       return parentPos;
     }
     const currPos = parentPos;
-    const nextPos = this.loadedDriver.get_next_sibling(parentId, currPos);
+    const nextPos = this.driver.get_next_sibling(parentId, currPos);
     if (nextPos !== void 0) {
       return _core.makePosition.call(void 0, currPos, nextPos);
     } else {
@@ -1801,6 +1835,7 @@ var Storage = class {
 };
 
 // src/YjsStorage.ts
+var _crypto = require('crypto');
 var _jsbase64 = require('js-base64');
 
 var _yjs = require('yjs'); var Y = _interopRequireWildcard(_yjs);
@@ -1810,30 +1845,33 @@ var YjsStorage = class {
   constructor(driver, updateCountThreshold = UPDATE_COUNT_THRESHOLD) {
     __publicField(this, "driver");
     __publicField(this, "updateCountThreshold");
-    __publicField(this, "doc", new Y.Doc());
-    // the root document
+    /**
+     * The root Y.Doc instance, which may not have been hydrated from storage
+     * yet. Use getRootDoc() instead, which lazily hydrates it on first access —
+     * only touch this field directly when the unhydrated instance is fine
+     * (e.g. identity checks, subdoc traversal).
+     */
+    __publicField(this, "rawRootDoc", new Y.Doc());
     __publicField(this, "lastSnapshotById", /* @__PURE__ */ new Map());
-    __publicField(this, "initPromisesById", /* @__PURE__ */ new Map());
+    __publicField(this, "docsById", /* @__PURE__ */ new Map());
     __publicField(this, "storedKeysById", /* @__PURE__ */ new Map());
     // compact the updates into a single update and write it to the durable storage
-    __publicField(this, "_compactYJSUpdates", async (doc, docId, storedKeys) => {
+    __publicField(this, "_compactYJSUpdates", (doc, docId, storedKeys) => {
       const compactedUpdate = Y.encodeStateAsUpdate(doc);
       const newKey = _nanoid.nanoid.call(void 0, );
-      await this.driver.write_y_updates(docId, newKey, compactedUpdate);
-      await this.driver.delete_y_updates(docId, storedKeys);
+      this.driver.write_y_updates(docId, newKey, compactedUpdate);
+      this.driver.delete_y_updates(docId, storedKeys);
       this.storedKeysById.set(docId, [newKey]);
     });
-    __publicField(this, "_loadYDocFromDurableStorage", async (_logger, doc, docId) => {
-      const docUpdates = Object.fromEntries(
-        await this.driver.iter_y_updates(docId)
-      );
+    __publicField(this, "_loadYDocFromDurableStorage", (doc, docId) => {
+      const docUpdates = Object.fromEntries(this.driver.iter_y_updates(docId));
       const updates = Object.values(docUpdates);
       const beforeSize = updates.reduce((acc, update) => acc + update.length, 0);
       const newupdate = Y.mergeUpdates(updates);
       const storedKeys = Object.keys(docUpdates);
       Y.applyUpdate(doc, newupdate);
       if (this.shouldCompactByKeyCount(storedKeys) || this.shouldCompactBySize(beforeSize, newupdate.length)) {
-        await this._compactYJSUpdates(doc, docId, storedKeys);
+        this._compactYJSUpdates(doc, docId, storedKeys);
       } else {
         this.storedKeysById.set(docId, storedKeys);
       }
@@ -1842,7 +1880,7 @@ var YjsStorage = class {
     });
     this.driver = driver;
     this.updateCountThreshold = updateCountThreshold;
-    this.doc.on("subdocs", ({ removed }) => {
+    this.rawRootDoc.on("subdocs", ({ removed }) => {
       removed.forEach((subdoc) => {
         subdoc.destroy();
       });
@@ -1851,9 +1889,27 @@ var YjsStorage = class {
   // ------------------------------------------------------------------------------------
   // Public API
   // ------------------------------------------------------------------------------------
-  async getYDoc(logger, docId) {
-    const doc = await this.loadDocByIdIfNotAlreadyLoaded(logger, docId);
-    return doc;
+  getYDoc(logger, docId) {
+    if (docId !== ROOT_YDOC_ID) {
+      this.getRootDoc(logger);
+    }
+    let loaded = this.docsById.get(docId);
+    let doc = docId === ROOT_YDOC_ID ? this.rawRootDoc : this.findYSubdocByGuid(docId);
+    if (!doc) {
+      doc = new Y.Doc();
+    }
+    if (loaded === void 0) {
+      loaded = this._loadYDocFromDurableStorage(doc, docId);
+      this.docsById.set(docId, loaded);
+    }
+    return loaded;
+  }
+  /**
+   * Returns the root Y.Doc, lazily loading it from storage first if it
+   * hasn't been loaded yet during this instance's lifetime.
+   */
+  getRootDoc(logger) {
+    return this.getYDoc(logger, ROOT_YDOC_ID);
   }
   /**
    * If passed a state vector, an update with diff will be returned, if not the entire doc is returned.
@@ -1861,18 +1917,13 @@ var YjsStorage = class {
    * @param stateVector a base64 encoded target state vector created by running Y.encodeStateVector(Doc) on the client
    * @returns a base64 encoded array of YJS updates
    */
-  async getYDocUpdate(logger, stateVector = "", guid, isV2 = false) {
-    const update = await this.getYDocUpdateBinary(
-      logger,
-      stateVector,
-      guid,
-      isV2
-    );
+  getYDocUpdate(logger, stateVector = "", guid, isV2 = false) {
+    const update = this.getYDocUpdateBinary(logger, stateVector, guid, isV2);
     if (!update) return null;
     return _jsbase64.Base64.fromUint8Array(update);
   }
-  async getYDocUpdateBinary(logger, stateVector = "", guid, isV2 = false) {
-    const doc = guid !== void 0 ? await this.getYSubdoc(logger, guid) : this.doc;
+  getYDocUpdateBinary(logger, stateVector = "", guid, isV2 = false) {
+    const doc = guid !== void 0 ? this.getYSubdoc(logger, guid) : this.getRootDoc(logger);
     if (!doc) {
       return null;
     }
@@ -1889,15 +1940,15 @@ var YjsStorage = class {
     }
     return Y.encodeStateAsUpdate(doc, encodedTargetVector);
   }
-  async getYStateVector(logger, guid) {
-    const doc = guid !== void 0 ? await this.getYSubdoc(logger, guid) : this.doc;
+  getYStateVector(logger, guid) {
+    const doc = guid !== void 0 ? this.getYSubdoc(logger, guid) : this.getRootDoc(logger);
     if (!doc) {
       return null;
     }
     return _jsbase64.Base64.fromUint8Array(Y.encodeStateVector(doc));
   }
-  async getSnapshotHash(logger, options) {
-    const doc = options.guid !== void 0 ? await this.getYSubdoc(logger, options.guid) : this.doc;
+  getSnapshotHash(logger, options) {
+    const doc = options.guid !== void 0 ? this.getYSubdoc(logger, options.guid) : this.getRootDoc(logger);
     if (!doc) {
       return null;
     }
@@ -1910,8 +1961,8 @@ var YjsStorage = class {
    *   isUpdated: true if the update had an effect on the YDoc
    *   snapshotHash: the hash of the new snapshot
    */
-  async addYDocUpdate(logger, update, guid, isV2) {
-    const doc = guid !== void 0 ? await this.getYSubdoc(logger, guid) : this.doc;
+  addYDocUpdate(logger, update, guid, isV2) {
+    const doc = guid !== void 0 ? this.getYSubdoc(logger, guid) : this.getRootDoc(logger);
     if (!doc) {
       throw new Error(`YDoc with guid ${guid} not found`);
     }
@@ -1923,11 +1974,11 @@ var YjsStorage = class {
       const afterSnapshot = this._putLastSnapshot(doc);
       const updated = !Y.equalSnapshots(beforeSnapshot, afterSnapshot);
       if (updated) {
-        await this.handleYDocUpdate(doc, updateAsU8, isV2);
+        this.handleYDocUpdate(doc, updateAsU8, isV2);
       }
       return {
         isUpdated: updated,
-        snapshotHash: await this.calculateSnapshotHash(afterSnapshot, { isV2 })
+        snapshotHash: this.calculateSnapshotHash(afterSnapshot, { isV2 })
       };
     } catch (e) {
       logger.warn(`Ignored bad YDoc update: ${String(e)}`);
@@ -1936,32 +1987,12 @@ var YjsStorage = class {
       );
     }
   }
-  loadDocByIdIfNotAlreadyLoaded(logger, docId) {
-    let loaded$ = this.initPromisesById.get(docId);
-    let doc = docId === ROOT_YDOC_ID ? this.doc : this.findYSubdocByGuid(docId);
-    if (!doc) {
-      doc = new Y.Doc();
-    }
-    if (loaded$ === void 0) {
-      loaded$ = this._loadYDocFromDurableStorage(logger, doc, docId);
-      this.initPromisesById.set(docId, loaded$);
-    }
-    return loaded$;
-  }
-  async load(logger) {
-    await this.loadDocByIdIfNotAlreadyLoaded(logger, ROOT_YDOC_ID);
-  }
-  /**
-   * Unloads the Yjs documents from memory.
-   */
-  unload() {
-  }
   // ------------------------------------------------------------------------------------
   // Private APIs
   // ------------------------------------------------------------------------------------
   // NOTE: We could instead store the hash of snapshot instead of the whole snapshot to optimize memory usage.
   _getOrPutLastSnapshot(doc) {
-    const docId = doc.guid === this.doc.guid ? ROOT_YDOC_ID : doc.guid;
+    const docId = doc.guid === this.rawRootDoc.guid ? ROOT_YDOC_ID : doc.guid;
     const snapshot2 = this.lastSnapshotById.get(docId);
     if (snapshot2) {
       return snapshot2;
@@ -1970,47 +2001,44 @@ var YjsStorage = class {
   }
   // NOTE: We could instead store the hash of snapshot instead of the whole snapshot to optimize memory usage.
   _putLastSnapshot(doc) {
-    const docId = doc.guid === this.doc.guid ? ROOT_YDOC_ID : doc.guid;
+    const docId = doc.guid === this.rawRootDoc.guid ? ROOT_YDOC_ID : doc.guid;
     const snapshot2 = Y.snapshot(doc);
     this.lastSnapshotById.set(docId, snapshot2);
     return snapshot2;
   }
   findYSubdocByGuid(guid) {
-    for (const subdoc of this.doc.getSubdocs()) {
+    for (const subdoc of this.rawRootDoc.getSubdocs()) {
       if (subdoc.guid === guid) {
         return subdoc;
       }
     }
     return null;
   }
-  async calculateSnapshotHash(snapshot2, { isV2 }) {
+  calculateSnapshotHash(snapshot2, { isV2 }) {
     const encodedSnapshot = isV2 ? Y.encodeSnapshotV2(snapshot2) : Y.encodeSnapshot(snapshot2);
-    return _jsbase64.Base64.fromUint8Array(
-      new Uint8Array(
-        await crypto.subtle.digest("SHA-256", new Uint8Array(encodedSnapshot))
-      )
-    );
+    return _crypto.createHash.call(void 0, "sha256").update(encodedSnapshot).digest("base64");
   }
   // gets a subdoc, it will be loaded if not already loaded
-  async getYSubdoc(logger, guid) {
+  getYSubdoc(logger, guid) {
+    this.getRootDoc(logger);
     const subdoc = this.findYSubdocByGuid(guid);
     if (!subdoc) {
       return null;
     }
-    await this.loadDocByIdIfNotAlreadyLoaded(logger, guid);
+    this.getYDoc(logger, guid);
     return subdoc;
   }
   // When the YJS doc changes, update it in durable storage
-  async handleYDocUpdate(doc, update, isV2) {
+  handleYDocUpdate(doc, update, isV2) {
     const v1update = isV2 ? Y.convertUpdateFormatV2ToV1(update) : update;
-    const docId = doc.guid === this.doc.guid ? ROOT_YDOC_ID : doc.guid;
+    const docId = doc.guid === this.rawRootDoc.guid ? ROOT_YDOC_ID : doc.guid;
     const storedKeys = this.storedKeysById.get(docId);
     if (this.shouldCompactByKeyCount(storedKeys)) {
-      await this._compactYJSUpdates(doc, docId, storedKeys || []);
+      this._compactYJSUpdates(doc, docId, storedKeys || []);
       return;
     }
     const newKey = _nanoid.nanoid.call(void 0, );
-    await this.driver.write_y_updates(docId, newKey, v1update);
+    this.driver.write_y_updates(docId, newKey, v1update);
     if (!storedKeys) {
       this.storedKeysById.set(docId, [newKey]);
     } else {
@@ -2029,10 +2057,19 @@ var YjsStorage = class {
 };
 
 // src/lib/tryCatch.ts
-async function tryCatch(promise) {
+function isThenable(value) {
+  return value !== null && (typeof value === "object" || typeof value === "function") && typeof value.then === "function";
+}
+function tryCatch(promise) {
   try {
-    const data = await (typeof promise === "function" ? promise() : promise);
-    return [data, void 0];
+    const result = typeof promise === "function" ? promise() : promise;
+    if (isThenable(result)) {
+      return Promise.resolve(result).then(
+        (data) => [data, void 0],
+        (error) => [void 0, error]
+      );
+    }
+    return [result, void 0];
   } catch (error) {
     return [void 0, error];
   }
@@ -2258,13 +2295,13 @@ var BackendSession = class extends BrowserSession {
     super(ticket, socket, debug);
   }
 };
-var __debug2;
+var _logger, __debug2;
 var Room = class {
   constructor(meta, options) {
     //              ^^^^^^^^^^ User-defined Room Metadata, Session Metadata, and Client Metadata
     __publicField(this, "meta");
     __publicField(this, "driver");
-    __publicField(this, "logger");
+    __privateAdd(this, _logger);
     /**
      * While a room is in "maintenance mode", all WebSocket connections to the
      * room should be rejected until it's pulled out of maintenance mode again.
@@ -2274,8 +2311,10 @@ var Room = class {
      * init-storage, storage-reset, etc.) cannot interfere with one another.
      */
     __publicField(this, "_maintenanceMode", new (0, _asyncmutex.Mutex)());
-    __publicField(this, "_loadData$", null);
-    __publicField(this, "_data", null);
+    __publicField(this, "_storage");
+    __publicField(this, "_yjsStorage");
+    __publicField(this, "mutex", new (0, _asyncmutex.Mutex)());
+    // prettier-ignore
     __publicField(this, "_qsize", 0);
     __publicField(this, "sessions", new UniqueMap((s) => s.actor));
     __publicField(this, "hooks");
@@ -2283,52 +2322,38 @@ var Room = class {
     const driver = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _61 => _61.storage]), () => ( makeNewInMemoryDriver()));
     this.meta = meta;
     this.driver = driver;
-    this.logger = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _62 => _62.logger]), () => ( BLACK_HOLE));
+    this._storage = new Storage(this.driver);
+    this._yjsStorage = new YjsStorage(this.driver);
+    __privateSet(this, _logger, _nullishCoalesce(_optionalChain([options, 'optionalAccess', _62 => _62.logger]), () => ( BLACK_HOLE)));
     this.hooks = {
       isClientMsgAllowed: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _63 => _63.hooks, 'optionalAccess', _64 => _64.isClientMsgAllowed]), () => ( (() => {
         return {
           allowed: true
         };
       }))),
-      // YYY .load() isn't called on the RoomServer yet! As soon as it does, these hooks will get called
-      onRoomWillLoad: _optionalChain([options, 'optionalAccess', _65 => _65.hooks, 'optionalAccess', _66 => _66.onRoomWillLoad]),
-      onRoomDidLoad: _optionalChain([options, 'optionalAccess', _67 => _67.hooks, 'optionalAccess', _68 => _68.onRoomDidLoad]),
-      onRoomWillUnload: _optionalChain([options, 'optionalAccess', _69 => _69.hooks, 'optionalAccess', _70 => _70.onRoomWillUnload]),
-      onRoomDidUnload: _optionalChain([options, 'optionalAccess', _71 => _71.hooks, 'optionalAccess', _72 => _72.onRoomDidUnload]),
-      onSessionDidStart: _optionalChain([options, 'optionalAccess', _73 => _73.hooks, 'optionalAccess', _74 => _74.onSessionDidStart]),
-      onSessionDidEnd: _optionalChain([options, 'optionalAccess', _75 => _75.hooks, 'optionalAccess', _76 => _76.onSessionDidEnd]),
-      postClientMsgStorageDidUpdate: _optionalChain([options, 'optionalAccess', _77 => _77.hooks, 'optionalAccess', _78 => _78.postClientMsgStorageDidUpdate]),
-      postClientMsgYdocDidUpdate: _optionalChain([options, 'optionalAccess', _79 => _79.hooks, 'optionalAccess', _80 => _80.postClientMsgYdocDidUpdate])
+      onRoomWillUnload: _optionalChain([options, 'optionalAccess', _65 => _65.hooks, 'optionalAccess', _66 => _66.onRoomWillUnload]),
+      onSessionDidStart: _optionalChain([options, 'optionalAccess', _67 => _67.hooks, 'optionalAccess', _68 => _68.onSessionDidStart]),
+      onSessionDidEnd: _optionalChain([options, 'optionalAccess', _69 => _69.hooks, 'optionalAccess', _70 => _70.onSessionDidEnd]),
+      postClientMsgStorageDidUpdate: _optionalChain([options, 'optionalAccess', _71 => _71.hooks, 'optionalAccess', _72 => _72.postClientMsgStorageDidUpdate]),
+      postClientMsgYdocDidUpdate: _optionalChain([options, 'optionalAccess', _73 => _73.hooks, 'optionalAccess', _74 => _74.postClientMsgYdocDidUpdate])
     };
-    __privateSet(this, __debug2, _nullishCoalesce(_optionalChain([options, 'optionalAccess', _81 => _81.enableDebugLogging]), () => ( false)));
-  }
-  get loadingState() {
-    if (this._loadData$ === null) {
-      return "initial";
-    } else if (this._data === null) {
-      return "loading";
-    } else {
-      return "loaded";
-    }
+    __privateSet(this, __debug2, _nullishCoalesce(_optionalChain([options, 'optionalAccess', _75 => _75.enableDebugLogging]), () => ( false)));
   }
-  get numSessions() {
-    return this.sessions.size;
-  }
-  // prettier-ignore
   get storage() {
-    return this.data.storage;
+    return this._storage;
   }
   // prettier-ignore
   get yjsStorage() {
-    return this.data.yjsStorage;
+    return this._yjsStorage;
   }
-  // prettier-ignore
-  get mutex() {
-    return this.data.mutex;
+  get logger() {
+    return __privateGet(this, _logger);
   }
-  // prettier-ignore
-  get data() {
-    return _nullishCoalesce(this._data, () => ( _core.raise.call(void 0, "Cannot use room before it's loaded")));
+  addLoggerContext(attrs) {
+    __privateSet(this, _logger, __privateGet(this, _logger).withContext(attrs));
+  }
+  get numSessions() {
+    return this.sessions.size;
   }
   // prettier-ignore
   // ------------------------------------------------------------------------------------
@@ -2353,34 +2378,15 @@ var Room = class {
   // Public API
   // ------------------------------------------------------------------------------------
   /**
-   * Initializes the Room, so it's ready to start accepting connections. Safe
-   * to call multiple times. After awaiting `room.load()` the Room is ready to
-   * be used.
-   */
-  async load(ctx) {
-    if (this._loadData$ === null) {
-      this._data = null;
-      this._loadData$ = this._load(ctx).catch((e) => {
-        this._data = null;
-        this._loadData$ = null;
-        throw e;
-      });
-    }
-    return this._loadData$;
-  }
-  /**
-   * Releases the currently-loaded storage tree from worker memory, freeing it
-   * up to be garbage collected. The next time a user will join the room, the
-   * room will be reloaded from storage.
+   * Releases the currently-loaded storage tree and Yjs documents from worker
+   * memory, freeing them up to be garbage collected. The next time the room
+   * is used, fresh instances will lazily be created.
    */
   unload(ctx) {
-    _optionalChain([this, 'access', _82 => _82.hooks, 'access', _83 => _83.onRoomWillUnload, 'optionalCall', _84 => _84(ctx)]);
-    if (this._data) {
-      this.storage.unload();
-      this.yjsStorage.unload();
-    }
-    this._loadData$ = null;
-    _optionalChain([this, 'access', _85 => _85.hooks, 'access', _86 => _86.onRoomDidUnload, 'optionalCall', _87 => _87(ctx)]);
+    _optionalChain([this, 'access', _76 => _76.hooks, 'access', _77 => _77.onRoomWillUnload, 'optionalCall', _78 => _78(ctx)]);
+    this.driver.reinitialize();
+    this._storage = new Storage(this.driver);
+    this._yjsStorage = new YjsStorage(this.driver);
   }
   /**
    * Issues a Ticket with a new/unique actor ID
@@ -2393,26 +2399,26 @@ var Room = class {
    * connection is established. If the socket is never established, this
    * unused Ticket will simply get garbage collected.
    */
-  async createTicket(options) {
-    const actor$ = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _88 => _88.actor]), () => ( this.getNextActor()));
+  createTicket(options) {
+    const actor = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _79 => _79.actor]), () => ( this.getNextActor()));
     const sessionKey = _nanoid.nanoid.call(void 0, );
-    const info = _optionalChain([options, 'optionalAccess', _89 => _89.info]);
+    const info = _optionalChain([options, 'optionalAccess', _80 => _80.info]);
     const ticket = {
-      version: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _90 => _90.version]), () => ( HIGHEST_PROTOCOL_VERSION)),
-      actor: await actor$,
+      version: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _81 => _81.version]), () => ( HIGHEST_PROTOCOL_VERSION)),
+      actor,
       sessionKey,
-      meta: _optionalChain([options, 'optionalAccess', _91 => _91.meta]),
-      publicMeta: _optionalChain([options, 'optionalAccess', _92 => _92.publicMeta]),
-      user: _optionalChain([options, 'optionalAccess', _93 => _93.id]) ? { id: options.id, info } : { anonymousId: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _94 => _94.anonymousId]), () => ( _nanoid.nanoid.call(void 0, ))), info },
-      scopes: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _95 => _95.scopes]), () => ( ["room:write"]))
+      meta: _optionalChain([options, 'optionalAccess', _82 => _82.meta]),
+      publicMeta: _optionalChain([options, 'optionalAccess', _83 => _83.publicMeta]),
+      user: _optionalChain([options, 'optionalAccess', _84 => _84.id]) ? { id: options.id, info } : { anonymousId: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _85 => _85.anonymousId]), () => ( _nanoid.nanoid.call(void 0, ))), info },
+      scopes: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _86 => _86.scopes]), () => ( ["room:write"]))
     };
     if (__privateGet(this, __debug2)) {
       console.log(`new ticket created: ${JSON.stringify(ticket)}`);
     }
     return ticket;
   }
-  async createBackendSession_experimental() {
-    const ticket = await this.createTicket();
+  createBackendSession_experimental() {
+    const ticket = this.createTicket();
     const capturedServerMsgs = [];
     const stub = {
       send: (data) => {
@@ -2453,7 +2459,7 @@ var Room = class {
       newSession.markActive(lastActivity);
     }
   }
-  async sendSessionStartMessages(newSession, ticket, ctx, defer = () => {
+  sendSessionStartMessages(newSession, ticket, ctx, defer = () => {
     throw new Error(
       "One of your hook handlers returned a promise, but no side effect collector was provided. Pass a `defer` callback to sendSessionStartMessages() to collect async side effects."
     );
@@ -2466,10 +2472,7 @@ var Room = class {
         scopes: session.scopes
       };
     }
-    const leasedSessions = await this.listLeasedSessions(
-      ctx,
-      defer
-    );
+    const leasedSessions = this.listLeasedSessions(ctx, defer);
     for (const leasedSession of leasedSessions) {
       users[leasedSession.actorId] = {
         id: leasedSession.sessionId,
@@ -2505,7 +2508,7 @@ var Room = class {
    * - Sends a ROOM_STATE message to the socket.
    * - Broadcasts a USER_JOINED message to all other sessions in the room.
    */
-  async startBrowserSession(ticket, socket, ctx, defer = () => {
+  startBrowserSession(ticket, socket, ctx, defer = () => {
     throw new Error(
       "One of your hook handlers returned a promise, but no side effect collector was provided. Pass a `defer` callback to startBrowserSession() to collect async side effects."
     );
@@ -2519,13 +2522,13 @@ var Room = class {
         ctx,
         defer
       );
-      this.logger.warn(
+      __privateGet(this, _logger).warn(
         `Previous session for actor ${ticket.actor} killed in favor of new session`
       );
     }
     const newSession = new BrowserSession(ticket, socket, __privateGet(this, __debug2));
     this.sessions.set(ticket.sessionKey, newSession);
-    await this.sendSessionStartMessages(newSession, ticket, ctx, defer);
+    this.sendSessionStartMessages(newSession, ticket, ctx, defer);
     this.sendToOthers(
       ticket.sessionKey,
       {
@@ -2538,7 +2541,7 @@ var Room = class {
       ctx,
       defer
     );
-    const p$ = _optionalChain([this, 'access', _96 => _96.hooks, 'access', _97 => _97.onSessionDidStart, 'optionalCall', _98 => _98(newSession, ctx)]);
+    const p$ = _optionalChain([this, 'access', _87 => _87.hooks, 'access', _88 => _88.onSessionDidStart, 'optionalCall', _89 => _89(newSession, ctx)]);
     if (p$) defer(p$);
   }
   /**
@@ -2562,7 +2565,7 @@ var Room = class {
       for (const other of this.otherSessions(key)) {
         other.send({ type: ServerMsgCode2.USER_LEFT, actor: session.actor });
       }
-      const p$ = _optionalChain([this, 'access', _99 => _99.hooks, 'access', _100 => _100.onSessionDidEnd, 'optionalCall', _101 => _101(session, ctx)]);
+      const p$ = _optionalChain([this, 'access', _90 => _90.hooks, 'access', _91 => _91.onSessionDidEnd, 'optionalCall', _92 => _92(session, ctx)]);
       if (p$) defer(p$);
     }
   }
@@ -2593,7 +2596,7 @@ var Room = class {
     );
   }) {
     const text = typeof data === "string" ? data : _core.raise.call(void 0, "Unsupported message format");
-    _optionalChain([this, 'access', _102 => _102.sessions, 'access', _103 => _103.get, 'call', _104 => _104(key), 'optionalAccess', _105 => _105.markActive, 'call', _106 => _106()]);
+    _optionalChain([this, 'access', _93 => _93.sessions, 'access', _94 => _94.get, 'call', _95 => _95(key), 'optionalAccess', _96 => _96.markActive, 'call', _97 => _97()]);
     if (text === "ping") {
       await this.handlePing(key, ctx);
     } else {
@@ -2633,7 +2636,6 @@ var Room = class {
    * 2. The ClientMsg payload has been validated to be correct.
    */
   async processClientMsg(key, messages, ctx) {
-    await this.load(ctx);
     const { defer, waitAll } = collectSideEffects();
     await this.mutex.runExclusive(
       () => this._processClientMsg_withExclusiveAccess(key, messages, ctx, defer)
@@ -2660,7 +2662,6 @@ var Room = class {
    * a session.
    */
   async processClientMsgFromBackendSession(session, messages, ctx) {
-    await this.load(ctx);
     const { defer, waitAll } = collectSideEffects();
     await this.mutex.runExclusive(
       () => this._processClientMsgFromBackendSession_withExclusiveAccess(
@@ -2682,18 +2683,18 @@ var Room = class {
    * Upsert a leased session. Creates a new session if it doesn't exist (or is expired),
    * or updates an existing session with merged presence.
    */
-  async upsertLeasedSession(sessionId, presence, ttl, info, ctx, defer = () => {
+  upsertLeasedSession(sessionId, presence, ttl, info, ctx, defer = () => {
     throw new Error(
       "One of your hook handlers returned a promise, but no side effect collector was provided. Pass a `defer` callback to upsertLeasedSession() to collect async side effects."
     );
   }) {
-    const existingSession = await this.driver.get_leased_session(sessionId);
+    const existingSession = this.driver.get_leased_session(sessionId);
     const isExpired = existingSession !== void 0 && isLeasedSessionExpired(existingSession);
     if (isExpired) {
-      await this.deleteLeasedSession(existingSession, ctx, defer);
+      this.deleteLeasedSession(existingSession, ctx, defer);
     }
     if (existingSession === void 0 || isExpired) {
-      const actorId = await this.getNextActor();
+      const actorId = this.getNextActor();
       const now = Date.now();
       const session = {
         sessionId,
@@ -2703,7 +2704,7 @@ var Room = class {
         ttl,
         actorId
       };
-      await this.driver.put_leased_session(session);
+      this.driver.put_leased_session(session);
       this.sendToAll(
         {
           type: ServerMsgCode2.USER_JOINED,
@@ -2737,7 +2738,7 @@ var Room = class {
         updatedAt: Date.now(),
         ttl
       };
-      await this.driver.put_leased_session(updatedSession);
+      this.driver.put_leased_session(updatedSession);
       this.sendToAll(
         {
           type: ServerMsgCode2.UPDATE_PRESENCE,
@@ -2754,13 +2755,12 @@ var Room = class {
   /**
    * List all server sessions. As a side effect, it will delete expired sessions.
    */
-  async listLeasedSessions(ctx, defer = () => {
+  listLeasedSessions(ctx, defer = () => {
     throw new Error(
       "One of your hook handlers returned a promise, but no side effect collector was provided. Pass a `defer` callback to listLeasedSessions() to collect async side effects."
     );
   }) {
-    await this.load(ctx);
-    const sessions = await this.driver.list_leased_sessions();
+    const sessions = this.driver.list_leased_sessions();
     const validSessions = [];
     const toDelete = [];
     for (const [_, session] of sessions) {
@@ -2771,14 +2771,14 @@ var Room = class {
       }
     }
     for (const session of toDelete) {
-      await this.deleteLeasedSession(session, ctx, defer);
+      this.deleteLeasedSession(session, ctx, defer);
     }
     return validSessions;
   }
   /**
    * Delete a server session and broadcast USER_LEFT to all sessions.
    */
-  async deleteLeasedSession(session, ctx, defer = () => {
+  deleteLeasedSession(session, ctx, defer = () => {
     throw new Error(
       "One of your hook handlers returned a promise, but no side effect collector was provided. Pass a `defer` callback to deleteLeasedSession() to collect async side effects."
     );
@@ -2791,20 +2791,19 @@ var Room = class {
       ctx,
       defer
     );
-    await this.driver.delete_leased_session(session.sessionId);
+    this.driver.delete_leased_session(session.sessionId);
   }
   /**
    * Delete all server sessions and broadcast USER_LEFT to all sessions.
    */
-  async deleteAllLeasedSessions(ctx, defer = () => {
+  deleteAllLeasedSessions(ctx, defer = () => {
     throw new Error(
       "One of your hook handlers returned a promise, but no side effect collector was provided. Pass a `defer` callback to deleteAllLeasedSessions() to collect async side effects."
     );
   }) {
-    await this.load(ctx);
-    const sessions = await this.driver.list_leased_sessions();
+    const sessions = this.driver.list_leased_sessions();
     for (const [_, session] of sessions) {
-      await this.deleteLeasedSession(session, ctx, defer);
+      this.deleteLeasedSession(session, ctx, defer);
     }
   }
   // ---------------------------------------------------------------------------
@@ -2813,53 +2812,53 @@ var Room = class {
   /**
    * List feeds with pagination and filtering.
    */
-  async listFeeds(options) {
-    return await this.driver.list_feeds(options);
+  listFeeds(options) {
+    return this.driver.list_feeds(options);
   }
   /**
    * Get a specific feed by feed ID.
    */
-  async getFeed(feedId) {
-    return await this.driver.get_feed(feedId);
+  getFeed(feedId) {
+    return this.driver.get_feed(feedId);
   }
   /**
    * Create a new feed.
    * If timestamp is not provided, current server time is used.
    */
-  async createFeed(feed) {
+  createFeed(feed) {
     const now = _nullishCoalesce(feed.timestamp, () => ( Date.now()));
     const fullFeed = {
       ...feed,
       createdAt: now,
       updatedAt: now
     };
-    await this.driver.create_feed(fullFeed);
+    this.driver.create_feed(fullFeed);
     return fullFeed;
   }
   /**
    * Update a feed's metadata.
    */
-  async updateFeedMetadata(feedId, metadata) {
-    await this.driver.update_feed_metadata(feedId, metadata);
+  updateFeedMetadata(feedId, metadata) {
+    this.driver.update_feed_metadata(feedId, metadata);
   }
   /**
    * Delete a feed.
    */
-  async deleteFeed(feedId) {
-    await this.driver.delete_feed(feedId);
+  deleteFeed(feedId) {
+    this.driver.delete_feed(feedId);
   }
   /**
    * List feed messages for a feed with pagination.
    */
-  async listFeedMessages(feedId, options) {
-    return await this.driver.list_feed_messages(feedId, options);
+  listFeedMessages(feedId, options) {
+    return this.driver.list_feed_messages(feedId, options);
   }
   /**
    * Add a message to a feed.
    * If message id is not provided, a unique ID is automatically generated.
    * If timestamp is not provided, current server time is used.
    */
-  async addFeedMessage(feedId, message) {
+  addFeedMessage(feedId, message) {
     const now = _nullishCoalesce(message.timestamp, () => ( Date.now()));
     const fullMessage = {
       id: _nullishCoalesce(message.id, () => ( _nanoid.nanoid.call(void 0, ))),
@@ -2867,15 +2866,15 @@ var Room = class {
       updatedAt: now,
       data: message.data
     };
-    await this.driver.add_feed_message(feedId, fullMessage);
+    this.driver.add_feed_message(feedId, fullMessage);
     return fullMessage;
   }
   /**
    * Update a feed message's data.
    * Returns the updated message.
    */
-  async updateFeedMessage(feedId, messageId, data, timestamp) {
-    return await this.driver.update_feed_message(
+  updateFeedMessage(feedId, messageId, data, timestamp) {
+    return this.driver.update_feed_message(
       feedId,
       messageId,
       data,
@@ -2885,8 +2884,8 @@ var Room = class {
   /**
    * Delete a feed message.
    */
-  async deleteFeedMessage(feedId, messageId) {
-    await this.driver.delete_feed_message(feedId, messageId);
+  deleteFeedMessage(feedId, messageId) {
+    this.driver.delete_feed_message(feedId, messageId);
   }
   /**
    * Will send the given ServerMsg through all Session, except the Session
@@ -2933,37 +2932,15 @@ var Room = class {
       }
     }
   }
-  // ------------------------------------------------------------------------------------
-  // Private APIs
-  // ------------------------------------------------------------------------------------
-  async _loadStorage() {
-    const storage = new Storage(this.driver);
-    await storage.load(this.logger);
-    return storage;
-  }
-  async _loadYjsStorage() {
-    const yjsStorage = new YjsStorage(this.driver);
-    await yjsStorage.load(this.logger);
-    return yjsStorage;
-  }
-  // Don't ever manually call this!
-  async _load(ctx) {
-    await _optionalChain([this, 'access', _107 => _107.hooks, 'access', _108 => _108.onRoomWillLoad, 'optionalCall', _109 => _109(ctx)]);
-    const storage = await this._loadStorage();
-    const yjsStorage = await this._loadYjsStorage();
-    this._data = {
-      mutex: new (0, _asyncmutex.Mutex)(),
-      storage,
-      yjsStorage
-    };
-    await _optionalChain([this, 'access', _110 => _110.hooks, 'access', _111 => _111.onRoomDidLoad, 'optionalCall', _112 => _112(ctx)]);
-  }
   /**
    * Returns a new, unique, actor ID.
    */
-  async getNextActor() {
-    return await this.driver.next_actor();
+  getNextActor() {
+    return this.driver.next_actor();
   }
+  // ------------------------------------------------------------------------------------
+  // Private APIs
+  // ------------------------------------------------------------------------------------
   /**
    * Iterates over all *other* Sessions and their session keys.
    */
@@ -2991,18 +2968,18 @@ var Room = class {
   async handlePing(sessionKey, ctx) {
     const session = this.sessions.get(sessionKey);
     if (session === void 0) {
-      this.logger.withContext({ sessionKey }).warn("[probe] in handlePing, no such session exists");
+      __privateGet(this, _logger).withContext({ sessionKey }).warn("[probe] in handlePing, no such session exists");
       return;
     }
     const sent = session.sendPong();
     if (sent !== 0) {
-      await _optionalChain([this, 'access', _113 => _113.hooks, 'access', _114 => _114.onDidPong, 'optionalCall', _115 => _115(ctx)]);
+      await _optionalChain([this, 'access', _98 => _98.hooks, 'access', _99 => _99.onDidPong, 'optionalCall', _100 => _100(ctx)]);
     }
   }
-  async _processClientMsg_withExclusiveAccess(sessionKey, messages, ctx, defer) {
+  _processClientMsg_withExclusiveAccess(sessionKey, messages, ctx, defer) {
     const session = this.sessions.get(sessionKey);
     if (!session) {
-      this.logger.withContext({ sessionKey }).warn("[probe] in handleClientMsgs, no such session exists");
+      __privateGet(this, _logger).withContext({ sessionKey }).warn("[probe] in handleClientMsgs, no such session exists");
       return;
     }
     const toFanOut = [];
@@ -3013,7 +2990,7 @@ var Room = class {
     for (const msg of messages) {
       const isMsgAllowed = this.hooks.isClientMsgAllowed(msg, session);
       if (isMsgAllowed.allowed) {
-        await this.handleOne(
+        this.handleOne(
           session,
           msg,
           replyImmediately,
@@ -3043,7 +3020,7 @@ var Room = class {
   // TODO It's a bit bothering how much duplication there is between this method
   // and the _processClientMsg_withExclusiveAccess version. A better
   // abstraction is needed.
-  async _processClientMsgFromBackendSession_withExclusiveAccess(session, messages, ctx, defer) {
+  _processClientMsgFromBackendSession_withExclusiveAccess(session, messages, ctx, defer) {
     const toFanOut = [];
     const toReplyImmediately = [];
     const toReplyAfter = [];
@@ -3065,7 +3042,7 @@ var Room = class {
     const scheduleFanOut = (msg) => void toFanOut.push(msg);
     const scheduleReply = (msg) => void toReplyAfter.push(msg);
     for (const msg of messages) {
-      await this.handleOne(
+      this.handleOne(
         session,
         msg,
         replyImmediately,
@@ -3088,7 +3065,7 @@ var Room = class {
       toReplyAfter.length = 0;
     }
   }
-  async handleOne(session, msg, replyImmediately, scheduleFanOut, scheduleReply, ctx, defer) {
+  handleOne(session, msg, replyImmediately, scheduleFanOut, scheduleReply, ctx, defer) {
     if (!this.mutex.isLocked()) {
       throw new Error("Handling messages requires exclusive access");
     }
@@ -3112,7 +3089,7 @@ var Room = class {
       }
       case _core.ClientMsgCode.FETCH_STORAGE: {
         if (session.version >= 8 /* V8 */) {
-          const rawStream = this.storage.loadedDriver.iter_nodes_optimized();
+          const rawStream = this.storage.driver.iter_nodes_optimized();
           for (const chunk of groupNodesForWebSocketMessages(rawStream)) {
             const frame = `{"type":${ServerMsgCode2.STORAGE_CHUNK},"nodes":[${chunk.join(",")}]}`;
             replyImmediately(frame);
@@ -3121,14 +3098,14 @@ var Room = class {
         } else {
           replyImmediately({
             type: ServerMsgCode2.STORAGE_STATE_V7,
-            items: Array.from(this.storage.loadedDriver.iter_nodes())
+            items: Array.from(this.storage.driver.iter_nodes())
           });
         }
         break;
       }
       case _core.ClientMsgCode.UPDATE_STORAGE: {
-        _optionalChain([this, 'access', _116 => _116.driver, 'access', _117 => _117.bump_storage_version, 'optionalCall', _118 => _118()]);
-        const result = await this.storage.applyOps(msg.ops);
+        _optionalChain([this, 'access', _101 => _101.driver, 'access', _102 => _102.bump_storage_version, 'optionalCall', _103 => _103()]);
+        const result = this.storage.applyOps(msg.ops);
         const opsToForward = result.flatMap(
           (r) => r.action === "accepted" ? [r.op] : []
         );
@@ -3160,7 +3137,7 @@ var Room = class {
           });
         }
         if (opsToForward.length > 0) {
-          const p$ = _optionalChain([this, 'access', _119 => _119.hooks, 'access', _120 => _120.postClientMsgStorageDidUpdate, 'optionalCall', _121 => _121(ctx)]);
+          const p$ = _optionalChain([this, 'access', _104 => _104.hooks, 'access', _105 => _105.postClientMsgStorageDidUpdate, 'optionalCall', _106 => _106(ctx)]);
           if (p$) defer(p$);
         }
         break;
@@ -3169,11 +3146,17 @@ var Room = class {
         const vector = msg.vector;
         const guid = msg.guid;
         const isV2 = msg.v2;
-        const [update, stateVector, snapshotHash] = await Promise.all([
-          this.yjsStorage.getYDocUpdate(this.logger, vector, guid, isV2),
-          this.yjsStorage.getYStateVector(this.logger, guid),
-          this.yjsStorage.getSnapshotHash(this.logger, { guid, isV2 })
-        ]);
+        const update = this.yjsStorage.getYDocUpdate(
+          __privateGet(this, _logger),
+          vector,
+          guid,
+          isV2
+        );
+        const stateVector = this.yjsStorage.getYStateVector(__privateGet(this, _logger), guid);
+        const snapshotHash = this.yjsStorage.getSnapshotHash(__privateGet(this, _logger), {
+          guid,
+          isV2
+        });
         if (update !== null && snapshotHash !== null) {
           replyImmediately({
             type: ServerMsgCode2.UPDATE_YDOC,
@@ -3192,8 +3175,8 @@ var Room = class {
         const update = msg.update;
         const guid = msg.guid;
         const isV2 = msg.v2;
-        const [result, error] = await tryCatch(
-          this.yjsStorage.addYDocUpdate(this.logger, update, guid, isV2)
+        const [result, error] = tryCatch(
+          () => this.yjsStorage.addYDocUpdate(__privateGet(this, _logger), update, guid, isV2)
         );
         if (error)
           break;
@@ -3211,7 +3194,7 @@ var Room = class {
           defer
         );
         if (result.isUpdated) {
-          const p$ = _optionalChain([this, 'access', _122 => _122.hooks, 'access', _123 => _123.postClientMsgYdocDidUpdate, 'optionalCall', _124 => _124(ctx, session)]);
+          const p$ = _optionalChain([this, 'access', _107 => _107.hooks, 'access', _108 => _108.postClientMsgYdocDidUpdate, 'optionalCall', _109 => _109(ctx, session)]);
           if (p$) defer(p$);
         }
         break;
@@ -3219,8 +3202,8 @@ var Room = class {
       // Feed messages
       case FeedMsgCode.FETCH_FEEDS: {
         const fetchMsg = msg;
-        const [result, err] = await tryCatch(
-          this.listFeeds({
+        const [result, err] = tryCatch(
+          () => this.listFeeds({
             cursor: fetchMsg.cursor,
             since: fetchMsg.since,
             limit: fetchMsg.limit,
@@ -3241,8 +3224,8 @@ var Room = class {
       }
       case FeedMsgCode.FETCH_FEED_MESSAGES: {
         const fetchMsg = msg;
-        const [result, err] = await tryCatch(
-          this.listFeedMessages(fetchMsg.feedId, {
+        const [result, err] = tryCatch(
+          () => this.listFeedMessages(fetchMsg.feedId, {
             cursor: fetchMsg.cursor,
             since: fetchMsg.since,
             limit: fetchMsg.limit
@@ -3263,8 +3246,8 @@ var Room = class {
       }
       case FeedMsgCode.ADD_FEED: {
         const addMsg = msg;
-        const [feed, err] = await tryCatch(
-          this.createFeed({
+        const [feed, err] = tryCatch(
+          () => this.createFeed({
             feedId: addMsg.feedId,
             metadata: _nullishCoalesce(addMsg.metadata, () => ( {}))
           })
@@ -3283,14 +3266,14 @@ var Room = class {
       }
       case FeedMsgCode.UPDATE_FEED: {
         const updateMsg = msg;
-        const [, metaErr] = await tryCatch(
-          this.updateFeedMetadata(updateMsg.feedId, updateMsg.metadata)
+        const [, metaErr] = tryCatch(
+          () => this.updateFeedMetadata(updateMsg.feedId, updateMsg.metadata)
         );
         if (metaErr) {
           replyImmediately(feedFailureServerMsg(updateMsg.requestId, metaErr));
           break;
         }
-        const feed = await this.getFeed(updateMsg.feedId);
+        const feed = this.getFeed(updateMsg.feedId);
         if (!feed) {
           replyImmediately(
             feedRequestFailed(
@@ -3310,7 +3293,7 @@ var Room = class {
       }
       case FeedMsgCode.DELETE_FEED: {
         const deleteMsg = msg;
-        const [, err] = await tryCatch(this.deleteFeed(deleteMsg.feedId));
+        const [, err] = tryCatch(() => this.deleteFeed(deleteMsg.feedId));
         if (err) {
           replyImmediately(feedFailureServerMsg(deleteMsg.requestId, err));
           break;
@@ -3325,8 +3308,8 @@ var Room = class {
       }
       case FeedMsgCode.ADD_FEED_MESSAGE: {
         const addMsg = msg;
-        const [message, err] = await tryCatch(
-          this.addFeedMessage(addMsg.feedId, {
+        const [message, err] = tryCatch(
+          () => this.addFeedMessage(addMsg.feedId, {
             data: addMsg.data,
             id: addMsg.id
           })
@@ -3346,8 +3329,8 @@ var Room = class {
       }
       case FeedMsgCode.UPDATE_FEED_MESSAGE: {
         const updateMsg = msg;
-        const [message, err] = await tryCatch(
-          this.updateFeedMessage(
+        const [message, err] = tryCatch(
+          () => this.updateFeedMessage(
             updateMsg.feedId,
             updateMsg.messageId,
             updateMsg.data
@@ -3368,8 +3351,8 @@ var Room = class {
       }
       case FeedMsgCode.DELETE_FEED_MESSAGE: {
         const deleteMsg = msg;
-        const [, err] = await tryCatch(
-          this.deleteFeedMessage(deleteMsg.feedId, deleteMsg.messageId)
+        const [, err] = tryCatch(
+          () => this.deleteFeedMessage(deleteMsg.feedId, deleteMsg.messageId)
         );
         if (err) {
           replyImmediately(feedFailureServerMsg(deleteMsg.requestId, err));
@@ -3393,6 +3376,7 @@ var Room = class {
     }
   }
 };
+_logger = new WeakMap();
 __debug2 = new WeakMap();