@liveblocks/server 1.1.1-pnpmtest1 → 1.2.1

package/dist/index.cjs

@@ -20,8 +20,131 @@ var _core = require('@liveblocks/core');
 
 
 
+
+
 var _decoders = require('decoders');
 
+// src/protocol/feedMessages.ts
+var FeedMsgCode = {
+  // Server → client (50x)
+  FEEDS_LIST: 500,
+  FEEDS_ADDED: 501,
+  FEEDS_UPDATED: 502,
+  FEED_DELETED: 503,
+  FEED_MESSAGES_LIST: 504,
+  FEED_MESSAGES_ADDED: 505,
+  FEED_MESSAGES_UPDATED: 506,
+  FEED_MESSAGES_DELETED: 507,
+  FEED_REQUEST_FAILED: 508,
+  // Client → server (51x)
+  FETCH_FEEDS: 510,
+  FETCH_FEED_MESSAGES: 511,
+  ADD_FEED: 512,
+  UPDATE_FEED: 513,
+  DELETE_FEED: 514,
+  ADD_FEED_MESSAGE: 515,
+  UPDATE_FEED_MESSAGE: 516,
+  DELETE_FEED_MESSAGE: 517
+};
+var FeedRequestErrorCode = {
+  INTERNAL: "INTERNAL",
+  FEED_ALREADY_EXISTS: "FEED_ALREADY_EXISTS",
+  FEED_NOT_FOUND: "FEED_NOT_FOUND",
+  FEED_MESSAGE_NOT_FOUND: "FEED_MESSAGE_NOT_FOUND"
+};
+
+// src/protocol/feedErrors.ts
+function feedRequestFailed(requestId, code, reason) {
+  return {
+    type: FeedMsgCode.FEED_REQUEST_FAILED,
+    requestId: _nullishCoalesce(requestId, () => ( "")),
+    code,
+    reason
+  };
+}
+function mapFeedError(err) {
+  if (!(err instanceof Error)) {
+    return { code: FeedRequestErrorCode.INTERNAL };
+  }
+  const m = err.message;
+  if (m.includes("already exists")) {
+    return { code: FeedRequestErrorCode.FEED_ALREADY_EXISTS, reason: m };
+  }
+  if (m.includes("Feed message") && m.includes("not found")) {
+    return { code: FeedRequestErrorCode.FEED_MESSAGE_NOT_FOUND, reason: m };
+  }
+  if (m.includes("not found")) {
+    return { code: FeedRequestErrorCode.FEED_NOT_FOUND, reason: m };
+  }
+  return { code: FeedRequestErrorCode.INTERNAL, reason: m };
+}
+function feedFailureServerMsg(requestId, err) {
+  const mapped = mapFeedError(err);
+  return feedRequestFailed(requestId, mapped.code, mapped.reason);
+}
+
+// src/protocol/ProtocolVersion.ts
+
+var ProtocolVersion = /* @__PURE__ */ ((ProtocolVersion2) => {
+  ProtocolVersion2[ProtocolVersion2["V7"] = 7] = "V7";
+  ProtocolVersion2[ProtocolVersion2["V8"] = 8] = "V8";
+  return ProtocolVersion2;
+})(ProtocolVersion || {});
+var protocolVersionDecoder = _decoders.enum_.call(void 0, ProtocolVersion).describe(
+  "Unsupported protocol version"
+);
+
+// src/decoders/feedMetadata.ts
+
+
+
+
+
+
+
+
+
+
+
+
+var MAX_METADATA_COUNT = 50;
+var MAX_METADATA_VALUE_LIST_LENGTH = 50;
+var feedMetadataIdDecoder = _decoders.sized.call(void 0, _decoders.identifier, { min: 1, max: 40 });
+var metadataStringValue = _decoders.sized.call(void 0, _decoders.string, { max: 256 });
+function createRoomMetadataValueDecoder() {
+  return _decoders.select.call(void 0, 
+    _decoders.either.call(void 0, _decoders.string, _decoders.poja).describe("Must be string or string[]"),
+    (x) => typeof x === "string" ? metadataStringValue : _decoders.array.call(void 0, metadataStringValue).refine(
+      (value) => value.length <= MAX_METADATA_VALUE_LIST_LENGTH,
+      `Must be at most ${MAX_METADATA_VALUE_LIST_LENGTH} items`
+    )
+  );
+}
+var roomMetadataValueDecoder = createRoomMetadataValueDecoder();
+var feedMetadataNullableValueDecoder = _decoders.nullable.call(void 0, roomMetadataValueDecoder);
+var feedMetadataRecordForCreate = _decoders.record.call(void 0, 
+  feedMetadataIdDecoder,
+  roomMetadataValueDecoder
+).refine(
+  (value) => Object.keys(value).length <= MAX_METADATA_COUNT,
+  `Must be at most ${MAX_METADATA_COUNT} items`
+);
+var optionalFeedMetadataDecoder = _decoders.optional.call(void 0, feedMetadataRecordForCreate);
+var feedMetadataUpdateDecoder = _decoders.record.call(void 0, 
+  feedMetadataIdDecoder,
+  feedMetadataNullableValueDecoder
+);
+var feedMetadataRecordForFilter = _decoders.record.call(void 0, 
+  feedMetadataIdDecoder,
+  feedMetadataNullableValueDecoder
+).refine(
+  (value) => Object.keys(value).length <= MAX_METADATA_COUNT,
+  `Must be at most ${MAX_METADATA_COUNT} items`
+);
+var fetchFeedsMetadataFilterDecoder = _decoders.optional.call(void 0, 
+  feedMetadataRecordForFilter
+);
+
 // src/decoders/jsonYolo.ts
 
 var jsonYolo = _decoders.unknown;
@@ -141,13 +264,77 @@ var updateYDocClientMsg = _decoders.object.call(void 0, {
   // Don't specify to update the root doc
   v2: _decoders.optional.call(void 0, _decoders.boolean)
 });
+var fetchFeedsClientMsg = _decoders.object.call(void 0, {
+  type: _decoders.constant.call(void 0, FeedMsgCode.FETCH_FEEDS),
+  requestId: _decoders.string,
+  cursor: _decoders.optional.call(void 0, _decoders.string),
+  since: _decoders.optional.call(void 0, _decoders.number),
+  limit: _decoders.optional.call(void 0, _decoders.number),
+  metadata: fetchFeedsMetadataFilterDecoder
+});
+var fetchFeedMessagesClientMsg = _decoders.object.call(void 0, {
+  type: _decoders.constant.call(void 0, FeedMsgCode.FETCH_FEED_MESSAGES),
+  requestId: _decoders.string,
+  feedId: _decoders.nonEmptyString,
+  cursor: _decoders.optional.call(void 0, _decoders.string),
+  since: _decoders.optional.call(void 0, _decoders.number),
+  limit: _decoders.optional.call(void 0, _decoders.number)
+});
+var addFeedClientMsg = _decoders.object.call(void 0, {
+  type: _decoders.constant.call(void 0, FeedMsgCode.ADD_FEED),
+  feedId: _decoders.string,
+  metadata: optionalFeedMetadataDecoder,
+  timestamp: _decoders.optional.call(void 0, _decoders.number),
+  requestId: _decoders.optional.call(void 0, _decoders.string)
+});
+var updateFeedClientMsg = _decoders.object.call(void 0, {
+  type: _decoders.constant.call(void 0, FeedMsgCode.UPDATE_FEED),
+  feedId: _decoders.string,
+  metadata: feedMetadataUpdateDecoder,
+  requestId: _decoders.optional.call(void 0, _decoders.string)
+});
+var deleteFeedClientMsg = _decoders.object.call(void 0, {
+  type: _decoders.constant.call(void 0, FeedMsgCode.DELETE_FEED),
+  feedId: _decoders.string,
+  requestId: _decoders.optional.call(void 0, _decoders.string)
+});
+var addFeedMessageClientMsg = _decoders.object.call(void 0, {
+  type: _decoders.constant.call(void 0, FeedMsgCode.ADD_FEED_MESSAGE),
+  feedId: _decoders.string,
+  data: _decoders.jsonObject,
+  id: _decoders.optional.call(void 0, _decoders.string),
+  timestamp: _decoders.optional.call(void 0, _decoders.number),
+  requestId: _decoders.optional.call(void 0, _decoders.string)
+});
+var updateFeedMessageClientMsg = _decoders.object.call(void 0, {
+  type: _decoders.constant.call(void 0, FeedMsgCode.UPDATE_FEED_MESSAGE),
+  feedId: _decoders.string,
+  messageId: _decoders.string,
+  data: _decoders.jsonObject,
+  timestamp: _decoders.optional.call(void 0, _decoders.number),
+  requestId: _decoders.optional.call(void 0, _decoders.string)
+});
+var deleteFeedMessageClientMsg = _decoders.object.call(void 0, {
+  type: _decoders.constant.call(void 0, FeedMsgCode.DELETE_FEED_MESSAGE),
+  feedId: _decoders.string,
+  messageId: _decoders.string,
+  requestId: _decoders.optional.call(void 0, _decoders.string)
+});
 var clientMsgDecoder = _decoders.taggedUnion.call(void 0, "type", {
   [_core.ClientMsgCode.UPDATE_PRESENCE]: updatePresenceClientMsg,
   [_core.ClientMsgCode.BROADCAST_EVENT]: broadcastEventClientMsg,
   [_core.ClientMsgCode.FETCH_STORAGE]: fetchStorageClientMsg,
   [_core.ClientMsgCode.UPDATE_STORAGE]: updateStorageClientMsg,
   [_core.ClientMsgCode.FETCH_YDOC]: fetchYDocClientMsg,
-  [_core.ClientMsgCode.UPDATE_YDOC]: updateYDocClientMsg
+  [_core.ClientMsgCode.UPDATE_YDOC]: updateYDocClientMsg,
+  [FeedMsgCode.FETCH_FEEDS]: fetchFeedsClientMsg,
+  [FeedMsgCode.FETCH_FEED_MESSAGES]: fetchFeedMessagesClientMsg,
+  [FeedMsgCode.ADD_FEED]: addFeedClientMsg,
+  [FeedMsgCode.UPDATE_FEED]: updateFeedClientMsg,
+  [FeedMsgCode.DELETE_FEED]: deleteFeedClientMsg,
+  [FeedMsgCode.ADD_FEED_MESSAGE]: addFeedMessageClientMsg,
+  [FeedMsgCode.UPDATE_FEED_MESSAGE]: updateFeedMessageClientMsg,
+  [FeedMsgCode.DELETE_FEED_MESSAGE]: deleteFeedMessageClientMsg
 }).describe("Must be a valid client message");
 var transientClientMsgDecoder = _decoders.taggedUnion.call(void 0, "type", {
   // [ClientMsgCode.UPDATE_PRESENCE]: updatePresenceClientMsg,
@@ -628,17 +815,6 @@ function makeMetadataDB(driver) {
   };
 }
 
-// src/protocol/ProtocolVersion.ts
-
-var ProtocolVersion = /* @__PURE__ */ ((ProtocolVersion2) => {
-  ProtocolVersion2[ProtocolVersion2["V7"] = 7] = "V7";
-  ProtocolVersion2[ProtocolVersion2["V8"] = 8] = "V8";
-  return ProtocolVersion2;
-})(ProtocolVersion || {});
-var protocolVersionDecoder = _decoders.enum_.call(void 0, ProtocolVersion).describe(
-  "Unsupported protocol version"
-);
-
 // src/Room.ts
 
 
@@ -845,16 +1021,21 @@ function hasStaticDataAt(node, key) {
   return node.type === _core.CrdtType.OBJECT && Object.prototype.hasOwnProperty.call(node.data, key) && node.data[key] !== void 0;
 }
 var InMemoryDriver = class {
+  // Key: `${feedId}:${messageId}`
   constructor(options) {
     __publicField(this, "_nextActor");
     __publicField(this, "_nodes");
     __publicField(this, "_metadb");
     __publicField(this, "_ydb");
     __publicField(this, "_leasedSessions");
+    __publicField(this, "_feeds");
+    __publicField(this, "_feedMessages");
     this._nodes = /* @__PURE__ */ new Map();
     this._metadb = /* @__PURE__ */ new Map();
     this._ydb = /* @__PURE__ */ new Map();
     this._leasedSessions = /* @__PURE__ */ new Map();
+    this._feeds = /* @__PURE__ */ new Map();
+    this._feedMessages = /* @__PURE__ */ new Map();
     this._nextActor = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _35 => _35.initialActor]), () => ( -1));
     for (const [key, value] of _nullishCoalesce(_optionalChain([options, 'optionalAccess', _36 => _36.initialNodes]), () => ( []))) {
       this._nodes.set(key, value);
@@ -894,6 +1075,180 @@ var InMemoryDriver = class {
   takeRowsWritten() {
     return 0;
   }
+  // ---------------------------------------------------------------------------
+  // Feed APIs
+  // ---------------------------------------------------------------------------
+  async 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]);
+    const metadata = _optionalChain([options, 'optionalAccess', _40 => _40.metadata]);
+    let feeds = [];
+    for (const [_, feed] of this._feeds.entries()) {
+      if (metadata !== void 0) {
+        const feedMetadata = feed.metadata;
+        let matches = true;
+        for (const [key, value] of Object.entries(metadata)) {
+          if (feedMetadata[key] !== value) {
+            matches = false;
+            break;
+          }
+        }
+        if (!matches) continue;
+      }
+      if (since !== void 0 && feed.createdAt < since) {
+        continue;
+      }
+      feeds.push(feed);
+    }
+    feeds.sort((a, b) => {
+      if (b.createdAt !== a.createdAt) {
+        return b.createdAt - a.createdAt;
+      }
+      return b.feedId.localeCompare(a.feedId);
+    });
+    if (cursor !== void 0) {
+      try {
+        const decoded = JSON.parse(
+          decodeURIComponent(
+            escape(atob(cursor.replace(/-/g, "+").replace(/_/g, "/")))
+          )
+        );
+        const [cursorFeedId, cursorCreatedAt] = decoded;
+        feeds = feeds.filter((s) => {
+          return s.createdAt < cursorCreatedAt || s.createdAt === cursorCreatedAt && s.feedId < cursorFeedId;
+        });
+      } catch (e2) {
+      }
+    }
+    let nextCursor;
+    if (feeds.length > limit) {
+      feeds = feeds.slice(0, limit);
+      const last = feeds[feeds.length - 1];
+      if (last) {
+        const cursorData = [last.feedId, last.createdAt];
+        nextCursor = btoa(
+          unescape(encodeURIComponent(JSON.stringify(cursorData)))
+        ).replace("/", "_").replace("+", "-").replace(/=+$/, "");
+      }
+    }
+    return { feeds, nextCursor };
+  }
+  async get_feed(feedId) {
+    const feed = this._feeds.get(feedId);
+    if (feed === void 0) {
+      return void 0;
+    }
+    return feed;
+  }
+  async create_feed(feed) {
+    if (this._feeds.has(feed.feedId)) {
+      throw new Error(`Feed ${feed.feedId} already exists`);
+    }
+    this._feeds.set(feed.feedId, {
+      feedId: feed.feedId,
+      metadata: feed.metadata,
+      createdAt: feed.createdAt,
+      updatedAt: feed.updatedAt
+    });
+  }
+  async update_feed_metadata(feedId, metadata) {
+    const existing = this._feeds.get(feedId);
+    if (existing === void 0) {
+      throw new Error(`Feed ${feedId} not found`);
+    }
+    this._feeds.set(feedId, {
+      ...existing,
+      metadata
+    });
+  }
+  async delete_feed(feedId) {
+    const messageKeys = [];
+    for (const [key] of this._feedMessages.entries()) {
+      if (key.startsWith(`${feedId}:`)) {
+        messageKeys.push(key);
+      }
+    }
+    for (const key of messageKeys) {
+      this._feedMessages.delete(key);
+    }
+    this._feeds.delete(feedId);
+  }
+  async 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]);
+    let messages = [];
+    const prefix = `${feedId}:`;
+    for (const [key, message] of this._feedMessages.entries()) {
+      if (key.startsWith(prefix)) {
+        if (since !== void 0 && message.createdAt < since) {
+          continue;
+        }
+        messages.push(message);
+      }
+    }
+    messages.sort((a, b) => {
+      if (b.createdAt !== a.createdAt) {
+        return b.createdAt - a.createdAt;
+      }
+      return b.id.localeCompare(a.id);
+    });
+    if (cursor !== void 0) {
+      try {
+        const decoded = JSON.parse(
+          decodeURIComponent(
+            escape(atob(cursor.replace(/-/g, "+").replace(/_/g, "/")))
+          )
+        );
+        const [cursorMessageId, cursorCreatedAt] = decoded;
+        messages = messages.filter((m) => {
+          return m.createdAt < cursorCreatedAt || m.createdAt === cursorCreatedAt && m.id < cursorMessageId;
+        });
+      } catch (e3) {
+      }
+    }
+    let nextCursor;
+    if (messages.length > limit) {
+      messages = messages.slice(0, limit);
+      const last = messages[messages.length - 1];
+      if (last) {
+        const cursorData = [last.id, last.createdAt];
+        nextCursor = btoa(
+          unescape(encodeURIComponent(JSON.stringify(cursorData)))
+        ).replace("/", "_").replace("+", "-").replace(/=+$/, "");
+      }
+    }
+    return { messages, nextCursor };
+  }
+  async 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) {
+    const key = `${feedId}:${messageId}`;
+    const message = this._feedMessages.get(key);
+    if (message === void 0) {
+      throw new Error(`Feed message ${messageId} not found in feed ${feedId}`);
+    }
+    const effectiveTimestamp = _nullishCoalesce(timestamp, () => ( Date.now()));
+    if (effectiveTimestamp < message.updatedAt) {
+      return message;
+    }
+    const updatedMessage = {
+      ...message,
+      updatedAt: effectiveTimestamp,
+      data
+    };
+    this._feedMessages.set(key, updatedMessage);
+    return updatedMessage;
+  }
+  async delete_feed_message(feedId, messageId) {
+    this._feedMessages.delete(`${feedId}:${messageId}`);
+  }
   next_actor() {
     return ++this._nextActor;
   }
@@ -958,7 +1313,7 @@ var InMemoryDriver = class {
     }
     async function move_sibling(id, newPos) {
       const node = nodes.get(id);
-      if (_optionalChain([node, 'optionalAccess', _37 => _37.parentId]) === void 0) {
+      if (_optionalChain([node, 'optionalAccess', _44 => _44.parentId]) === void 0) {
         return;
       }
       if (revNodes.has(node.parentId, newPos))
@@ -970,7 +1325,7 @@ var InMemoryDriver = class {
     }
     async function set_object_data(id, data, allowOverwrite = false) {
       const node = nodes.get(id);
-      if (_optionalChain([node, 'optionalAccess', _38 => _38.type]) !== _core.CrdtType.OBJECT) {
+      if (_optionalChain([node, 'optionalAccess', _45 => _45.type]) !== _core.CrdtType.OBJECT) {
         return;
       }
       for (const key of Object.keys(data)) {
@@ -987,7 +1342,7 @@ var InMemoryDriver = class {
     }
     function delete_node(id) {
       const node = nodes.get(id);
-      if (_optionalChain([node, 'optionalAccess', _39 => _39.parentId]) === void 0) {
+      if (_optionalChain([node, 'optionalAccess', _46 => _46.parentId]) === void 0) {
         return;
       }
       revNodes.delete(node.parentId, node.parentKey);
@@ -1256,7 +1611,7 @@ var Storage = class {
       }
       return accept(op2);
     } else if (intent === "set") {
-      const deletedId = op2.deletedId !== void 0 && op2.deletedId !== op2.id && _optionalChain([this, 'access', _40 => _40.loadedDriver, 'access', _41 => _41.get_node, 'call', _42 => _42(op2.deletedId), 'optionalAccess', _43 => _43.parentId]) === node.parentId ? op2.deletedId : void 0;
+      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;
       if (deletedId !== void 0) {
         await this.loadedDriver.delete_node(deletedId);
       }
@@ -1335,10 +1690,10 @@ var Storage = class {
    */
   async moveToPosInList(id, targetKey) {
     const node = this.loadedDriver.get_node(id);
-    if (_optionalChain([node, 'optionalAccess', _44 => _44.parentId]) === void 0) {
+    if (_optionalChain([node, 'optionalAccess', _51 => _51.parentId]) === void 0) {
       return;
     }
-    if (_optionalChain([this, 'access', _45 => _45.loadedDriver, 'access', _46 => _46.get_node, 'call', _47 => _47(node.parentId), 'optionalAccess', _48 => _48.type]) !== _core.CrdtType.LIST) {
+    if (_optionalChain([this, 'access', _52 => _52.loadedDriver, 'access', _53 => _53.get_node, 'call', _54 => _54(node.parentId), 'optionalAccess', _55 => _55.type]) !== _core.CrdtType.LIST) {
       return;
     }
     if (node.parentKey === targetKey) {
@@ -1448,7 +1803,7 @@ var YjsStorage = class {
     let encodedTargetVector;
     try {
       encodedTargetVector = stateVector.length > 0 ? _jsbase64.Base64.toUint8Array(stateVector) : void 0;
-    } catch (e) {
+    } catch (e4) {
       logger.warn(
         "Could not get update from passed vector, returning all updates"
       );
@@ -1673,13 +2028,14 @@ function isLeasedSessionExpired(leasedSession) {
 
 // src/Room.ts
 var messagesDecoder = _decoders.array.call(void 0, clientMsgDecoder);
+var ServerMsgCode2 = { ..._core.ServerMsgCode, ...FeedMsgCode };
 var HIGHEST_PROTOCOL_VERSION = Math.max(
   ...Object.values(ProtocolVersion).filter(
     (v) => typeof v === "number"
   )
 );
 var SERVER_MSG_CODE_NAMES = Object.fromEntries(
-  Object.entries(_core.ServerMsgCode).map(([k, v]) => [v, k])
+  Object.entries(ServerMsgCode2).map(([k, v]) => [v, k])
 );
 var BLACK_HOLE = new Logger([
   /* No targets, i.e. black hole logger */
@@ -1722,6 +2078,7 @@ var BrowserSession = class {
     // Metadata sent to client in ROOM_STATE message's "meta" field
     __privateAdd(this, __socket);
     __privateAdd(this, __debug);
+    /** Updated on every incoming message (including pings) via handleData(). Used for idle timeout detection. */
     __privateAdd(this, __lastActiveAt);
     // We keep a status in-memory in the session of whether we already sent a rejected ops message to the client.
     __privateAdd(this, __hasNotifiedClientStorageUpdateError);
@@ -1733,15 +2090,15 @@ var BrowserSession = class {
     this.publicMeta = ticket.publicMeta;
     __privateSet(this, __socket, socket);
     __privateSet(this, __debug, debug);
-    const now = _nullishCoalesce(createdAt, () => ( /* @__PURE__ */ new Date()));
+    const now = _nullishCoalesce(_optionalChain([createdAt, 'optionalAccess', _56 => _56.getTime, 'call', _57 => _57()]), () => ( Date.now()));
     this.createdAt = now;
     __privateSet(this, __lastActiveAt, now);
     __privateSet(this, __hasNotifiedClientStorageUpdateError, false);
   }
   get lastActiveAt() {
-    const lastPing = _optionalChain([__privateGet, 'call', _49 => _49(this, __socket), 'access', _50 => _50.getLastPongTimestamp, 'optionalCall', _51 => _51()]);
-    if (lastPing && lastPing > __privateGet(this, __lastActiveAt)) {
-      return lastPing;
+    const lastPing = _optionalChain([__privateGet, 'call', _58 => _58(this, __socket), 'access', _59 => _59.getLastPongTimestamp, 'optionalCall', _60 => _60()]);
+    if (lastPing && lastPing.getTime() > __privateGet(this, __lastActiveAt)) {
+      return lastPing.getTime();
     } else {
       return __privateGet(this, __lastActiveAt);
     }
@@ -1749,10 +2106,9 @@ var BrowserSession = class {
   get hasNotifiedClientStorageUpdateError() {
     return __privateGet(this, __hasNotifiedClientStorageUpdateError);
   }
-  markActive(now = /* @__PURE__ */ new Date()) {
-    if (now > __privateGet(this, __lastActiveAt)) {
-      __privateSet(this, __lastActiveAt, now);
-    }
+  /** @internal - This should have to be called only from Room, never externally */
+  markActive(now) {
+    __privateSet(this, __lastActiveAt, now ? now.getTime() : Date.now());
   }
   setHasNotifiedClientStorageUpdateError() {
     __privateSet(this, __hasNotifiedClientStorageUpdateError, true);
@@ -1824,6 +2180,15 @@ var Room = class {
     __publicField(this, "meta");
     __publicField(this, "driver");
     __publicField(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.
+     * Maintenance mode should only last a couple of milliseconds, typically.
+     *
+     * This mutex ensures that concurrent destructive operations (like
+     * 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, "_qsize", 0);
@@ -1831,28 +2196,28 @@ var Room = class {
     __publicField(this, "hooks");
     __privateAdd(this, __debug2);
     __privateAdd(this, __allowStreaming);
-    const driver = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _52 => _52.storage]), () => ( makeNewInMemoryDriver()));
+    const driver = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _61 => _61.storage]), () => ( makeNewInMemoryDriver()));
     this.meta = meta;
     this.driver = driver;
-    this.logger = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _53 => _53.logger]), () => ( BLACK_HOLE));
-    __privateSet(this, __allowStreaming, _nullishCoalesce(_optionalChain([options, 'optionalAccess', _54 => _54.allowStreaming]), () => ( true)));
+    this.logger = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _62 => _62.logger]), () => ( BLACK_HOLE));
+    __privateSet(this, __allowStreaming, _nullishCoalesce(_optionalChain([options, 'optionalAccess', _63 => _63.allowStreaming]), () => ( true)));
     this.hooks = {
-      isClientMsgAllowed: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _55 => _55.hooks, 'optionalAccess', _56 => _56.isClientMsgAllowed]), () => ( (() => {
+      isClientMsgAllowed: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _64 => _64.hooks, 'optionalAccess', _65 => _65.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', _57 => _57.hooks, 'optionalAccess', _58 => _58.onRoomWillLoad]),
-      onRoomDidLoad: _optionalChain([options, 'optionalAccess', _59 => _59.hooks, 'optionalAccess', _60 => _60.onRoomDidLoad]),
-      onRoomWillUnload: _optionalChain([options, 'optionalAccess', _61 => _61.hooks, 'optionalAccess', _62 => _62.onRoomWillUnload]),
-      onRoomDidUnload: _optionalChain([options, 'optionalAccess', _63 => _63.hooks, 'optionalAccess', _64 => _64.onRoomDidUnload]),
-      onSessionDidStart: _optionalChain([options, 'optionalAccess', _65 => _65.hooks, 'optionalAccess', _66 => _66.onSessionDidStart]),
-      onSessionDidEnd: _optionalChain([options, 'optionalAccess', _67 => _67.hooks, 'optionalAccess', _68 => _68.onSessionDidEnd]),
-      postClientMsgStorageDidUpdate: _optionalChain([options, 'optionalAccess', _69 => _69.hooks, 'optionalAccess', _70 => _70.postClientMsgStorageDidUpdate]),
-      postClientMsgYdocDidUpdate: _optionalChain([options, 'optionalAccess', _71 => _71.hooks, 'optionalAccess', _72 => _72.postClientMsgYdocDidUpdate])
+      onRoomWillLoad: _optionalChain([options, 'optionalAccess', _66 => _66.hooks, 'optionalAccess', _67 => _67.onRoomWillLoad]),
+      onRoomDidLoad: _optionalChain([options, 'optionalAccess', _68 => _68.hooks, 'optionalAccess', _69 => _69.onRoomDidLoad]),
+      onRoomWillUnload: _optionalChain([options, 'optionalAccess', _70 => _70.hooks, 'optionalAccess', _71 => _71.onRoomWillUnload]),
+      onRoomDidUnload: _optionalChain([options, 'optionalAccess', _72 => _72.hooks, 'optionalAccess', _73 => _73.onRoomDidUnload]),
+      onSessionDidStart: _optionalChain([options, 'optionalAccess', _74 => _74.hooks, 'optionalAccess', _75 => _75.onSessionDidStart]),
+      onSessionDidEnd: _optionalChain([options, 'optionalAccess', _76 => _76.hooks, 'optionalAccess', _77 => _77.onSessionDidEnd]),
+      postClientMsgStorageDidUpdate: _optionalChain([options, 'optionalAccess', _78 => _78.hooks, 'optionalAccess', _79 => _79.postClientMsgStorageDidUpdate]),
+      postClientMsgYdocDidUpdate: _optionalChain([options, 'optionalAccess', _80 => _80.hooks, 'optionalAccess', _81 => _81.postClientMsgYdocDidUpdate])
     };
-    __privateSet(this, __debug2, _nullishCoalesce(_optionalChain([options, 'optionalAccess', _73 => _73.enableDebugLogging]), () => ( false)));
+    __privateSet(this, __debug2, _nullishCoalesce(_optionalChain([options, 'optionalAccess', _82 => _82.enableDebugLogging]), () => ( false)));
   }
   get loadingState() {
     if (this._loadData$ === null) {
@@ -1884,6 +2249,24 @@ var Room = class {
   }
   // prettier-ignore
   // ------------------------------------------------------------------------------------
+  // Maintenance mode
+  // ------------------------------------------------------------------------------------
+  /**
+   * Returns true if the room is currently in maintenance mode.
+   * When in maintenance mode, callers should refuse new WebSocket connections.
+   */
+  get isInMaintenance() {
+    return this._maintenanceMode.isLocked();
+  }
+  /**
+   * Tries to enter maintenance mode and run the given callback exclusively.
+   * If the room is already in maintenance mode, throws E_ALREADY_LOCKED
+   * immediately instead of queuing the request.
+   */
+  async runInMaintenanceMode(callback) {
+    return _asyncmutex.tryAcquire.call(void 0, this._maintenanceMode).runExclusive(callback);
+  }
+  // ------------------------------------------------------------------------------------
   // Public API
   // ------------------------------------------------------------------------------------
   /**
@@ -1908,13 +2291,13 @@ var Room = class {
    * room will be reloaded from storage.
    */
   unload(ctx) {
-    _optionalChain([this, 'access', _74 => _74.hooks, 'access', _75 => _75.onRoomWillUnload, 'optionalCall', _76 => _76(ctx)]);
+    _optionalChain([this, 'access', _83 => _83.hooks, 'access', _84 => _84.onRoomWillUnload, 'optionalCall', _85 => _85(ctx)]);
     if (this._data) {
       this.storage.unload();
       this.yjsStorage.unload();
     }
     this._loadData$ = null;
-    _optionalChain([this, 'access', _77 => _77.hooks, 'access', _78 => _78.onRoomDidUnload, 'optionalCall', _79 => _79(ctx)]);
+    _optionalChain([this, 'access', _86 => _86.hooks, 'access', _87 => _87.onRoomDidUnload, 'optionalCall', _88 => _88(ctx)]);
   }
   /**
    * Issues a Ticket with a new/unique actor ID
@@ -1928,17 +2311,17 @@ var Room = class {
    * unused Ticket will simply get garbage collected.
    */
   async createTicket(options) {
-    const actor$ = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _80 => _80.actor]), () => ( this.getNextActor()));
+    const actor$ = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _89 => _89.actor]), () => ( this.getNextActor()));
     const sessionKey = _nanoid.nanoid.call(void 0, );
-    const info = _optionalChain([options, 'optionalAccess', _81 => _81.info]);
+    const info = _optionalChain([options, 'optionalAccess', _90 => _90.info]);
     const ticket = {
-      version: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _82 => _82.version]), () => ( HIGHEST_PROTOCOL_VERSION)),
+      version: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _91 => _91.version]), () => ( HIGHEST_PROTOCOL_VERSION)),
       actor: await actor$,
       sessionKey,
-      meta: _optionalChain([options, 'optionalAccess', _83 => _83.meta]),
-      publicMeta: _optionalChain([options, 'optionalAccess', _84 => _84.publicMeta]),
-      user: _optionalChain([options, 'optionalAccess', _85 => _85.id]) ? { id: options.id, info } : { anonymousId: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _86 => _86.anonymousId]), () => ( _nanoid.nanoid.call(void 0, ))), info },
-      scopes: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _87 => _87.scopes]), () => ( ["room:write"]))
+      meta: _optionalChain([options, 'optionalAccess', _92 => _92.meta]),
+      publicMeta: _optionalChain([options, 'optionalAccess', _93 => _93.publicMeta]),
+      user: _optionalChain([options, 'optionalAccess', _94 => _94.id]) ? { id: options.id, info } : { anonymousId: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _95 => _95.anonymousId]), () => ( _nanoid.nanoid.call(void 0, ))), info },
+      scopes: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _96 => _96.scopes]), () => ( ["room:write"]))
     };
     if (__privateGet(this, __debug2)) {
       console.log(`new ticket created: ${JSON.stringify(ticket)}`);
@@ -2023,7 +2406,7 @@ var Room = class {
     );
     for (const leasedSession of leasedSessions) {
       newSession.send({
-        type: _core.ServerMsgCode.UPDATE_PRESENCE,
+        type: ServerMsgCode2.UPDATE_PRESENCE,
         actor: leasedSession.actorId,
         targetActor: newSession.actor,
         // full presence to new user
@@ -2063,7 +2446,7 @@ var Room = class {
     this.sendToOthers(
       ticket.sessionKey,
       {
-        type: _core.ServerMsgCode.USER_JOINED,
+        type: ServerMsgCode2.USER_JOINED,
         actor: newSession.actor,
         id: newSession.user.id,
         info: newSession.user.info,
@@ -2072,7 +2455,7 @@ var Room = class {
       ctx,
       defer
     );
-    const p$ = _optionalChain([this, 'access', _88 => _88.hooks, 'access', _89 => _89.onSessionDidStart, 'optionalCall', _90 => _90(newSession, ctx)]);
+    const p$ = _optionalChain([this, 'access', _97 => _97.hooks, 'access', _98 => _98.onSessionDidStart, 'optionalCall', _99 => _99(newSession, ctx)]);
     if (p$) defer(p$);
   }
   /**
@@ -2094,9 +2477,9 @@ var Room = class {
     const deleted = sessions.delete(key);
     if (deleted) {
       for (const other of this.otherSessions(key)) {
-        other.send({ type: _core.ServerMsgCode.USER_LEFT, actor: session.actor });
+        other.send({ type: ServerMsgCode2.USER_LEFT, actor: session.actor });
       }
-      const p$ = _optionalChain([this, 'access', _91 => _91.hooks, 'access', _92 => _92.onSessionDidEnd, 'optionalCall', _93 => _93(session, ctx)]);
+      const p$ = _optionalChain([this, 'access', _100 => _100.hooks, 'access', _101 => _101.onSessionDidEnd, 'optionalCall', _102 => _102(session, ctx)]);
       if (p$) defer(p$);
     }
   }
@@ -2127,6 +2510,7 @@ var Room = class {
     );
   }) {
     const text = typeof data === "string" ? data : _core.raise.call(void 0, "Unsupported message format");
+    _optionalChain([this, 'access', _103 => _103.sessions, 'access', _104 => _104.get, 'call', _105 => _105(key), 'optionalAccess', _106 => _106.markActive, 'call', _107 => _107()]);
     if (text === "ping") {
       await this.handlePing(key, ctx);
     } else {
@@ -2239,7 +2623,7 @@ var Room = class {
       await this.driver.put_leased_session(session);
       this.sendToAll(
         {
-          type: _core.ServerMsgCode.USER_JOINED,
+          type: ServerMsgCode2.USER_JOINED,
           actor: actorId,
           id: sessionId,
           info,
@@ -2250,7 +2634,7 @@ var Room = class {
       );
       this.sendToAll(
         {
-          type: _core.ServerMsgCode.UPDATE_PRESENCE,
+          type: ServerMsgCode2.UPDATE_PRESENCE,
           actor: actorId,
           data: presence,
           targetActor: 1
@@ -2273,7 +2657,7 @@ var Room = class {
       await this.driver.put_leased_session(updatedSession);
       this.sendToAll(
         {
-          type: _core.ServerMsgCode.UPDATE_PRESENCE,
+          type: ServerMsgCode2.UPDATE_PRESENCE,
           actor: existingSession.actorId,
           data: presence
           // Send only the patch, not the full merged presence
@@ -2318,7 +2702,7 @@ var Room = class {
   }) {
     this.sendToAll(
       {
-        type: _core.ServerMsgCode.USER_LEFT,
+        type: ServerMsgCode2.USER_LEFT,
         actor: session.actorId
       },
       ctx,
@@ -2340,6 +2724,87 @@ var Room = class {
       await this.deleteLeasedSession(session, ctx, defer);
     }
   }
+  // ---------------------------------------------------------------------------
+  // Feed APIs
+  // ---------------------------------------------------------------------------
+  /**
+   * List feeds with pagination and filtering.
+   */
+  async listFeeds(options) {
+    return await this.driver.list_feeds(options);
+  }
+  /**
+   * Get a specific feed by feed ID.
+   */
+  async getFeed(feedId) {
+    return await this.driver.get_feed(feedId);
+  }
+  /**
+   * Create a new feed.
+   * If timestamp is not provided, current server time is used.
+   */
+  async createFeed(feed) {
+    const now = _nullishCoalesce(feed.timestamp, () => ( Date.now()));
+    const fullFeed = {
+      ...feed,
+      createdAt: now,
+      updatedAt: now
+    };
+    await this.driver.create_feed(fullFeed);
+    return fullFeed;
+  }
+  /**
+   * Update a feed's metadata.
+   */
+  async updateFeedMetadata(feedId, metadata) {
+    await this.driver.update_feed_metadata(feedId, metadata);
+  }
+  /**
+   * Delete a feed.
+   */
+  async deleteFeed(feedId) {
+    await 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);
+  }
+  /**
+   * 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) {
+    const now = _nullishCoalesce(message.timestamp, () => ( Date.now()));
+    const fullMessage = {
+      id: _nullishCoalesce(message.id, () => ( _nanoid.nanoid.call(void 0, ))),
+      createdAt: now,
+      updatedAt: now,
+      data: message.data
+    };
+    await 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(
+      feedId,
+      messageId,
+      data,
+      _nullishCoalesce(timestamp, () => ( Date.now()))
+    );
+  }
+  /**
+   * Delete a feed message.
+   */
+  async deleteFeedMessage(feedId, messageId) {
+    await this.driver.delete_feed_message(feedId, messageId);
+  }
   /**
    * Will send the given ServerMsg through all Session, except the Session
    * where the message originates from.
@@ -2400,7 +2865,7 @@ var Room = class {
   }
   // Don't ever manually call this!
   async _load(ctx) {
-    await _optionalChain([this, 'access', _94 => _94.hooks, 'access', _95 => _95.onRoomWillLoad, 'optionalCall', _96 => _96(ctx)]);
+    await _optionalChain([this, 'access', _108 => _108.hooks, 'access', _109 => _109.onRoomWillLoad, 'optionalCall', _110 => _110(ctx)]);
     const storage = await this._loadStorage();
     const yjsStorage = await this._loadYjsStorage();
     this._data = {
@@ -2408,7 +2873,7 @@ var Room = class {
       storage,
       yjsStorage
     };
-    await _optionalChain([this, 'access', _97 => _97.hooks, 'access', _98 => _98.onRoomDidLoad, 'optionalCall', _99 => _99(ctx)]);
+    await _optionalChain([this, 'access', _111 => _111.hooks, 'access', _112 => _112.onRoomDidLoad, 'optionalCall', _113 => _113(ctx)]);
   }
   /**
    * Returns a new, unique, actor ID.
@@ -2449,7 +2914,7 @@ var Room = class {
     }
     const sent = session.sendPong();
     if (sent !== 0) {
-      await _optionalChain([this, 'access', _100 => _100.hooks, 'access', _101 => _101.onDidPong, 'optionalCall', _102 => _102(ctx)]);
+      await _optionalChain([this, 'access', _114 => _114.hooks, 'access', _115 => _115.onDidPong, 'optionalCall', _116 => _116(ctx)]);
     }
   }
   async _processClientMsg_withExclusiveAccess(sessionKey, messages, ctx, defer) {
@@ -2478,7 +2943,7 @@ var Room = class {
       } else {
         if (!session.hasNotifiedClientStorageUpdateError) {
           toReply.push({
-            type: _core.ServerMsgCode.REJECT_STORAGE_OP,
+            type: ServerMsgCode2.REJECT_STORAGE_OP,
             opIds: msg.type === _core.ClientMsgCode.UPDATE_STORAGE ? msg.ops.map((op2) => op2.opId) : [],
             reason: isMsgAllowed.reason
           });
@@ -2542,7 +3007,7 @@ var Room = class {
     switch (msg.type) {
       case _core.ClientMsgCode.UPDATE_PRESENCE: {
         scheduleFanOut({
-          type: _core.ServerMsgCode.UPDATE_PRESENCE,
+          type: ServerMsgCode2.UPDATE_PRESENCE,
           actor: session.actor,
           data: msg.data,
           targetActor: msg.targetActor
@@ -2551,7 +3016,7 @@ var Room = class {
       }
       case _core.ClientMsgCode.BROADCAST_EVENT: {
         scheduleFanOut({
-          type: _core.ServerMsgCode.BROADCASTED_EVENT,
+          type: ServerMsgCode2.BROADCASTED_EVENT,
           actor: session.actor,
           event: msg.event
         });
@@ -2566,29 +3031,29 @@ var Room = class {
               NODES_PER_CHUNK
             )) {
               replyImmediately({
-                type: _core.ServerMsgCode.STORAGE_CHUNK,
+                type: ServerMsgCode2.STORAGE_CHUNK,
                 nodes: chunk
               });
             }
           } else {
             replyImmediately({
-              type: _core.ServerMsgCode.STORAGE_CHUNK,
+              type: ServerMsgCode2.STORAGE_CHUNK,
               nodes: Array.from(
                 _core.nodeStreamToCompactNodes.call(void 0, this.storage.loadedDriver.iter_nodes())
               )
             });
           }
-          replyImmediately({ type: _core.ServerMsgCode.STORAGE_STREAM_END });
+          replyImmediately({ type: ServerMsgCode2.STORAGE_STREAM_END });
         } else {
           replyImmediately({
-            type: _core.ServerMsgCode.STORAGE_STATE_V7,
+            type: ServerMsgCode2.STORAGE_STATE_V7,
             items: Array.from(this.storage.loadedDriver.iter_nodes())
           });
         }
         break;
       }
       case _core.ClientMsgCode.UPDATE_STORAGE: {
-        _optionalChain([this, 'access', _103 => _103.driver, 'access', _104 => _104.bump_storage_version, 'optionalCall', _105 => _105()]);
+        _optionalChain([this, 'access', _117 => _117.driver, 'access', _118 => _118.bump_storage_version, 'optionalCall', _119 => _119()]);
         const result = await this.storage.applyOps(msg.ops);
         const opsToForward = result.flatMap(
           (r) => r.action === "accepted" ? [r.op] : []
@@ -2605,22 +3070,22 @@ var Room = class {
         });
         if (opsToForward.length > 0) {
           scheduleFanOut({
-            type: _core.ServerMsgCode.UPDATE_STORAGE,
+            type: ServerMsgCode2.UPDATE_STORAGE,
             ops: opsToForward.map(stripOpId)
           });
           scheduleReply({
-            type: _core.ServerMsgCode.UPDATE_STORAGE,
+            type: ServerMsgCode2.UPDATE_STORAGE,
             ops: opsToForward
           });
         }
         if (opsToSendBack.length > 0) {
           replyImmediately({
-            type: _core.ServerMsgCode.UPDATE_STORAGE,
+            type: ServerMsgCode2.UPDATE_STORAGE,
             ops: opsToSendBack
           });
         }
         if (opsToForward.length > 0) {
-          const p$ = _optionalChain([this, 'access', _106 => _106.hooks, 'access', _107 => _107.postClientMsgStorageDidUpdate, 'optionalCall', _108 => _108(ctx)]);
+          const p$ = _optionalChain([this, 'access', _120 => _120.hooks, 'access', _121 => _121.postClientMsgStorageDidUpdate, 'optionalCall', _122 => _122(ctx)]);
           if (p$) defer(p$);
         }
         break;
@@ -2636,7 +3101,7 @@ var Room = class {
         ]);
         if (update !== null && snapshotHash !== null) {
           replyImmediately({
-            type: _core.ServerMsgCode.UPDATE_YDOC,
+            type: ServerMsgCode2.UPDATE_YDOC,
             update,
             isSync: true,
             // this is no longer used by the client, instead we use the presence of stateVector
@@ -2659,7 +3124,7 @@ var Room = class {
           break;
         this.sendToAll(
           {
-            type: _core.ServerMsgCode.UPDATE_YDOC,
+            type: ServerMsgCode2.UPDATE_YDOC,
             update,
             guid,
             isSync: false,
@@ -2671,15 +3136,185 @@ var Room = class {
           defer
         );
         if (result.isUpdated) {
-          const p$ = _optionalChain([this, 'access', _109 => _109.hooks, 'access', _110 => _110.postClientMsgYdocDidUpdate, 'optionalCall', _111 => _111(ctx, session)]);
+          const p$ = _optionalChain([this, 'access', _123 => _123.hooks, 'access', _124 => _124.postClientMsgYdocDidUpdate, 'optionalCall', _125 => _125(ctx, session)]);
           if (p$) defer(p$);
         }
         break;
       }
+      case FeedMsgCode.FETCH_FEEDS: {
+        const fetchMsg = msg;
+        const [result, err] = await tryCatch(
+          this.listFeeds({
+            cursor: fetchMsg.cursor,
+            since: fetchMsg.since,
+            limit: fetchMsg.limit,
+            metadata: fetchMsg.metadata
+          })
+        );
+        if (err) {
+          replyImmediately(feedFailureServerMsg(fetchMsg.requestId, err));
+          break;
+        }
+        replyImmediately({
+          type: FeedMsgCode.FEEDS_LIST,
+          requestId: fetchMsg.requestId,
+          feeds: result.feeds,
+          nextCursor: result.nextCursor
+        });
+        break;
+      }
+      case FeedMsgCode.FETCH_FEED_MESSAGES: {
+        const fetchMsg = msg;
+        const [result, err] = await tryCatch(
+          this.listFeedMessages(fetchMsg.feedId, {
+            cursor: fetchMsg.cursor,
+            since: fetchMsg.since,
+            limit: fetchMsg.limit
+          })
+        );
+        if (err) {
+          replyImmediately(feedFailureServerMsg(fetchMsg.requestId, err));
+          break;
+        }
+        replyImmediately({
+          type: FeedMsgCode.FEED_MESSAGES_LIST,
+          requestId: fetchMsg.requestId,
+          feedId: fetchMsg.feedId,
+          messages: result.messages,
+          nextCursor: result.nextCursor
+        });
+        break;
+      }
+      case FeedMsgCode.ADD_FEED: {
+        const addMsg = msg;
+        const [feed, err] = await tryCatch(
+          this.createFeed({
+            feedId: addMsg.feedId,
+            metadata: _nullishCoalesce(addMsg.metadata, () => ( {})),
+            timestamp: addMsg.timestamp
+          })
+        );
+        if (err) {
+          replyImmediately(feedFailureServerMsg(addMsg.requestId, err));
+          break;
+        }
+        const feedsMsg = {
+          type: FeedMsgCode.FEEDS_ADDED,
+          feeds: [feed]
+        };
+        replyImmediately(feedsMsg);
+        scheduleFanOut(feedsMsg);
+        break;
+      }
+      case FeedMsgCode.UPDATE_FEED: {
+        const updateMsg = msg;
+        const [, metaErr] = await tryCatch(
+          this.updateFeedMetadata(updateMsg.feedId, updateMsg.metadata)
+        );
+        if (metaErr) {
+          replyImmediately(feedFailureServerMsg(updateMsg.requestId, metaErr));
+          break;
+        }
+        const feed = await this.getFeed(updateMsg.feedId);
+        if (!feed) {
+          replyImmediately(
+            feedRequestFailed(
+              updateMsg.requestId,
+              FeedRequestErrorCode.FEED_NOT_FOUND
+            )
+          );
+          break;
+        }
+        const feedsMsg = {
+          type: FeedMsgCode.FEEDS_UPDATED,
+          feeds: [feed]
+        };
+        replyImmediately(feedsMsg);
+        scheduleFanOut(feedsMsg);
+        break;
+      }
+      case FeedMsgCode.DELETE_FEED: {
+        const deleteMsg = msg;
+        const [, err] = await tryCatch(this.deleteFeed(deleteMsg.feedId));
+        if (err) {
+          replyImmediately(feedFailureServerMsg(deleteMsg.requestId, err));
+          break;
+        }
+        const feedDeletedMsg = {
+          type: FeedMsgCode.FEED_DELETED,
+          feedId: deleteMsg.feedId
+        };
+        replyImmediately(feedDeletedMsg);
+        scheduleFanOut(feedDeletedMsg);
+        break;
+      }
+      case FeedMsgCode.ADD_FEED_MESSAGE: {
+        const addMsg = msg;
+        const [message, err] = await tryCatch(
+          this.addFeedMessage(addMsg.feedId, {
+            data: addMsg.data,
+            id: addMsg.id,
+            timestamp: addMsg.timestamp
+          })
+        );
+        if (err) {
+          replyImmediately(feedFailureServerMsg(addMsg.requestId, err));
+          break;
+        }
+        const feedMessagesMsg = {
+          type: FeedMsgCode.FEED_MESSAGES_ADDED,
+          feedId: addMsg.feedId,
+          messages: [message]
+        };
+        replyImmediately(feedMessagesMsg);
+        scheduleFanOut(feedMessagesMsg);
+        break;
+      }
+      case FeedMsgCode.UPDATE_FEED_MESSAGE: {
+        const updateMsg = msg;
+        const [message, err] = await tryCatch(
+          this.updateFeedMessage(
+            updateMsg.feedId,
+            updateMsg.messageId,
+            updateMsg.data,
+            updateMsg.timestamp
+          )
+        );
+        if (err) {
+          replyImmediately(feedFailureServerMsg(updateMsg.requestId, err));
+          break;
+        }
+        const feedMessagesMsg = {
+          type: FeedMsgCode.FEED_MESSAGES_UPDATED,
+          feedId: updateMsg.feedId,
+          messages: [message]
+        };
+        replyImmediately(feedMessagesMsg);
+        scheduleFanOut(feedMessagesMsg);
+        break;
+      }
+      case FeedMsgCode.DELETE_FEED_MESSAGE: {
+        const deleteMsg = msg;
+        const [, err] = await tryCatch(
+          this.deleteFeedMessage(deleteMsg.feedId, deleteMsg.messageId)
+        );
+        if (err) {
+          replyImmediately(feedFailureServerMsg(deleteMsg.requestId, err));
+          break;
+        }
+        const feedMessagesMsg = {
+          type: FeedMsgCode.FEED_MESSAGES_DELETED,
+          feedId: deleteMsg.feedId,
+          messageIds: [deleteMsg.messageId]
+        };
+        replyImmediately(feedMessagesMsg);
+        scheduleFanOut(feedMessagesMsg);
+        break;
+      }
       default: {
         try {
           return _core.assertNever.call(void 0, msg, "Unrecognized client msg");
-        } catch (e2) {
+        } catch (e5) {
         }
       }
     }
@@ -2723,5 +3358,14 @@ __allowStreaming = new WeakMap();
 
 
 
-exports.BackendSession = BackendSession; exports.BrowserSession = BrowserSession; exports.ConsoleTarget = ConsoleTarget; exports.DefaultMap = DefaultMap; exports.InMemoryDriver = InMemoryDriver; exports.LogLevel = LogLevel; exports.LogTarget = LogTarget; exports.Logger = Logger; exports.NestedMap = NestedMap; exports.ProtocolVersion = ProtocolVersion; exports.ROOT_YDOC_ID = ROOT_YDOC_ID; exports.Room = Room; exports.UniqueMap = UniqueMap; exports.ackIgnoredOp = ackIgnoredOp; exports.clientMsgDecoder = clientMsgDecoder; exports.concatUint8Arrays = concatUint8Arrays; exports.guidDecoder = guidDecoder; exports.isLeasedSessionExpired = isLeasedSessionExpired; exports.jsonObjectYolo = jsonObjectYolo; exports.jsonYolo = jsonYolo; exports.makeInMemorySnapshot = makeInMemorySnapshot; exports.makeMetadataDB = makeMetadataDB; exports.plainLsonToNodeStream = plainLsonToNodeStream; exports.protocolVersionDecoder = protocolVersionDecoder; exports.quote = quote; exports.serializeServerMsg = serialize; exports.snapshotToLossyJson_eager = snapshotToLossyJson_eager; exports.snapshotToLossyJson_lazy = snapshotToLossyJson_lazy; exports.snapshotToNodeStream = snapshotToNodeStream; exports.snapshotToPlainLson_eager = snapshotToPlainLson_eager; exports.snapshotToPlainLson_lazy = snapshotToPlainLson_lazy; exports.test_only__Storage = Storage; exports.test_only__YjsStorage = YjsStorage; exports.transientClientMsgDecoder = transientClientMsgDecoder; exports.tryCatch = tryCatch;
+
+
+
+
+
+
+
+
+
+exports.BackendSession = BackendSession; exports.BrowserSession = BrowserSession; exports.ConsoleTarget = ConsoleTarget; exports.DefaultMap = DefaultMap; exports.FeedMsgCode = FeedMsgCode; exports.FeedRequestErrorCode = FeedRequestErrorCode; exports.InMemoryDriver = InMemoryDriver; exports.LogLevel = LogLevel; exports.LogTarget = LogTarget; exports.Logger = Logger; exports.NestedMap = NestedMap; exports.ProtocolVersion = ProtocolVersion; exports.ROOT_YDOC_ID = ROOT_YDOC_ID; exports.Room = Room; exports.UniqueMap = UniqueMap; exports.ackIgnoredOp = ackIgnoredOp; exports.clientMsgDecoder = clientMsgDecoder; exports.concatUint8Arrays = concatUint8Arrays; exports.feedFailureServerMsg = feedFailureServerMsg; exports.feedMetadataIdDecoder = feedMetadataIdDecoder; exports.feedMetadataUpdateDecoder = feedMetadataUpdateDecoder; exports.feedRequestFailed = feedRequestFailed; exports.fetchFeedsMetadataFilterDecoder = fetchFeedsMetadataFilterDecoder; exports.guidDecoder = guidDecoder; exports.isLeasedSessionExpired = isLeasedSessionExpired; exports.jsonObjectYolo = jsonObjectYolo; exports.jsonYolo = jsonYolo; exports.makeInMemorySnapshot = makeInMemorySnapshot; exports.makeMetadataDB = makeMetadataDB; exports.mapFeedError = mapFeedError; exports.optionalFeedMetadataDecoder = optionalFeedMetadataDecoder; exports.plainLsonToNodeStream = plainLsonToNodeStream; exports.protocolVersionDecoder = protocolVersionDecoder; exports.quote = quote; exports.serializeServerMsg = serialize; exports.snapshotToLossyJson_eager = snapshotToLossyJson_eager; exports.snapshotToLossyJson_lazy = snapshotToLossyJson_lazy; exports.snapshotToNodeStream = snapshotToNodeStream; exports.snapshotToPlainLson_eager = snapshotToPlainLson_eager; exports.snapshotToPlainLson_lazy = snapshotToPlainLson_lazy; exports.test_only__Storage = Storage; exports.test_only__YjsStorage = YjsStorage; exports.transientClientMsgDecoder = transientClientMsgDecoder; exports.tryCatch = tryCatch;
 //# sourceMappingURL=index.cjs.map