@liveblocks/core 1.1.8 → 1.2.0-comments

package/dist/index.mjs

@@ -1,6 +1,12 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
 // src/version.ts
 var PKG_NAME = "@liveblocks/core";
-var PKG_VERSION = "1.1.8";
+var PKG_VERSION = "1.2.0-comments";
 var PKG_FORMAT = "esm";
 
 // src/dupe-detection.ts
@@ -46,6 +52,36 @@ function detectDupes(pkgName, pkgVersion, pkgFormat) {
   }
 }
 
+// src/lib/assert.ts
+function assertNever(_value, errmsg) {
+  throw new Error(errmsg);
+}
+function assert(condition, errmsg) {
+  if (process.env.NODE_ENV !== "production") {
+    if (!condition) {
+      const err = new Error(errmsg);
+      err.name = "Assertion failure";
+      throw err;
+    }
+  }
+}
+function nn(value, errmsg = "Expected value to be non-nullable") {
+  assert(value !== null && value !== void 0, errmsg);
+  return value;
+}
+
+// src/lib/controlledPromise.ts
+function controlledPromise() {
+  let flagger;
+  const promise = new Promise((res) => {
+    flagger = res;
+  });
+  if (!flagger) {
+    throw new Error("Should never happen");
+  }
+  return [promise, flagger];
+}
+
 // src/lib/EventSource.ts
 function makeEventSource() {
   const _onetimeObservers = /* @__PURE__ */ new Set();
@@ -119,185 +155,14 @@ function makeEventSource() {
   };
 }
 
-// src/devtools/bridge.ts
-var _bridgeActive = false;
-function activateBridge(allowed) {
-  _bridgeActive = allowed;
-}
-function sendToPanel(message, options) {
-  if (process.env.NODE_ENV === "production" || typeof window === "undefined") {
-    return;
-  }
-  const fullMsg = {
-    ...message,
-    source: "liveblocks-devtools-client"
-  };
-  if (!(options?.force || _bridgeActive)) {
-    return;
-  }
-  window.postMessage(fullMsg, "*");
-}
-var eventSource = makeEventSource();
-if (process.env.NODE_ENV !== "production" && typeof window !== "undefined") {
-  window.addEventListener("message", (event) => {
-    if (event.source === window && event.data?.source === "liveblocks-devtools-panel") {
-      eventSource.notify(event.data);
-    } else {
-    }
-  });
-}
-var onMessageFromPanel = eventSource.observable;
-
-// src/devtools/index.ts
-var VERSION = PKG_VERSION || "dev";
-var _devtoolsSetupHasRun = false;
-function setupDevTools(getAllRooms) {
-  if (process.env.NODE_ENV === "production" || typeof window === "undefined") {
-    return;
-  }
-  if (_devtoolsSetupHasRun) {
-    return;
-  }
-  _devtoolsSetupHasRun = true;
-  onMessageFromPanel.subscribe((msg) => {
-    switch (msg.msg) {
-      case "connect": {
-        activateBridge(true);
-        for (const roomId of getAllRooms()) {
-          sendToPanel({
-            msg: "room::available",
-            roomId,
-            clientVersion: VERSION
-          });
-        }
-        break;
-      }
-    }
-  });
-  sendToPanel({ msg: "wake-up-devtools" }, { force: true });
-}
-var unsubsByRoomId = /* @__PURE__ */ new Map();
-function stopSyncStream(roomId) {
-  const unsubs = unsubsByRoomId.get(roomId) ?? [];
-  unsubsByRoomId.delete(roomId);
-  for (const unsub of unsubs) {
-    unsub();
-  }
-}
-function startSyncStream(room) {
-  stopSyncStream(room.id);
-  fullSync(room);
-  unsubsByRoomId.set(room.id, [
-    // When the connection status changes
-    room.events.status.subscribe(() => partialSyncConnection(room)),
-    // When storage initializes, send the update
-    room.events.storageDidLoad.subscribeOnce(() => partialSyncStorage(room)),
-    // Any time storage updates, send the new storage root
-    room.events.storage.subscribe(() => partialSyncStorage(room)),
-    // Any time "me" or "others" updates, send the new values accordingly
-    room.events.self.subscribe(() => partialSyncMe(room)),
-    room.events.others.subscribe(() => partialSyncOthers(room))
-  ]);
-}
-function partialSyncConnection(room) {
-  sendToPanel({
-    msg: "room::sync::partial",
-    roomId: room.id,
-    status: room.getStatus()
-  });
-}
-function partialSyncStorage(room) {
-  const root = room.getStorageSnapshot();
-  if (root) {
-    sendToPanel({
-      msg: "room::sync::partial",
-      roomId: room.id,
-      storage: root.toTreeNode("root").payload
-    });
-  }
-}
-function partialSyncMe(room) {
-  const me = room.__internal.getSelf_forDevTools();
-  if (me) {
-    sendToPanel({
-      msg: "room::sync::partial",
-      roomId: room.id,
-      me
-    });
-  }
-}
-function partialSyncOthers(room) {
-  const others = room.__internal.getOthers_forDevTools();
-  if (others) {
-    sendToPanel({
-      msg: "room::sync::partial",
-      roomId: room.id,
-      others
-    });
-  }
-}
-function fullSync(room) {
-  const root = room.getStorageSnapshot();
-  const me = room.__internal.getSelf_forDevTools();
-  const others = room.__internal.getOthers_forDevTools();
-  sendToPanel({
-    msg: "room::sync::full",
-    roomId: room.id,
-    status: room.getStatus(),
-    storage: root?.toTreeNode("root").payload ?? null,
-    me,
-    others
-  });
-}
-var roomChannelListeners = /* @__PURE__ */ new Map();
-function stopRoomChannelListener(roomId) {
-  const listener = roomChannelListeners.get(roomId);
-  roomChannelListeners.delete(roomId);
-  if (listener) {
-    listener();
-  }
-}
-function linkDevTools(roomId, room) {
-  if (process.env.NODE_ENV === "production" || typeof window === "undefined") {
-    return;
-  }
-  sendToPanel({ msg: "room::available", roomId, clientVersion: VERSION });
-  stopRoomChannelListener(roomId);
-  roomChannelListeners.set(
-    roomId,
-    // Returns the unsubscribe callback, that we store in the
-    // roomChannelListeners registry
-    onMessageFromPanel.subscribe((msg) => {
-      switch (msg.msg) {
-        case "room::subscribe": {
-          if (msg.roomId === roomId) {
-            startSyncStream(room);
-          }
-          break;
-        }
-        case "room::unsubscribe": {
-          if (msg.roomId === roomId) {
-            stopSyncStream(roomId);
-          }
-          break;
-        }
-      }
-    })
-  );
-}
-function unlinkDevTools(roomId) {
-  if (process.env.NODE_ENV === "production" || typeof window === "undefined") {
-    return;
-  }
-  stopSyncStream(roomId);
-  stopRoomChannelListener(roomId);
-  sendToPanel({
-    msg: "room::unavailable",
-    roomId
-  });
-}
-
 // src/lib/fancy-console.ts
+var fancy_console_exports = {};
+__export(fancy_console_exports, {
+  error: () => error2,
+  errorWithTitle: () => errorWithTitle,
+  warn: () => warn,
+  warnWithTitle: () => warnWithTitle
+});
 var badge = "background:#0e0d12;border-radius:9999px;color:#fff;padding:3px 7px;font-family:sans-serif;font-weight:600;";
 var bold = "font-weight:600";
 function wrap(method) {
@@ -323,57 +188,6 @@ function wrapWithTitle(method) {
 var warnWithTitle = wrapWithTitle("warn");
 var errorWithTitle = wrapWithTitle("error");
 
-// src/lib/deprecation.ts
-var _emittedDeprecationWarnings = /* @__PURE__ */ new Set();
-function deprecate(message, key = message) {
-  if (process.env.NODE_ENV !== "production") {
-    if (!_emittedDeprecationWarnings.has(key)) {
-      _emittedDeprecationWarnings.add(key);
-      errorWithTitle("Deprecation warning", message);
-    }
-  }
-}
-function deprecateIf(condition, message, key = message) {
-  if (process.env.NODE_ENV !== "production") {
-    if (condition) {
-      deprecate(message, key);
-    }
-  }
-}
-function throwUsageError(message) {
-  if (process.env.NODE_ENV !== "production") {
-    const usageError = new Error(message);
-    usageError.name = "Usage error";
-    errorWithTitle("Usage error", message);
-    throw usageError;
-  }
-}
-function errorIf(condition, message) {
-  if (process.env.NODE_ENV !== "production") {
-    if (condition) {
-      throwUsageError(message);
-    }
-  }
-}
-
-// src/lib/assert.ts
-function assertNever(_value, errmsg) {
-  throw new Error(errmsg);
-}
-function assert(condition, errmsg) {
-  if (process.env.NODE_ENV !== "production") {
-    if (!condition) {
-      const err = new Error(errmsg);
-      err.name = "Assertion failure";
-      throw err;
-    }
-  }
-}
-function nn(value, errmsg = "Expected value to be non-nullable") {
-  assert(value !== null && value !== void 0, errmsg);
-  return value;
-}
-
 // src/lib/fsm.ts
 function distance(state1, state2) {
   if (state1 === state2) {
@@ -812,9 +626,48 @@ async function withTimeout(promise, millis, errmsg = "Timed out") {
   return Promise.race([promise, timer$]).finally(() => clearTimeout(timerID));
 }
 
-// src/connection.ts
-function newToLegacyStatus(status) {
-  switch (status) {
+// src/protocol/ServerMsg.ts
+var ServerMsgCode = /* @__PURE__ */ ((ServerMsgCode2) => {
+  ServerMsgCode2[ServerMsgCode2["UPDATE_PRESENCE"] = 100] = "UPDATE_PRESENCE";
+  ServerMsgCode2[ServerMsgCode2["USER_JOINED"] = 101] = "USER_JOINED";
+  ServerMsgCode2[ServerMsgCode2["USER_LEFT"] = 102] = "USER_LEFT";
+  ServerMsgCode2[ServerMsgCode2["BROADCASTED_EVENT"] = 103] = "BROADCASTED_EVENT";
+  ServerMsgCode2[ServerMsgCode2["ROOM_STATE"] = 104] = "ROOM_STATE";
+  ServerMsgCode2[ServerMsgCode2["INITIAL_STORAGE_STATE"] = 200] = "INITIAL_STORAGE_STATE";
+  ServerMsgCode2[ServerMsgCode2["UPDATE_STORAGE"] = 201] = "UPDATE_STORAGE";
+  ServerMsgCode2[ServerMsgCode2["REJECT_STORAGE_OP"] = 299] = "REJECT_STORAGE_OP";
+  ServerMsgCode2[ServerMsgCode2["UPDATE_YDOC"] = 300] = "UPDATE_YDOC";
+  return ServerMsgCode2;
+})(ServerMsgCode || {});
+
+// src/types/IWebSocket.ts
+var WebsocketCloseCodes = /* @__PURE__ */ ((WebsocketCloseCodes2) => {
+  WebsocketCloseCodes2[WebsocketCloseCodes2["CLOSE_ABNORMAL"] = 1006] = "CLOSE_ABNORMAL";
+  WebsocketCloseCodes2[WebsocketCloseCodes2["UNEXPECTED_CONDITION"] = 1011] = "UNEXPECTED_CONDITION";
+  WebsocketCloseCodes2[WebsocketCloseCodes2["TRY_AGAIN_LATER"] = 1013] = "TRY_AGAIN_LATER";
+  WebsocketCloseCodes2[WebsocketCloseCodes2["INVALID_MESSAGE_FORMAT"] = 4e3] = "INVALID_MESSAGE_FORMAT";
+  WebsocketCloseCodes2[WebsocketCloseCodes2["NOT_ALLOWED"] = 4001] = "NOT_ALLOWED";
+  WebsocketCloseCodes2[WebsocketCloseCodes2["MAX_NUMBER_OF_MESSAGES_PER_SECONDS"] = 4002] = "MAX_NUMBER_OF_MESSAGES_PER_SECONDS";
+  WebsocketCloseCodes2[WebsocketCloseCodes2["MAX_NUMBER_OF_CONCURRENT_CONNECTIONS"] = 4003] = "MAX_NUMBER_OF_CONCURRENT_CONNECTIONS";
+  WebsocketCloseCodes2[WebsocketCloseCodes2["MAX_NUMBER_OF_MESSAGES_PER_DAY_PER_APP"] = 4004] = "MAX_NUMBER_OF_MESSAGES_PER_DAY_PER_APP";
+  WebsocketCloseCodes2[WebsocketCloseCodes2["MAX_NUMBER_OF_CONCURRENT_CONNECTIONS_PER_ROOM"] = 4005] = "MAX_NUMBER_OF_CONCURRENT_CONNECTIONS_PER_ROOM";
+  WebsocketCloseCodes2[WebsocketCloseCodes2["TOKEN_EXPIRED"] = 4109] = "TOKEN_EXPIRED";
+  WebsocketCloseCodes2[WebsocketCloseCodes2["CLOSE_WITHOUT_RETRY"] = 4999] = "CLOSE_WITHOUT_RETRY";
+  return WebsocketCloseCodes2;
+})(WebsocketCloseCodes || {});
+function shouldDisconnect(code) {
+  return code === 4999 /* CLOSE_WITHOUT_RETRY */ || code >= 4e3 && code < 4100;
+}
+function shouldReauth(code) {
+  return code >= 4100 && code < 4200;
+}
+function shouldRetryWithoutReauth(code) {
+  return code === 1013 /* TRY_AGAIN_LATER */ || code >= 4200 && code < 4300;
+}
+
+// src/connection.ts
+function newToLegacyStatus(status) {
+  switch (status) {
     case "connecting":
       return "connecting";
     case "connected":
@@ -916,9 +769,6 @@ var logPermanentClose = log(
 function isCloseEvent(error3) {
   return !(error3 instanceof Error) && error3.type === "close";
 }
-function isCustomCloseEvent(error3) {
-  return isCloseEvent(error3) && error3.code >= 4e3 && error3.code < 4100;
-}
 function enableTracing(machine) {
   const start = (/* @__PURE__ */ new Date()).getTime();
   function log2(...args) {
@@ -969,13 +819,19 @@ function defineConnectivityEvents(machine) {
   };
 }
 var assign = (patch) => (ctx) => ctx.patch(patch);
-function createConnectionStateMachine(delegates, enableDebugLogging) {
+function createConnectionStateMachine(delegates, options) {
   const onMessage = makeEventSource();
   onMessage.pause();
   const onLiveblocksError = makeEventSource();
+  function fireErrorEvent(errmsg, errcode) {
+    return () => {
+      const err = new LiveblocksError(errmsg, errcode);
+      onLiveblocksError.notify(err);
+    };
+  }
   const initialContext = {
     successCount: 0,
-    token: null,
+    authValue: null,
     socket: null,
     backoffDelay: RESET_DELAY
   };
@@ -989,9 +845,9 @@ function createConnectionStateMachine(delegates, enableDebugLogging) {
   });
   machine.onEnter("@idle.*", resetSuccessCount).addTransitions("@idle.*", {
     CONNECT: (_, ctx) => (
-      // If we still have a known token, try to reconnect to the socket directly,
-      // otherwise, try to obtain a new token
-      ctx.token !== null ? "@connecting.busy" : "@auth.busy"
+      // If we still have a known authValue, try to reconnect to the socket directly,
+      // otherwise, try to obtain a new authValue
+      ctx.authValue !== null ? "@connecting.busy" : "@auth.busy"
     )
   });
   machine.addTransitions("@auth.backoff", {
@@ -1010,7 +866,7 @@ function createConnectionStateMachine(delegates, enableDebugLogging) {
     (okEvent) => ({
       target: "@connecting.busy",
       effect: assign({
-        token: okEvent.data,
+        authValue: okEvent.data,
         backoffDelay: RESET_DELAY
       })
     }),
@@ -1019,7 +875,10 @@ function createConnectionStateMachine(delegates, enableDebugLogging) {
       if (failedEvent.reason instanceof StopRetrying) {
         return {
           target: "@idle.failed",
-          effect: log(2 /* ERROR */, failedEvent.reason.message)
+          effect: [
+            log(2 /* ERROR */, failedEvent.reason.message),
+            fireErrorEvent(failedEvent.reason.message, -1)
+          ]
         };
       }
       return {
@@ -1069,16 +928,29 @@ function createConnectionStateMachine(delegates, enableDebugLogging) {
       let capturedPrematureEvent = null;
       const connect$ = new Promise(
         (resolve, rej) => {
-          if (ctx.token === null) {
-            throw new Error("No auth token");
+          if (ctx.authValue === null) {
+            throw new Error("No auth authValue");
           }
-          const socket = delegates.createSocket(ctx.token);
+          const socket = delegates.createSocket(ctx.authValue);
           function reject(event) {
             capturedPrematureEvent = event;
             socket.removeEventListener("message", onSocketMessage);
             rej(event);
           }
+          const [actor$, didReceiveActor] = controlledPromise();
+          if (!options.waitForActorId) {
+            didReceiveActor();
+          }
+          function waitForActorId(event) {
+            const serverMsg = tryParseJson(event.data);
+            if (serverMsg?.type === 104 /* ROOM_STATE */) {
+              didReceiveActor();
+            }
+          }
           socket.addEventListener("message", onSocketMessage);
+          if (options.waitForActorId) {
+            socket.addEventListener("message", waitForActorId);
+          }
           socket.addEventListener("error", reject);
           socket.addEventListener("close", reject);
           socket.addEventListener("open", () => {
@@ -1087,8 +959,11 @@ function createConnectionStateMachine(delegates, enableDebugLogging) {
             const unsub = () => {
               socket.removeEventListener("error", reject);
               socket.removeEventListener("close", reject);
+              socket.removeEventListener("message", waitForActorId);
             };
-            resolve([socket, unsub]);
+            void actor$.then(() => {
+              resolve([socket, unsub]);
+            });
           });
         }
       );
@@ -1129,24 +1004,35 @@ function createConnectionStateMachine(delegates, enableDebugLogging) {
       if (err instanceof StopRetrying) {
         return {
           target: "@idle.failed",
-          effect: log(2 /* ERROR */, err.message)
-        };
-      }
-      if (isCloseEvent(err) && err.code === 4999) {
-        return {
-          target: "@idle.failed",
-          effect: log(2 /* ERROR */, err.reason)
-        };
-      }
-      if (isCustomCloseEvent(err) && err.code !== 4001) {
-        return {
-          target: "@connecting.backoff",
           effect: [
-            increaseBackoffDelayAggressively,
-            logPrematureErrorOrCloseEvent(err)
+            log(2 /* ERROR */, err.message),
+            fireErrorEvent(err.message, -1)
           ]
         };
       }
+      if (isCloseEvent(err)) {
+        if (err.code === 4109 /* TOKEN_EXPIRED */) {
+          return "@auth.busy";
+        }
+        if (shouldRetryWithoutReauth(err.code)) {
+          return {
+            target: "@connecting.backoff",
+            effect: [
+              increaseBackoffDelayAggressively,
+              logPrematureErrorOrCloseEvent(err)
+            ]
+          };
+        }
+        if (shouldDisconnect(err.code)) {
+          return {
+            target: "@idle.failed",
+            effect: [
+              log(2 /* ERROR */, err.reason),
+              fireErrorEvent(err.reason, err.code)
+            ]
+          };
+        }
+      }
       return {
         target: "@auth.backoff",
         effect: [increaseBackoffDelay, logPrematureErrorOrCloseEvent(err)]
@@ -1200,29 +1086,29 @@ function createConnectionStateMachine(delegates, enableDebugLogging) {
       };
     },
     EXPLICIT_SOCKET_CLOSE: (e) => {
-      if (e.event.code === 4999) {
+      if (shouldDisconnect(e.event.code)) {
         return {
           target: "@idle.failed",
-          effect: logPermanentClose
+          effect: [
+            logPermanentClose,
+            fireErrorEvent(e.event.reason, e.event.code)
+          ]
         };
       }
-      if (e.event.code === 4001) {
-        return {
-          target: "@auth.backoff",
-          effect: [increaseBackoffDelay, logCloseEvent(e.event)]
-        };
+      if (shouldReauth(e.event.code)) {
+        if (e.event.code === 4109 /* TOKEN_EXPIRED */) {
+          return "@auth.busy";
+        } else {
+          return {
+            target: "@auth.backoff",
+            effect: [increaseBackoffDelay, logCloseEvent(e.event)]
+          };
+        }
       }
-      if (isCustomCloseEvent(e.event)) {
+      if (shouldRetryWithoutReauth(e.event.code)) {
         return {
           target: "@connecting.backoff",
-          effect: [
-            increaseBackoffDelayAggressively,
-            logCloseEvent(e.event),
-            () => {
-              const err = new LiveblocksError(e.event.reason, e.event.code);
-              onLiveblocksError.notify(err);
-            }
-          ]
+          effect: [increaseBackoffDelayAggressively, logCloseEvent(e.event)]
         };
       }
       return {
@@ -1261,7 +1147,7 @@ function createConnectionStateMachine(delegates, enableDebugLogging) {
   const cleanups = [];
   const { statusDidChange, didConnect, didDisconnect, unsubscribe } = defineConnectivityEvents(machine);
   cleanups.push(unsubscribe);
-  if (enableDebugLogging) {
+  if (options.enableDebugLogging) {
     cleanups.push(enableTracing(machine));
   }
   machine.start();
@@ -1279,10 +1165,10 @@ function createConnectionStateMachine(delegates, enableDebugLogging) {
   };
 }
 var ManagedSocket = class {
-  constructor(delegates, enableDebugLogging = false) {
+  constructor(delegates, enableDebugLogging = false, waitForActorId = true) {
     const { machine, events, cleanups } = createConnectionStateMachine(
       delegates,
-      enableDebugLogging
+      { waitForActorId, enableDebugLogging }
     );
     this.machine = machine;
     this.events = events;
@@ -1299,10 +1185,10 @@ var ManagedSocket = class {
     }
   }
   /**
-   * Returns the current auth token.
+   * Returns the current auth authValue.
    */
-  get token() {
-    return this.machine.context.token;
+  get authValue() {
+    return this.machine.context.authValue;
   }
   /**
    * Call this method to try to connect to a WebSocket. This only has an effect
@@ -1313,7 +1199,7 @@ var ManagedSocket = class {
   }
   /**
    * If idle, will try to connect. Otherwise, it will attempt to reconnect to
-   * the socket, potentially obtaining a new token first, if needed.
+   * the socket, potentially obtaining a new authValue first, if needed.
    */
   reconnect() {
     this.machine.send({ type: "RECONNECT" });
@@ -1360,124 +1246,635 @@ var ManagedSocket = class {
   }
 };
 
-// src/lib/position.ts
-var MIN_CODE = 32;
-var MAX_CODE = 126;
-var NUM_DIGITS = MAX_CODE - MIN_CODE + 1;
-var ZERO = nthDigit(0);
-var ONE = nthDigit(1);
-var ZERO_NINE = ZERO + nthDigit(-1);
-function nthDigit(n) {
-  const code = MIN_CODE + (n < 0 ? NUM_DIGITS + n : n);
-  if (code < MIN_CODE || code > MAX_CODE) {
-    throw new Error(`Invalid n value: ${n}`);
-  }
-  return String.fromCharCode(code);
+// src/protocol/AuthToken.ts
+function canWriteStorage(scopes) {
+  return scopes.includes("room:write" /* Write */);
 }
-function makePosition(x, y) {
-  if (x !== void 0 && y !== void 0) {
-    return between(x, y);
-  } else if (x !== void 0) {
-    return after(x);
-  } else if (y !== void 0) {
-    return before(y);
-  } else {
-    return ONE;
+function isValidAuthTokenPayload(data) {
+  return isPlainObject(data) && (data.k === "acc" /* ACCESS_TOKEN */ || data.k === "id" /* ID_TOKEN */ || data.k === "sec-legacy" /* SECRET_LEGACY */);
+}
+function parseAuthToken(rawTokenString) {
+  const tokenParts = rawTokenString.split(".");
+  if (tokenParts.length !== 3) {
+    throw new Error("Authentication error: invalid JWT token");
+  }
+  const payload = tryParseJson(b64decode(tokenParts[1]));
+  if (!(payload && isValidAuthTokenPayload(payload))) {
+    throw new Error(
+      "Authentication error: expected a valid token but did not get one. Hint: if you are using a callback, ensure the room is passed when creating the token. For more information: https://liveblocks.io/docs/api-reference/liveblocks-client#createClientCallback"
+    );
   }
+  return {
+    raw: rawTokenString,
+    parsed: payload
+  };
 }
-function before(pos) {
-  const lastIndex = pos.length - 1;
-  for (let i = 0; i <= lastIndex; i++) {
-    const code = pos.charCodeAt(i);
-    if (code <= MIN_CODE) {
-      continue;
+
+// src/auth-manager.ts
+function createAuthManager(authOptions) {
+  const authentication = prepareAuthentication(authOptions);
+  const tokens = [];
+  const expiryTimes = [];
+  const requestPromises = /* @__PURE__ */ new Map();
+  function hasCorrespondingScopes(requestedScope, scopes) {
+    if (requestedScope === "comments:read") {
+      return scopes.includes("comments:read" /* CommentsRead */) || scopes.includes("comments:write" /* CommentsWrite */) || scopes.includes("room:read" /* Read */) || scopes.includes("room:write" /* Write */);
+    } else if (requestedScope === "room:read") {
+      return scopes.includes("room:read" /* Read */) || scopes.includes("room:write" /* Write */);
     }
-    if (i === lastIndex) {
-      if (code === MIN_CODE + 1) {
-        return pos.substring(0, i) + ZERO_NINE;
-      } else {
-        return pos.substring(0, i) + String.fromCharCode(code - 1);
+    return false;
+  }
+  function getCachedToken(requestedScope, roomId) {
+    const now = Math.ceil(Date.now() / 1e3);
+    for (let i = tokens.length - 1; i >= 0; i--) {
+      const token = tokens[i];
+      const expiresAt = expiryTimes[i];
+      if (expiresAt <= now) {
+        tokens.splice(i, 1);
+        expiryTimes.splice(i, 1);
+        continue;
+      }
+      if (token.parsed.k === "id" /* ID_TOKEN */) {
+        return token;
+      } else if (token.parsed.k === "sec-legacy" /* SECRET_LEGACY */) {
+        return void 0;
+      } else if (token.parsed.k === "acc" /* ACCESS_TOKEN */) {
+        for (const [resource, scopes] of Object.entries(token.parsed.perms)) {
+          if (resource.includes("*") && roomId.startsWith(resource.replace("*", "")) || roomId === resource && hasCorrespondingScopes(requestedScope, scopes)) {
+            return token;
+          }
+        }
       }
-    } else {
-      return pos.substring(0, i + 1);
     }
+    return void 0;
   }
-  return ONE;
-}
-function after(pos) {
-  for (let i = 0; i <= pos.length - 1; i++) {
-    const code = pos.charCodeAt(i);
-    if (code >= MAX_CODE) {
-      continue;
+  async function makeAuthRequest(roomId) {
+    const fetcher = authOptions.polyfills?.fetch ?? (typeof window === "undefined" ? void 0 : window.fetch);
+    if (authentication.type === "private") {
+      if (fetcher === void 0) {
+        throw new StopRetrying(
+          "To use Liveblocks client in a non-dom environment with a url as auth endpoint, you need to provide a fetch polyfill."
+        );
+      }
+      const response = await fetchAuthEndpoint(fetcher, authentication.url, {
+        room: roomId
+      });
+      return parseAuthToken(response.token);
     }
-    return pos.substring(0, i) + String.fromCharCode(code + 1);
-  }
-  return pos + ONE;
-}
-function between(lo, hi) {
-  if (lo < hi) {
-    return _between(lo, hi);
-  } else if (lo > hi) {
-    return _between(hi, lo);
-  } else {
-    throw new Error("Cannot compute value between two equal positions");
+    if (authentication.type === "custom") {
+      const response = await authentication.callback(roomId);
+      if (!response || typeof response !== "object") {
+        throw new Error(
+          'We expect the authentication callback to return a token, but it does not. Hint: the return value should look like: { token: "..." }'
+        );
+      }
+      if (typeof response.token === "string") {
+        return parseAuthToken(response.token);
+      } else if (typeof response.error === "string") {
+        const reason = `Authentication failed: ${"reason" in response && typeof response.reason === "string" ? response.reason : "Forbidden"}`;
+        if (response.error === "forbidden") {
+          throw new StopRetrying(reason);
+        } else {
+          throw new Error(reason);
+        }
+      } else {
+        throw new Error(
+          'We expect the authentication callback to return a token, but it does not. Hint: the return value should look like: { token: "..." }'
+        );
+      }
+    }
+    throw new Error("Invalid Liveblocks client options");
   }
-}
-function _between(lo, hi) {
-  let index = 0;
-  const loLen = lo.length;
-  const hiLen = hi.length;
-  while (true) {
-    const loCode = index < loLen ? lo.charCodeAt(index) : MIN_CODE;
-    const hiCode = index < hiLen ? hi.charCodeAt(index) : MAX_CODE;
-    if (loCode === hiCode) {
-      index++;
-      continue;
+  async function getAuthValue(requestedScope, roomId) {
+    if (authentication.type === "public") {
+      return { type: "public", publicApiKey: authentication.publicApiKey };
     }
-    if (hiCode - loCode === 1) {
-      const prefix = lo.substring(0, index + 1);
-      const suffix = lo.substring(index + 1);
-      const nines = "";
-      return prefix + _between(suffix, nines);
-    } else {
-      return takeN(lo, index) + String.fromCharCode(hiCode + loCode >> 1);
+    const cachedToken = getCachedToken(requestedScope, roomId);
+    if (cachedToken !== void 0) {
+      return { type: "secret", token: cachedToken };
+    }
+    let currentPromise = requestPromises.get(roomId);
+    if (currentPromise === void 0) {
+      currentPromise = makeAuthRequest(roomId);
+      requestPromises.set(roomId, currentPromise);
+    }
+    try {
+      const token = await currentPromise;
+      const BUFFER = 30;
+      const expiresAt = Math.floor(Date.now() / 1e3) + (token.parsed.exp - token.parsed.iat) - BUFFER;
+      tokens.push(token);
+      expiryTimes.push(expiresAt);
+      return { type: "secret", token };
+    } finally {
+      requestPromises.delete(roomId);
     }
   }
+  return {
+    getAuthValue
+  };
 }
-function takeN(pos, n) {
-  return n < pos.length ? pos.substring(0, n) : pos + ZERO.repeat(n - pos.length);
-}
-var MIN_NON_ZERO_CODE = MIN_CODE + 1;
-function isPos(str) {
-  if (str === "") {
-    return false;
-  }
-  const lastIdx = str.length - 1;
-  const last = str.charCodeAt(lastIdx);
-  if (last < MIN_NON_ZERO_CODE || last > MAX_CODE) {
-    return false;
+function prepareAuthentication(authOptions) {
+  const { publicApiKey, authEndpoint } = authOptions;
+  if (authEndpoint !== void 0 && publicApiKey !== void 0) {
+    throw new Error(
+      "You cannot use both publicApiKey and authEndpoint. Please use either publicApiKey or authEndpoint, but not both. For more information: https://liveblocks.io/docs/api-reference/liveblocks-client#createClient"
+    );
   }
-  for (let i = 0; i < lastIdx; i++) {
-    const code = str.charCodeAt(i);
-    if (code < MIN_CODE || code > MAX_CODE) {
-      return false;
+  if (typeof publicApiKey === "string") {
+    if (publicApiKey.startsWith("sk_")) {
+      throw new Error(
+        "Invalid publicApiKey. You are using the secret key which is not supported. Please use the public key instead. For more information: https://liveblocks.io/docs/api-reference/liveblocks-client#createClientPublicKey"
+      );
+    } else if (!publicApiKey.startsWith("pk_")) {
+      throw new Error(
+        "Invalid key. Please use the public key format: pk_<public key>. For more information: https://liveblocks.io/docs/api-reference/liveblocks-client#createClientPublicKey"
+      );
     }
+    return {
+      type: "public",
+      publicApiKey
+    };
   }
-  return true;
-}
-function convertToPos(str) {
-  const codes = [];
-  for (let i = 0; i < str.length; i++) {
-    const code = str.charCodeAt(i);
-    codes.push(code < MIN_CODE ? MIN_CODE : code > MAX_CODE ? MAX_CODE : code);
-  }
-  while (codes.length > 0 && codes[codes.length - 1] === MIN_CODE) {
-    codes.length--;
+  if (typeof authEndpoint === "string") {
+    return {
+      type: "private",
+      url: authEndpoint
+    };
+  } else if (typeof authEndpoint === "function") {
+    return {
+      type: "custom",
+      callback: authEndpoint
+    };
+  } else if (authEndpoint !== void 0) {
+    throw new Error(
+      "authEndpoint must be a string or a function. For more information: https://liveblocks.io/docs/api-reference/liveblocks-client#createClientAuthEndpoint"
+    );
   }
-  return codes.length > 0 ? String.fromCharCode(...codes) : (
-    // Edge case: the str was a 0-only string, which is invalid. Default back to .1
-    ONE
-  );
+  throw new Error(
+    "Invalid Liveblocks client options. For more information: https://liveblocks.io/docs/api-reference/liveblocks-client#createClient"
+  );
+}
+async function fetchAuthEndpoint(fetch2, endpoint, body) {
+  const res = await fetch2(endpoint, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(body)
+  });
+  if (!res.ok) {
+    const reason = `${(await res.text()).trim() || "reason not provided in auth response"} (${res.status} returned by POST ${endpoint})`;
+    if (res.status === 401 || res.status === 403) {
+      throw new StopRetrying(`Unauthorized: ${reason}`);
+    } else {
+      throw new Error(`Failed to authenticate: ${reason}`);
+    }
+  }
+  let data;
+  try {
+    data = await res.json();
+  } catch (er) {
+    throw new Error(
+      `Expected a JSON response when doing a POST request on "${endpoint}". ${String(
+        er
+      )}`
+    );
+  }
+  if (!isPlainObject(data) || typeof data.token !== "string") {
+    throw new Error(
+      `Expected a JSON response of the form \`{ token: "..." }\` when doing a POST request on "${endpoint}", but got ${JSON.stringify(
+        data
+      )}`
+    );
+  }
+  const { token } = data;
+  return { token };
+}
+
+// src/devtools/bridge.ts
+var _bridgeActive = false;
+function activateBridge(allowed) {
+  _bridgeActive = allowed;
+}
+function sendToPanel(message, options) {
+  if (process.env.NODE_ENV === "production" || typeof window === "undefined") {
+    return;
+  }
+  const fullMsg = {
+    ...message,
+    source: "liveblocks-devtools-client"
+  };
+  if (!(options?.force || _bridgeActive)) {
+    return;
+  }
+  window.postMessage(fullMsg, "*");
+}
+var eventSource = makeEventSource();
+if (process.env.NODE_ENV !== "production" && typeof window !== "undefined") {
+  window.addEventListener("message", (event) => {
+    if (event.source === window && event.data?.source === "liveblocks-devtools-panel") {
+      eventSource.notify(event.data);
+    } else {
+    }
+  });
+}
+var onMessageFromPanel = eventSource.observable;
+
+// src/devtools/index.ts
+var VERSION = PKG_VERSION || "dev";
+var _devtoolsSetupHasRun = false;
+function setupDevTools(getAllRooms) {
+  if (process.env.NODE_ENV === "production" || typeof window === "undefined") {
+    return;
+  }
+  if (_devtoolsSetupHasRun) {
+    return;
+  }
+  _devtoolsSetupHasRun = true;
+  onMessageFromPanel.subscribe((msg) => {
+    switch (msg.msg) {
+      case "connect": {
+        activateBridge(true);
+        for (const roomId of getAllRooms()) {
+          sendToPanel({
+            msg: "room::available",
+            roomId,
+            clientVersion: VERSION
+          });
+        }
+        break;
+      }
+    }
+  });
+  sendToPanel({ msg: "wake-up-devtools" }, { force: true });
+}
+var unsubsByRoomId = /* @__PURE__ */ new Map();
+function stopSyncStream(roomId) {
+  const unsubs = unsubsByRoomId.get(roomId) ?? [];
+  unsubsByRoomId.delete(roomId);
+  for (const unsub of unsubs) {
+    unsub();
+  }
+}
+function startSyncStream(room) {
+  stopSyncStream(room.id);
+  fullSync(room);
+  unsubsByRoomId.set(room.id, [
+    // When the connection status changes
+    room.events.status.subscribe(() => partialSyncConnection(room)),
+    // When storage initializes, send the update
+    room.events.storageDidLoad.subscribeOnce(() => partialSyncStorage(room)),
+    // Any time storage updates, send the new storage root
+    room.events.storage.subscribe(() => partialSyncStorage(room)),
+    // Any time "me" or "others" updates, send the new values accordingly
+    room.events.self.subscribe(() => partialSyncMe(room)),
+    room.events.others.subscribe(() => partialSyncOthers(room))
+  ]);
+}
+function partialSyncConnection(room) {
+  sendToPanel({
+    msg: "room::sync::partial",
+    roomId: room.id,
+    status: room.getStatus()
+  });
+}
+function partialSyncStorage(room) {
+  const root = room.getStorageSnapshot();
+  if (root) {
+    sendToPanel({
+      msg: "room::sync::partial",
+      roomId: room.id,
+      storage: root.toTreeNode("root").payload
+    });
+  }
+}
+function partialSyncMe(room) {
+  const me = room.__internal.getSelf_forDevTools();
+  if (me) {
+    sendToPanel({
+      msg: "room::sync::partial",
+      roomId: room.id,
+      me
+    });
+  }
+}
+function partialSyncOthers(room) {
+  const others = room.__internal.getOthers_forDevTools();
+  if (others) {
+    sendToPanel({
+      msg: "room::sync::partial",
+      roomId: room.id,
+      others
+    });
+  }
+}
+function fullSync(room) {
+  const root = room.getStorageSnapshot();
+  const me = room.__internal.getSelf_forDevTools();
+  const others = room.__internal.getOthers_forDevTools();
+  sendToPanel({
+    msg: "room::sync::full",
+    roomId: room.id,
+    status: room.getStatus(),
+    storage: root?.toTreeNode("root").payload ?? null,
+    me,
+    others
+  });
+}
+var roomChannelListeners = /* @__PURE__ */ new Map();
+function stopRoomChannelListener(roomId) {
+  const listener = roomChannelListeners.get(roomId);
+  roomChannelListeners.delete(roomId);
+  if (listener) {
+    listener();
+  }
+}
+function linkDevTools(roomId, room) {
+  if (process.env.NODE_ENV === "production" || typeof window === "undefined") {
+    return;
+  }
+  sendToPanel({ msg: "room::available", roomId, clientVersion: VERSION });
+  stopRoomChannelListener(roomId);
+  roomChannelListeners.set(
+    roomId,
+    // Returns the unsubscribe callback, that we store in the
+    // roomChannelListeners registry
+    onMessageFromPanel.subscribe((msg) => {
+      switch (msg.msg) {
+        case "room::subscribe": {
+          if (msg.roomId === roomId) {
+            startSyncStream(room);
+          }
+          break;
+        }
+        case "room::unsubscribe": {
+          if (msg.roomId === roomId) {
+            stopSyncStream(roomId);
+          }
+          break;
+        }
+      }
+    })
+  );
+}
+function unlinkDevTools(roomId) {
+  if (process.env.NODE_ENV === "production" || typeof window === "undefined") {
+    return;
+  }
+  stopSyncStream(roomId);
+  stopRoomChannelListener(roomId);
+  sendToPanel({
+    msg: "room::unavailable",
+    roomId
+  });
+}
+
+// src/lib/deprecation.ts
+var _emittedDeprecationWarnings = /* @__PURE__ */ new Set();
+function deprecate(message, key = message) {
+  if (process.env.NODE_ENV !== "production") {
+    if (!_emittedDeprecationWarnings.has(key)) {
+      _emittedDeprecationWarnings.add(key);
+      errorWithTitle("Deprecation warning", message);
+    }
+  }
+}
+function deprecateIf(condition, message, key = message) {
+  if (process.env.NODE_ENV !== "production") {
+    if (condition) {
+      deprecate(message, key);
+    }
+  }
+}
+function throwUsageError(message) {
+  if (process.env.NODE_ENV !== "production") {
+    const usageError = new Error(message);
+    usageError.name = "Usage error";
+    errorWithTitle("Usage error", message);
+    throw usageError;
+  }
+}
+function errorIf(condition, message) {
+  if (process.env.NODE_ENV !== "production") {
+    if (condition) {
+      throwUsageError(message);
+    }
+  }
+}
+
+// src/lib/Json.ts
+function isJsonScalar(data) {
+  return data === null || typeof data === "string" || typeof data === "number" || typeof data === "boolean";
+}
+function isJsonArray(data) {
+  return Array.isArray(data);
+}
+function isJsonObject(data) {
+  return !isJsonScalar(data) && !isJsonArray(data);
+}
+
+// src/realtime-client.ts
+function authValueToString(authValue) {
+  return authValue.type === "secret" ? authValue.token.raw : authValue.publicApiKey;
+}
+function createRealtimeClient(authManager, serverEndpoint) {
+  const eventHub = {
+    error: makeEventSource(),
+    connection: makeEventSource(),
+    events: {}
+  };
+  let managedSocket = null;
+  function createManagedSocket(roomId) {
+    managedSocket = new ManagedSocket(
+      {
+        // TODO: We're trying to (re)connect based on the first roomId that the user is asking for
+        // This is bad because the user might now have access to this room (anymore)
+        // This prevent any future reconnection to the websocket server
+        // We need to find a better way to handle the first (re)connection
+        // (Could it be based on the current listeners)
+        authenticate: () => authManager.getAuthValue("room:read", roomId),
+        createSocket: (authValue) => new WebSocket(
+          `${serverEndpoint}?token=${authValue.type === "secret" ? authValue.token.raw : authValue.publicApiKey}`
+        )
+      },
+      true,
+      false
+    );
+    managedSocket.events.statusDidChange.subscribe((status) => {
+      if (status === "connected") {
+        for (const roomId2 in eventHub.events) {
+          const eventSource2 = eventHub.events[roomId2];
+          if (eventSource2.count() > 0) {
+            subscribeToRoomEvents(roomId2);
+          }
+        }
+      }
+      eventHub.connection.notify(status);
+    });
+    managedSocket.events.onLiveblocksError.subscribe(eventHub.error.notify);
+    managedSocket.events.onMessage.subscribe((event) => {
+      if (typeof event.data !== "string") {
+        return;
+      }
+      const jsonEvent = tryParseJson(event.data);
+      if (jsonEvent !== void 0 && isJsonObject(jsonEvent) && typeof jsonEvent.roomId === "string") {
+        eventHub.events[jsonEvent.roomId].notify(jsonEvent);
+      }
+    });
+    managedSocket.connect();
+  }
+  function getOrCreateEventSource(roomId) {
+    let eventSource2 = eventHub.events[roomId];
+    if (eventSource2 === void 0) {
+      eventSource2 = makeEventSource();
+      eventHub.events[roomId] = eventSource2;
+    }
+    return eventSource2;
+  }
+  async function subscribeToRoomEvents(roomId) {
+    const authValue = await authManager.getAuthValue("room:read", roomId);
+    if (managedSocket === null || managedSocket.getStatus() !== "connected") {
+      return;
+    }
+    managedSocket.send(
+      JSON.stringify({
+        type: "subscribeToRooms",
+        rooms: [roomId],
+        token: authValueToString(authValue)
+      })
+    );
+  }
+  return {
+    subscribeToEvents: (roomId, callback) => {
+      if (!managedSocket) {
+        createManagedSocket(roomId);
+      }
+      subscribeToRoomEvents(roomId);
+      return getOrCreateEventSource(roomId).subscribe(callback);
+    },
+    error: eventHub.error.observable,
+    connection: eventHub.connection.observable
+  };
+}
+
+// src/lib/position.ts
+var MIN_CODE = 32;
+var MAX_CODE = 126;
+var NUM_DIGITS = MAX_CODE - MIN_CODE + 1;
+var ZERO = nthDigit(0);
+var ONE = nthDigit(1);
+var ZERO_NINE = ZERO + nthDigit(-1);
+function nthDigit(n) {
+  const code = MIN_CODE + (n < 0 ? NUM_DIGITS + n : n);
+  if (code < MIN_CODE || code > MAX_CODE) {
+    throw new Error(`Invalid n value: ${n}`);
+  }
+  return String.fromCharCode(code);
+}
+function makePosition(x, y) {
+  if (x !== void 0 && y !== void 0) {
+    return between(x, y);
+  } else if (x !== void 0) {
+    return after(x);
+  } else if (y !== void 0) {
+    return before(y);
+  } else {
+    return ONE;
+  }
+}
+function before(pos) {
+  const lastIndex = pos.length - 1;
+  for (let i = 0; i <= lastIndex; i++) {
+    const code = pos.charCodeAt(i);
+    if (code <= MIN_CODE) {
+      continue;
+    }
+    if (i === lastIndex) {
+      if (code === MIN_CODE + 1) {
+        return pos.substring(0, i) + ZERO_NINE;
+      } else {
+        return pos.substring(0, i) + String.fromCharCode(code - 1);
+      }
+    } else {
+      return pos.substring(0, i + 1);
+    }
+  }
+  return ONE;
+}
+function after(pos) {
+  for (let i = 0; i <= pos.length - 1; i++) {
+    const code = pos.charCodeAt(i);
+    if (code >= MAX_CODE) {
+      continue;
+    }
+    return pos.substring(0, i) + String.fromCharCode(code + 1);
+  }
+  return pos + ONE;
+}
+function between(lo, hi) {
+  if (lo < hi) {
+    return _between(lo, hi);
+  } else if (lo > hi) {
+    return _between(hi, lo);
+  } else {
+    throw new Error("Cannot compute value between two equal positions");
+  }
+}
+function _between(lo, hi) {
+  let index = 0;
+  const loLen = lo.length;
+  const hiLen = hi.length;
+  while (true) {
+    const loCode = index < loLen ? lo.charCodeAt(index) : MIN_CODE;
+    const hiCode = index < hiLen ? hi.charCodeAt(index) : MAX_CODE;
+    if (loCode === hiCode) {
+      index++;
+      continue;
+    }
+    if (hiCode - loCode === 1) {
+      const prefix = lo.substring(0, index + 1);
+      const suffix = lo.substring(index + 1);
+      const nines = "";
+      return prefix + _between(suffix, nines);
+    } else {
+      return takeN(lo, index) + String.fromCharCode(hiCode + loCode >> 1);
+    }
+  }
+}
+function takeN(pos, n) {
+  return n < pos.length ? pos.substring(0, n) : pos + ZERO.repeat(n - pos.length);
+}
+var MIN_NON_ZERO_CODE = MIN_CODE + 1;
+function isPos(str) {
+  if (str === "") {
+    return false;
+  }
+  const lastIdx = str.length - 1;
+  const last = str.charCodeAt(lastIdx);
+  if (last < MIN_NON_ZERO_CODE || last > MAX_CODE) {
+    return false;
+  }
+  for (let i = 0; i < lastIdx; i++) {
+    const code = str.charCodeAt(i);
+    if (code < MIN_CODE || code > MAX_CODE) {
+      return false;
+    }
+  }
+  return true;
+}
+function convertToPos(str) {
+  const codes = [];
+  for (let i = 0; i < str.length; i++) {
+    const code = str.charCodeAt(i);
+    codes.push(code < MIN_CODE ? MIN_CODE : code > MAX_CODE ? MAX_CODE : code);
+  }
+  while (codes.length > 0 && codes[codes.length - 1] === MIN_CODE) {
+    codes.length--;
+  }
+  return codes.length > 0 ? String.fromCharCode(...codes) : (
+    // Edge case: the str was a 0-only string, which is invalid. Default back to .1
+    ONE
+  );
 }
 function asPos(str) {
   return isPos(str) ? str : convertToPos(str);
@@ -3881,41 +4278,6 @@ function captureStackTrace(msg, traceRoot) {
   return errorLike.stack;
 }
 
-// src/lib/Json.ts
-function isJsonScalar(data) {
-  return data === null || typeof data === "string" || typeof data === "number" || typeof data === "boolean";
-}
-function isJsonArray(data) {
-  return Array.isArray(data);
-}
-function isJsonObject(data) {
-  return !isJsonScalar(data) && !isJsonArray(data);
-}
-
-// src/protocol/AuthToken.ts
-function isStringList(value) {
-  return Array.isArray(value) && value.every((i) => typeof i === "string");
-}
-function isMinimalTokenPayload(data) {
-  return isPlainObject(data) && typeof data.actor === "number" && (data.id === void 0 || typeof data.id === "string") && isStringList(data.scopes);
-}
-function parseAuthToken(rawTokenString) {
-  const tokenParts = rawTokenString.split(".");
-  if (tokenParts.length !== 3) {
-    throw new Error("Authentication error: invalid JWT token");
-  }
-  const payload = tryParseJson(b64decode(tokenParts[1]));
-  if (!(payload && isMinimalTokenPayload(payload))) {
-    throw new Error(
-      "Authentication error: we expected a room token but did not get one. Hint: if you are using a callback, ensure the room is passed when creating the token. For more information: https://liveblocks.io/docs/api-reference/liveblocks-client#createClientCallback"
-    );
-  }
-  return {
-    raw: rawTokenString,
-    parsed: payload
-  };
-}
-
 // src/protocol/ClientMsg.ts
 var ClientMsgCode = /* @__PURE__ */ ((ClientMsgCode2) => {
   ClientMsgCode2[ClientMsgCode2["UPDATE_PRESENCE"] = 100] = "UPDATE_PRESENCE";
@@ -3927,20 +4289,6 @@ var ClientMsgCode = /* @__PURE__ */ ((ClientMsgCode2) => {
   return ClientMsgCode2;
 })(ClientMsgCode || {});
 
-// src/protocol/ServerMsg.ts
-var ServerMsgCode = /* @__PURE__ */ ((ServerMsgCode2) => {
-  ServerMsgCode2[ServerMsgCode2["UPDATE_PRESENCE"] = 100] = "UPDATE_PRESENCE";
-  ServerMsgCode2[ServerMsgCode2["USER_JOINED"] = 101] = "USER_JOINED";
-  ServerMsgCode2[ServerMsgCode2["USER_LEFT"] = 102] = "USER_LEFT";
-  ServerMsgCode2[ServerMsgCode2["BROADCASTED_EVENT"] = 103] = "BROADCASTED_EVENT";
-  ServerMsgCode2[ServerMsgCode2["ROOM_STATE"] = 104] = "ROOM_STATE";
-  ServerMsgCode2[ServerMsgCode2["INITIAL_STORAGE_STATE"] = 200] = "INITIAL_STORAGE_STATE";
-  ServerMsgCode2[ServerMsgCode2["UPDATE_STORAGE"] = 201] = "UPDATE_STORAGE";
-  ServerMsgCode2[ServerMsgCode2["REJECT_STORAGE_OP"] = 299] = "REJECT_STORAGE_OP";
-  ServerMsgCode2[ServerMsgCode2["UPDATE_YDOC"] = 300] = "UPDATE_YDOC";
-  return ServerMsgCode2;
-})(ServerMsgCode || {});
-
 // src/lib/LegacyArray.ts
 function asArrayWithLegacyMethods(arr) {
   Object.defineProperty(arr, "count", {
@@ -3992,7 +4340,19 @@ var ImmutableRef = class {
 
 // src/refs/OthersRef.ts
 function makeUser(conn, presence) {
-  return freeze(compactObject({ ...conn, presence }));
+  const { connectionId, id, info } = conn;
+  const canWrite = canWriteStorage(conn.scopes);
+  return freeze(
+    compactObject({
+      connectionId,
+      id,
+      info,
+      canWrite,
+      isReadOnly: !canWrite,
+      // Deprecated, kept for backward-compatibility
+      presence
+    })
+  );
 }
 var OthersRef = class extends ImmutableRef {
   //
@@ -4000,50 +4360,53 @@ var OthersRef = class extends ImmutableRef {
   //
   constructor() {
     super();
-    this._connections = {};
-    this._presences = {};
-    this._users = {};
+    this._connections = /* @__PURE__ */ new Map();
+    this._presences = /* @__PURE__ */ new Map();
+    this._users = /* @__PURE__ */ new Map();
+  }
+  connectionIds() {
+    return this._connections.keys();
   }
   /** @internal */
   _toImmutable() {
     const users = compact(
-      Object.keys(this._presences).map(
+      Array.from(this._presences.keys()).map(
         (connectionId) => this.getUser(Number(connectionId))
       )
     );
     return asArrayWithLegacyMethods(users);
   }
   clearOthers() {
-    this._connections = {};
-    this._presences = {};
-    this._users = {};
+    this._connections = /* @__PURE__ */ new Map();
+    this._presences = /* @__PURE__ */ new Map();
+    this._users = /* @__PURE__ */ new Map();
     this.invalidate();
   }
   /** @internal */
   _getUser(connectionId) {
-    const conn = this._connections[connectionId];
-    const presence = this._presences[connectionId];
+    const conn = this._connections.get(connectionId);
+    const presence = this._presences.get(connectionId);
     if (conn !== void 0 && presence !== void 0) {
       return makeUser(conn, presence);
     }
     return void 0;
   }
   getUser(connectionId) {
-    const cachedUser = this._users[connectionId];
+    const cachedUser = this._users.get(connectionId);
     if (cachedUser) {
       return cachedUser;
     }
     const computedUser = this._getUser(connectionId);
     if (computedUser) {
-      this._users[connectionId] = computedUser;
+      this._users.set(connectionId, computedUser);
       return computedUser;
     }
     return void 0;
   }
   /** @internal */
   _invalidateUser(connectionId) {
-    if (this._users[connectionId] !== void 0) {
-      delete this._users[connectionId];
+    if (this._users.has(connectionId)) {
+      this._users.delete(connectionId);
     }
     this.invalidate();
   }
@@ -4051,14 +4414,17 @@ var OthersRef = class extends ImmutableRef {
    * Records a known connection. This records the connection ID and the
    * associated metadata.
    */
-  setConnection(connectionId, metaUserId, metaUserInfo, metaIsReadonly) {
-    this._connections[connectionId] = freeze({
+  setConnection(connectionId, metaUserId, metaUserInfo, scopes) {
+    this._connections.set(
       connectionId,
-      id: metaUserId,
-      info: metaUserInfo,
-      isReadOnly: metaIsReadonly
-    });
-    if (this._presences[connectionId] !== void 0) {
+      freeze({
+        connectionId,
+        id: metaUserId,
+        info: metaUserInfo,
+        scopes
+      })
+    );
+    if (this._presences.has(connectionId)) {
       this._invalidateUser(connectionId);
     }
   }
@@ -4067,8 +4433,8 @@ var OthersRef = class extends ImmutableRef {
    * the presence information.
    */
   removeConnection(connectionId) {
-    delete this._connections[connectionId];
-    delete this._presences[connectionId];
+    this._connections.delete(connectionId);
+    this._presences.delete(connectionId);
     this._invalidateUser(connectionId);
   }
   /**
@@ -4076,8 +4442,8 @@ var OthersRef = class extends ImmutableRef {
    * its known presence data is overwritten.
    */
   setOther(connectionId, presence) {
-    this._presences[connectionId] = freeze(compactObject(presence));
-    if (this._connections[connectionId] !== void 0) {
+    this._presences.set(connectionId, freeze(compactObject(presence)));
+    if (this._connections.has(connectionId)) {
       this._invalidateUser(connectionId);
     }
   }
@@ -4087,13 +4453,13 @@ var OthersRef = class extends ImmutableRef {
    * full .setOther() call first.
    */
   patchOther(connectionId, patch) {
-    const oldPresence = this._presences[connectionId];
+    const oldPresence = this._presences.get(connectionId);
     if (oldPresence === void 0) {
       return;
     }
     const newPresence = merge(oldPresence, patch);
     if (oldPresence !== newPresence) {
-      this._presences[connectionId] = freeze(newPresence);
+      this._presences.set(connectionId, freeze(newPresence));
       this._invalidateUser(connectionId);
     }
   }
@@ -4173,17 +4539,7 @@ function userToTreeNode(key, user) {
 function createRoom(options, config) {
   const initialPresence = typeof options.initialPresence === "function" ? options.initialPresence(config.roomId) : options.initialPresence;
   const initialStorage = typeof options.initialStorage === "function" ? options.initialStorage(config.roomId) : options.initialStorage;
-  const delegates = config.delegates ?? {
-    authenticate: makeAuthDelegateForRoom(
-      config.roomId,
-      config.authentication,
-      config.polyfills?.fetch
-    ),
-    createSocket: makeCreateSocketDelegateForRoom(
-      config.liveblocksServer,
-      config.polyfills?.WebSocket
-    )
-  };
+  const delegates = config.delegates;
   const managedSocket = new ManagedSocket(
     delegates,
     config.enableDebugLogging
@@ -4202,8 +4558,9 @@ function createRoom(options, config) {
       messages: [],
       storageOperations: []
     },
-    sessionInfo: new ValueRef(null),
-    me: new PatchableRef(initialPresence),
+    staticSessionInfo: new ValueRef(null),
+    dynamicSessionInfo: new ValueRef(null),
+    myPresence: new PatchableRef(initialPresence),
     others: new OthersRef(),
     initialStorage,
     idFactory: null,
@@ -4222,18 +4579,26 @@ function createRoom(options, config) {
   };
   const doNotBatchUpdates = (cb) => cb();
   const batchUpdates = config.unstable_batchedUpdates ?? doNotBatchUpdates;
-  let lastToken;
+  let lastTokenKey;
   function onStatusDidChange(newStatus) {
-    const token = managedSocket.token?.parsed;
-    if (token !== void 0 && token !== lastToken) {
-      context.sessionInfo.set({
-        userInfo: token.info,
-        userId: token.id,
-        // NOTE: In the future, these fields will get assigned in the connection phase
-        actor: token.actor,
-        isReadOnly: isStorageReadOnly(token.scopes)
-      });
-      lastToken = token;
+    const authValue = managedSocket.authValue;
+    if (authValue !== null) {
+      const tokenKey = authValue.type === "secret" ? authValue.token.raw : authValue.publicApiKey;
+      if (tokenKey !== lastTokenKey) {
+        lastTokenKey = tokenKey;
+        if (authValue.type === "secret") {
+          const token = authValue.token.parsed;
+          context.staticSessionInfo.set({
+            userId: token.k === "sec-legacy" /* SECRET_LEGACY */ ? token.id : token.uid,
+            userInfo: token.k === "sec-legacy" /* SECRET_LEGACY */ ? token.info : token.ui
+          });
+        } else {
+          context.staticSessionInfo.set({
+            userId: void 0,
+            userInfo: void 0
+          });
+        }
+      }
     }
     batchUpdates(() => {
       eventHub.status.notify(newStatus);
@@ -4270,20 +4635,15 @@ function createRoom(options, config) {
     }
   }
   function onDidConnect() {
-    const sessionInfo = context.sessionInfo.current;
-    if (sessionInfo === null) {
-      throw new Error("Unexpected missing session info");
-    }
     context.buffer.presenceUpdates = {
       type: "full",
       data: (
         // Because context.me.current is a readonly object, we'll have to
         // make a copy here. Otherwise, type errors happen later when
         // "patching" my presence.
-        { ...context.me.current }
+        { ...context.myPresence.current }
       )
     };
-    context.idFactory = makeIdFactory(sessionInfo.actor);
     if (_getStorage$ !== null) {
       refreshStorage({ flush: false });
     }
@@ -4348,7 +4708,12 @@ function createRoom(options, config) {
       }
     },
     assertStorageIsWritable: () => {
-      if (context.sessionInfo.current?.isReadOnly) {
+      const scopes = context.dynamicSessionInfo.current?.scopes;
+      if (scopes === void 0) {
+        return;
+      }
+      const canWrite = canWriteStorage(scopes);
+      if (!canWrite) {
         throw new Error(
           "Cannot write to storage with a read only user, please ensure the user has write permissions"
         );
@@ -4376,10 +4741,11 @@ function createRoom(options, config) {
     const message = JSON.stringify(messageOrMessages);
     if (config.unstable_fallbackToHTTP) {
       const size = new TextEncoder().encode(message).length;
-      if (size > MAX_MESSAGE_SIZE && managedSocket.token?.raw && config.httpSendEndpoint) {
+      if (size > MAX_MESSAGE_SIZE && // TODO: support public api key auth in REST API
+      managedSocket.authValue?.type === "secret" && config.httpSendEndpoint) {
         void httpSend(
           message,
-          managedSocket.token.raw,
+          managedSocket.authValue.token.raw,
           config.httpSendEndpoint,
           config.polyfills?.fetch
         ).then((resp) => {
@@ -4396,16 +4762,24 @@ function createRoom(options, config) {
     managedSocket.send(message);
   }
   const self = new DerivedRef(
-    context.sessionInfo,
-    context.me,
-    (info, me) => {
-      return info !== null ? {
-        connectionId: info.actor,
-        id: info.userId,
-        info: info.userInfo,
-        presence: me,
-        isReadOnly: info.isReadOnly
-      } : null;
+    context.staticSessionInfo,
+    context.dynamicSessionInfo,
+    context.myPresence,
+    (staticSession, dynamicSession, myPresence) => {
+      if (staticSession === null || dynamicSession === null) {
+        return null;
+      } else {
+        const canWrite = canWriteStorage(dynamicSession.scopes);
+        return {
+          connectionId: dynamicSession.actor,
+          id: staticSession.userId,
+          info: staticSession.userInfo,
+          presence: myPresence,
+          canWrite,
+          isReadOnly: !canWrite
+          // Deprecated, kept for backward-compatibility
+        };
+      }
     }
   );
   let _lastSelf;
@@ -4477,7 +4851,7 @@ function createRoom(options, config) {
       }
       if (presence) {
         notifySelfChanged(doNotBatchUpdates);
-        eventHub.myPresence.notify(context.me.current);
+        eventHub.myPresence.notify(context.myPresence.current);
       }
       if (storageUpdates.size > 0) {
         const updates = Array.from(storageUpdates.values());
@@ -4487,7 +4861,7 @@ function createRoom(options, config) {
     });
   }
   function getConnectionId() {
-    const info = context.sessionInfo.current;
+    const info = context.dynamicSessionInfo.current;
     if (info) {
       return info.actor;
     }
@@ -4516,9 +4890,9 @@ function createRoom(options, config) {
           data: {}
         };
         for (const key in op.data) {
-          reverse.data[key] = context.me.current[key];
+          reverse.data[key] = context.myPresence.current[key];
         }
-        context.me.patch(op.data);
+        context.myPresence.patch(op.data);
         if (context.buffer.presenceUpdates === null) {
           context.buffer.presenceUpdates = { type: "partial", data: op.data };
         } else {
@@ -4625,9 +4999,9 @@ function createRoom(options, config) {
         continue;
       }
       context.buffer.presenceUpdates.data[key] = overrideValue;
-      oldValues[key] = context.me.current[key];
+      oldValues[key] = context.myPresence.current[key];
     }
-    context.me.patch(patch);
+    context.myPresence.patch(patch);
     if (context.activeBatch) {
       if (options2?.addToHistory) {
         context.activeBatch.reverseOps.unshift({
@@ -4649,9 +5023,6 @@ function createRoom(options, config) {
       });
     }
   }
-  function isStorageReadOnly(scopes) {
-    return scopes.includes("room:read" /* Read */) && scopes.includes("room:presence:write" /* PresenceWrite */) && !scopes.includes("room:write" /* Write */);
-  }
   function onUpdatePresenceMessage(message) {
     if (message.targetActor !== void 0) {
       const oldUser = context.others.getUser(message.actor);
@@ -4682,11 +5053,17 @@ function createRoom(options, config) {
     }
     return null;
   }
-  function onRoomStateMessage(message) {
-    for (const connectionId in context.others._connections) {
+  function onRoomStateMessage(message, batchedUpdatesWrapper) {
+    context.dynamicSessionInfo.set({
+      actor: message.actor,
+      scopes: message.scopes
+    });
+    context.idFactory = makeIdFactory(message.actor);
+    notifySelfChanged(batchedUpdatesWrapper);
+    for (const connectionId of context.others.connectionIds()) {
       const user = message.users[connectionId];
       if (user === void 0) {
-        context.others.removeConnection(Number(connectionId));
+        context.others.removeConnection(connectionId);
       }
     }
     for (const key in message.users) {
@@ -4696,7 +5073,7 @@ function createRoom(options, config) {
         connectionId,
         user.id,
         user.info,
-        isStorageReadOnly(user.scopes)
+        user.scopes
       );
     }
     return { type: "reset" };
@@ -4717,11 +5094,11 @@ function createRoom(options, config) {
       message.actor,
       message.id,
       message.info,
-      isStorageReadOnly(message.scopes)
+      message.scopes
     );
     context.buffer.messages.push({
       type: 100 /* UPDATE_PRESENCE */,
-      data: context.me.current,
+      data: context.myPresence.current,
       targetActor: message.actor
     });
     flushNowOrSoon();
@@ -4806,7 +5183,7 @@ function createRoom(options, config) {
             break;
           }
           case 104 /* ROOM_STATE */: {
-            updates.others.push(onRoomStateMessage(message));
+            updates.others.push(onRoomStateMessage(message, doNotBatchUpdates));
             break;
           }
           case 200 /* INITIAL_STORAGE_STATE */: {
@@ -5173,10 +5550,9 @@ ${Array.from(traces).join("\n\n")}`
       // Core
       getStatus: () => managedSocket.getStatus(),
       getConnectionState: () => managedSocket.getLegacyStatus(),
-      isSelfAware: () => context.sessionInfo.current !== null,
       getSelf: () => self.current,
       // Presence
-      getPresence: () => context.me.current,
+      getPresence: () => context.myPresence.current,
       getOthers: () => context.others.current
     },
     // Explictly make the __internal field non-enumerable, to avoid aggressive
@@ -5271,18 +5647,30 @@ function makeClassicSubscribeFn(events) {
 function isRoomEventName(value) {
   return value === "my-presence" || value === "others" || value === "event" || value === "error" || value === "history" || value === "status" || value === "storage-status" || value === "lost-connection" || value === "connection";
 }
-function makeCreateSocketDelegateForRoom(liveblocksServer, WebSocketPolyfill) {
-  return (richToken) => {
+function makeAuthDelegateForRoom(roomId, authManager) {
+  return async () => {
+    return authManager.getAuthValue("room:read", roomId);
+  };
+}
+function makeCreateSocketDelegateForRoom(roomId, liveblocksServer, WebSocketPolyfill) {
+  return (authValue) => {
     const ws = WebSocketPolyfill ?? (typeof WebSocket === "undefined" ? void 0 : WebSocket);
     if (ws === void 0) {
       throw new StopRetrying(
         "To use Liveblocks client in a non-dom environment, you need to provide a WebSocket polyfill."
       );
     }
-    const token = richToken.raw;
-    return new ws(
-      `${liveblocksServer}/?token=${token}&version=${PKG_VERSION || "dev"}`
-    );
+    const url = new URL(liveblocksServer);
+    url.searchParams.set("roomId", roomId);
+    if (authValue.type === "secret") {
+      url.searchParams.set("tok", authValue.token.raw);
+    } else if (authValue.type === "public") {
+      url.searchParams.set("pubkey", authValue.publicApiKey);
+    } else {
+      return assertNever(authValue, "Unhandled case");
+    }
+    url.searchParams.set("version", PKG_VERSION || "dev");
+    return new ws(url.toString());
   };
 }
 async function httpSend(message, token, endpoint, fetchPolyfill) {
@@ -5297,96 +5685,6 @@ async function httpSend(message, token, endpoint, fetchPolyfill) {
     body: message
   });
 }
-function makeAuthDelegateForRoom(roomId, authentication, fetchPolyfill) {
-  const fetcher = fetchPolyfill ?? (typeof window === "undefined" ? void 0 : window.fetch);
-  if (authentication.type === "public") {
-    return async () => {
-      if (fetcher === void 0) {
-        throw new StopRetrying(
-          "To use Liveblocks client in a non-dom environment with a publicApiKey, you need to provide a fetch polyfill."
-        );
-      }
-      return fetchAuthEndpoint(fetcher, authentication.url, {
-        room: roomId,
-        publicApiKey: authentication.publicApiKey
-      }).then(({ token }) => parseAuthToken(token));
-    };
-  } else if (authentication.type === "private") {
-    return async () => {
-      if (fetcher === void 0) {
-        throw new StopRetrying(
-          "To use Liveblocks client in a non-dom environment with a url as auth endpoint, you need to provide a fetch polyfill."
-        );
-      }
-      return fetchAuthEndpoint(fetcher, authentication.url, {
-        room: roomId
-      }).then(({ token }) => parseAuthToken(token));
-    };
-  } else if (authentication.type === "custom") {
-    return async () => {
-      const response = await authentication.callback(roomId);
-      if (!response || typeof response !== "object") {
-        throw new Error(
-          'We expect the authentication callback to return a token, but it does not. Hint: the return value should look like: { token: "..." }'
-        );
-      }
-      if (typeof response.token === "string") {
-        return parseAuthToken(response.token);
-      } else if (typeof response.error === "string") {
-        const reason = `Authentication failed: ${"reason" in response && typeof response.reason === "string" ? response.reason : "Forbidden"}`;
-        if (response.error === "forbidden") {
-          throw new StopRetrying(reason);
-        } else {
-          throw new Error(reason);
-        }
-      } else {
-        throw new Error(
-          'We expect the authentication callback to return a token, but it does not. Hint: the return value should look like: { token: "..." }'
-        );
-      }
-    };
-  } else {
-    throw new Error("Internal error. Unexpected authentication type");
-  }
-}
-async function fetchAuthEndpoint(fetch2, endpoint, body) {
-  const res = await fetch2(endpoint, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json"
-    },
-    // Credentials are needed to support authentication with cookies
-    credentials: "include",
-    body: JSON.stringify(body)
-  });
-  if (!res.ok) {
-    const reason = `${(await res.text()).trim() || "reason not provided in auth response"} (${res.status} returned by POST ${endpoint})`;
-    if (res.status === 401 || res.status === 403) {
-      throw new StopRetrying(`Unauthorized: ${reason}`);
-    } else {
-      throw new Error(`Failed to authenticate: ${reason}`);
-    }
-  }
-  let data;
-  try {
-    data = await res.json();
-  } catch (er) {
-    throw new Error(
-      `Expected a JSON response when doing a POST request on "${endpoint}". ${String(
-        er
-      )}`
-    );
-  }
-  if (!isPlainObject(data) || typeof data.token !== "string") {
-    throw new Error(
-      `Expected a JSON response of the form \`{ token: "..." }\` when doing a POST request on "${endpoint}", but got ${JSON.stringify(
-        data
-      )}`
-    );
-  }
-  const { token } = data;
-  return { token };
-}
 
 // src/client.ts
 var MIN_THROTTLE = 16;
@@ -5398,7 +5696,7 @@ var MAX_LOST_CONNECTION_TIMEOUT = 3e4;
 var DEFAULT_LOST_CONNECTION_TIMEOUT = 5e3;
 function getServerFromClientOptions(clientOptions) {
   const rawOptions = clientOptions;
-  return typeof rawOptions.liveblocksServer === "string" ? rawOptions.liveblocksServer : "wss://api.liveblocks.io/v6";
+  return typeof rawOptions.liveblocksServer === "string" ? rawOptions.liveblocksServer : "wss://api.liveblocks.io/v7";
 }
 function createClient(options) {
   const clientOptions = options;
@@ -5406,6 +5704,7 @@ function createClient(options) {
   const lostConnectionTimeout = getLostConnectionTimeout(
     clientOptions.lostConnectionTimeout ?? DEFAULT_LOST_CONNECTION_TIMEOUT
   );
+  const authManager = createAuthManager(options);
   const rooms = /* @__PURE__ */ new Map();
   function getRoom(roomId) {
     const room = rooms.get(roomId);
@@ -5430,11 +5729,17 @@ function createClient(options) {
         throttleDelay,
         lostConnectionTimeout,
         polyfills: clientOptions.polyfills,
-        delegates: clientOptions.mockedDelegates,
+        delegates: clientOptions.mockedDelegates ?? {
+          createSocket: makeCreateSocketDelegateForRoom(
+            roomId,
+            getServerFromClientOptions(clientOptions),
+            clientOptions.polyfills?.WebSocket
+          ),
+          authenticate: makeAuthDelegateForRoom(roomId, authManager)
+        },
         enableDebugLogging: clientOptions.enableDebugLogging,
         unstable_batchedUpdates: options2?.unstable_batchedUpdates,
         liveblocksServer: getServerFromClientOptions(clientOptions),
-        authentication: prepareAuthentication(clientOptions, roomId),
         httpSendEndpoint: buildLiveblocksHttpSendEndpoint(
           clientOptions,
           roomId
@@ -5468,6 +5773,13 @@ function createClient(options) {
     }
   }
   return {
+    __internal: {
+      getAuthValue: authManager.getAuthValue,
+      realtimeClient: createRealtimeClient(
+        authManager,
+        getWsEventServerEndpoint(options)
+      )
+    },
     getRoom,
     enter,
     leave
@@ -5493,48 +5805,6 @@ function getLostConnectionTimeout(value) {
     RECOMMENDED_MIN_LOST_CONNECTION_TIMEOUT
   );
 }
-function prepareAuthentication(clientOptions, roomId) {
-  const { publicApiKey, authEndpoint } = clientOptions;
-  if (authEndpoint !== void 0 && publicApiKey !== void 0) {
-    throw new Error(
-      "You cannot use both publicApiKey and authEndpoint. Please use either publicApiKey or authEndpoint, but not both. For more information: https://liveblocks.io/docs/api-reference/liveblocks-client#createClient"
-    );
-  }
-  if (typeof publicApiKey === "string") {
-    if (publicApiKey.startsWith("sk_")) {
-      throw new Error(
-        "Invalid publicApiKey. You are using the secret key which is not supported. Please use the public key instead. For more information: https://liveblocks.io/docs/api-reference/liveblocks-client#createClientPublicKey"
-      );
-    } else if (!publicApiKey.startsWith("pk_")) {
-      throw new Error(
-        "Invalid key. Please use the public key format: pk_<public key>. For more information: https://liveblocks.io/docs/api-reference/liveblocks-client#createClientPublicKey"
-      );
-    }
-    return {
-      type: "public",
-      publicApiKey,
-      url: buildLiveblocksPublicAuthorizeEndpoint(clientOptions, roomId)
-    };
-  }
-  if (typeof authEndpoint === "string") {
-    return {
-      type: "private",
-      url: authEndpoint
-    };
-  } else if (typeof authEndpoint === "function") {
-    return {
-      type: "custom",
-      callback: authEndpoint
-    };
-  } else if (authEndpoint !== void 0) {
-    throw new Error(
-      "authEndpoint must be a string or a function. For more information: https://liveblocks.io/docs/api-reference/liveblocks-client#createClientAuthEndpoint"
-    );
-  }
-  throw new Error(
-    "Invalid Liveblocks client options. For more information: https://liveblocks.io/docs/api-reference/liveblocks-client#createClient"
-  );
-}
 function buildLiveblocksHttpSendEndpoint(options, roomId) {
   if (options.httpSendEndpoint) {
     return options.httpSendEndpoint.replace("{roomId}", roomId);
@@ -5543,13 +5813,11 @@ function buildLiveblocksHttpSendEndpoint(options, roomId) {
     roomId
   )}/send-message`;
 }
-function buildLiveblocksPublicAuthorizeEndpoint(options, roomId) {
-  if (options.publicAuthorizeEndpoint) {
-    return options.publicAuthorizeEndpoint.replace("{roomId}", roomId);
+function getWsEventServerEndpoint(options) {
+  if (typeof options.eventsServerEndpoint === "string") {
+    return options.eventsServerEndpoint;
   }
-  return `https://api.liveblocks.io/v2/rooms/${encodeURIComponent(
-    roomId
-  )}/public/authorize`;
+  return `wss://events.liveblocks.io/v1`;
 }
 
 // src/crdts/utils.ts
@@ -5923,18 +6191,378 @@ function shallow(a, b) {
   return shallowObj(a, b);
 }
 
-// src/types/IWebSocket.ts
-var WebsocketCloseCodes = /* @__PURE__ */ ((WebsocketCloseCodes2) => {
-  WebsocketCloseCodes2[WebsocketCloseCodes2["CLOSE_ABNORMAL"] = 1006] = "CLOSE_ABNORMAL";
-  WebsocketCloseCodes2[WebsocketCloseCodes2["INVALID_MESSAGE_FORMAT"] = 4e3] = "INVALID_MESSAGE_FORMAT";
-  WebsocketCloseCodes2[WebsocketCloseCodes2["NOT_ALLOWED"] = 4001] = "NOT_ALLOWED";
-  WebsocketCloseCodes2[WebsocketCloseCodes2["MAX_NUMBER_OF_MESSAGES_PER_SECONDS"] = 4002] = "MAX_NUMBER_OF_MESSAGES_PER_SECONDS";
-  WebsocketCloseCodes2[WebsocketCloseCodes2["MAX_NUMBER_OF_CONCURRENT_CONNECTIONS"] = 4003] = "MAX_NUMBER_OF_CONCURRENT_CONNECTIONS";
-  WebsocketCloseCodes2[WebsocketCloseCodes2["MAX_NUMBER_OF_MESSAGES_PER_DAY_PER_APP"] = 4004] = "MAX_NUMBER_OF_MESSAGES_PER_DAY_PER_APP";
-  WebsocketCloseCodes2[WebsocketCloseCodes2["MAX_NUMBER_OF_CONCURRENT_CONNECTIONS_PER_ROOM"] = 4005] = "MAX_NUMBER_OF_CONCURRENT_CONNECTIONS_PER_ROOM";
-  WebsocketCloseCodes2[WebsocketCloseCodes2["CLOSE_WITHOUT_RETRY"] = 4999] = "CLOSE_WITHOUT_RETRY";
-  return WebsocketCloseCodes2;
-})(WebsocketCloseCodes || {});
+// src/lib/AsyncCache.ts
+var noop = () => {
+};
+function isShallowEqual(a, b) {
+  if (a.isLoading !== b.isLoading || a.data === void 0 !== (b.data === void 0) || a.error === void 0 !== (b.error === void 0)) {
+    return false;
+  } else {
+    return shallow(a.data, b.data) && shallow(a.error, b.error);
+  }
+}
+function createCacheItem(key, defaultAsyncFunction, options) {
+  let asyncFunction = defaultAsyncFunction;
+  const context = {
+    isInvalid: true
+  };
+  let state = { isLoading: false };
+  let previousState = { isLoading: false };
+  const eventSource2 = makeEventSource();
+  function notify() {
+    const isEqual = options?.isStateEqual ?? isShallowEqual;
+    if (!isEqual(previousState, state)) {
+      previousState = state;
+      eventSource2.notify(state);
+    }
+  }
+  async function resolve() {
+    if (!context.promise) {
+      return;
+    }
+    try {
+      const data = await context.promise;
+      context.isInvalid = false;
+      state = {
+        isLoading: false,
+        data
+      };
+    } catch (error3) {
+      state = {
+        isLoading: false,
+        data: state.data,
+        error: error3
+      };
+    }
+    context.promise = void 0;
+    notify();
+  }
+  async function revalidate() {
+    context.isInvalid = true;
+    return get();
+  }
+  async function get() {
+    if (context.isInvalid) {
+      if (!context.promise) {
+        context.isInvalid = true;
+        context.promise = asyncFunction(key);
+        state = { isLoading: true, data: state.data };
+        notify();
+      }
+      await resolve();
+    }
+    return getState();
+  }
+  function getState() {
+    return state;
+  }
+  function setAsyncFunction(overrideAsyncFunction) {
+    asyncFunction = overrideAsyncFunction;
+  }
+  return {
+    ...eventSource2.observable,
+    setAsyncFunction,
+    get,
+    getState,
+    revalidate
+  };
+}
+function createAsyncCache(asyncFunction, options) {
+  const cache = /* @__PURE__ */ new Map();
+  function create(key, overrideAsyncFunction) {
+    let cacheItem = cache.get(key);
+    if (cacheItem) {
+      if (overrideAsyncFunction) {
+        cacheItem.setAsyncFunction(overrideAsyncFunction);
+      }
+      return cacheItem;
+    }
+    cacheItem = createCacheItem(
+      key,
+      overrideAsyncFunction ?? asyncFunction,
+      options
+    );
+    cache.set(key, cacheItem);
+    return cacheItem;
+  }
+  function get(key) {
+    return create(key).get();
+  }
+  function getState(key) {
+    return cache.get(key)?.getState();
+  }
+  function revalidate(key) {
+    return create(key).revalidate();
+  }
+  function subscribe(key, callback) {
+    return create(key).subscribe(callback) ?? noop;
+  }
+  function subscribeOnce(key, callback) {
+    return create(key).subscribeOnce(callback) ?? noop;
+  }
+  function has(key) {
+    return cache.has(key);
+  }
+  function clear() {
+    cache.clear();
+  }
+  return {
+    create,
+    get,
+    getState,
+    revalidate,
+    subscribe,
+    subscribeOnce,
+    has,
+    clear
+  };
+}
+
+// src/lib/Poller.ts
+function makePoller(callback) {
+  let context = {
+    state: "stopped",
+    timeoutHandle: null,
+    interval: null,
+    lastScheduledAt: null,
+    remainingInterval: null
+  };
+  function poll() {
+    if (context.state === "running") {
+      schedule(context.interval);
+    }
+    callback();
+  }
+  function schedule(interval) {
+    context = {
+      state: "running",
+      interval: context.state !== "stopped" ? context.interval : interval,
+      lastScheduledAt: performance.now(),
+      timeoutHandle: setTimeout(poll, interval),
+      remainingInterval: null
+    };
+  }
+  function scheduleRemaining(remaining) {
+    if (context.state !== "paused") {
+      return;
+    }
+    context = {
+      state: "running",
+      interval: context.interval,
+      lastScheduledAt: context.lastScheduledAt,
+      timeoutHandle: setTimeout(poll, remaining),
+      remainingInterval: null
+    };
+  }
+  function start(interval) {
+    if (context.state === "running") {
+      return;
+    }
+    schedule(interval);
+  }
+  function restart(interval) {
+    stop();
+    start(interval);
+  }
+  function pause() {
+    if (context.state !== "running") {
+      return;
+    }
+    clearTimeout(context.timeoutHandle);
+    context = {
+      state: "paused",
+      interval: context.interval,
+      lastScheduledAt: context.lastScheduledAt,
+      timeoutHandle: null,
+      remainingInterval: context.interval - (performance.now() - context.lastScheduledAt)
+    };
+  }
+  function resume() {
+    if (context.state !== "paused") {
+      return;
+    }
+    scheduleRemaining(context.remainingInterval);
+  }
+  function stop() {
+    if (context.state === "stopped") {
+      return;
+    }
+    if (context.timeoutHandle) {
+      clearTimeout(context.timeoutHandle);
+    }
+    context = {
+      state: "stopped",
+      interval: null,
+      lastScheduledAt: null,
+      timeoutHandle: null,
+      remainingInterval: null
+    };
+  }
+  return {
+    start,
+    restart,
+    pause,
+    resume,
+    stop
+  };
+}
+
+// src/comments/index.ts
+function createCommentsApi(client, { serverEndpoint }) {
+  async function fetchJson(roomId, endpoint, options) {
+    const response = await fetchApi(roomId, endpoint, options);
+    if (!response.ok) {
+      if (response.status >= 400 && response.status < 600) {
+        let errorMessage = "";
+        try {
+          const errorBody = await response.json();
+          errorMessage = errorBody.message;
+        } catch (error3) {
+          errorMessage = response.statusText;
+        }
+        throw new Error(
+          `Request failed with status ${response.status}: ${errorMessage}`
+        );
+      }
+    }
+    let body;
+    try {
+      body = await response.json();
+    } catch {
+      body = {};
+    }
+    return body;
+  }
+  async function fetchApi(roomId, endpoint, options) {
+    const authValue = await client.__internal.getAuthValue(
+      "comments:read",
+      // TODO: Use the right scope
+      roomId
+    );
+    if (authValue.type !== "secret") {
+      throw new Error("Only secret key are supported for client.");
+    }
+    const url = `${serverEndpoint}/rooms/${roomId}${endpoint}`;
+    return await fetch(url, {
+      ...options,
+      headers: {
+        ...options?.headers,
+        Authorization: `Bearer ${authValue.token.raw}`
+      }
+    });
+  }
+  async function getThreads({
+    roomId
+  }) {
+    const response = await fetchApi(roomId, "/threads");
+    if (response.ok) {
+      const json = await response.json();
+      return json.data;
+    } else if (response.status === 404) {
+      return [];
+    } else {
+      throw new Error("FAIL");
+    }
+  }
+  function createThread({
+    roomId,
+    metadata,
+    body,
+    commentId,
+    threadId
+  }) {
+    return fetchJson(roomId, "/threads", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        id: threadId,
+        comment: {
+          id: commentId,
+          body
+        },
+        metadata
+      })
+    });
+  }
+  function editThreadMetadata({
+    roomId,
+    metadata,
+    threadId
+  }) {
+    return fetchJson(
+      roomId,
+      `/threads/${threadId}/metadata`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(metadata)
+      }
+    );
+  }
+  function createComment({
+    roomId,
+    threadId,
+    commentId,
+    body
+  }) {
+    return fetchJson(roomId, `/threads/${threadId}/comments`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        id: commentId,
+        body
+      })
+    });
+  }
+  function editComment({
+    roomId,
+    threadId,
+    commentId,
+    body
+  }) {
+    return fetchJson(
+      roomId,
+      `/threads/${threadId}/comments/${commentId}`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          body
+        })
+      }
+    );
+  }
+  async function deleteComment({
+    roomId,
+    threadId,
+    commentId
+  }) {
+    await fetchJson(roomId, `/threads/${threadId}/comments/${commentId}`, {
+      method: "DELETE"
+    });
+  }
+  return {
+    getThreads,
+    createThread,
+    editThreadMetadata,
+    createComment,
+    editComment,
+    deleteComment
+  };
+}
+
+// src/comments/utils.ts
+function isCommentBodyMention(element) {
+  return "type" in element && element.type === "mention";
+}
 
 // src/index.ts
 detectDupes(PKG_NAME, PKG_VERSION, PKG_FORMAT);
@@ -5952,13 +6580,17 @@ export {
   assert,
   assertNever,
   b64decode,
+  fancy_console_exports as console,
+  createAsyncCache,
   createClient,
+  createCommentsApi,
   deprecate,
   deprecateIf,
   detectDupes,
   errorIf,
   freeze,
   isChildCrdt,
+  isCommentBodyMention,
   isJsonArray,
   isJsonObject,
   isJsonScalar,
@@ -5966,6 +6598,8 @@ export {
   isRootCrdt,
   legacy_patchImmutableObject,
   lsonToJson,
+  makeEventSource,
+  makePoller,
   makePosition,
   nn,
   patchLiveObjectKey,