@liveblocks/core 1.1.8 → 1.2.0-comments1

package/dist/index.js

@@ -1,6 +1,12 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/version.ts
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }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-comments1";
 var PKG_FORMAT = "cjs";
 
 // 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 (!(_optionalChain([options, 'optionalAccess', _3 => _3.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 && _optionalChain([event, 'access', _4 => _4.data, 'optionalAccess', _5 => _5.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 = _nullishCoalesce(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: _nullishCoalesce(_optionalChain([root, 'optionalAccess', _6 => _6.toTreeNode, 'call', _7 => _7("root"), 'access', _8 => _8.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) {
@@ -652,7 +466,7 @@ var FSM = class {
     });
   }
   getTargetFn(eventName) {
-    return _optionalChain([this, 'access', _9 => _9.allowedTransitions, 'access', _10 => _10.get, 'call', _11 => _11(this.currentState), 'optionalAccess', _12 => _12.get, 'call', _13 => _13(eventName)]);
+    return _optionalChain([this, 'access', _3 => _3.allowedTransitions, 'access', _4 => _4.get, 'call', _5 => _5(this.currentState), 'optionalAccess', _6 => _6.get, 'call', _7 => _7(eventName)]);
   }
   /**
    * Exits the current state, and executes any necessary cleanup functions.
@@ -669,7 +483,7 @@ var FSM = class {
     this.currentContext.allowPatching((patchableContext) => {
       levels = _nullishCoalesce(levels, () => ( this.cleanupStack.length));
       for (let i = 0; i < levels; i++) {
-        _optionalChain([this, 'access', _14 => _14.cleanupStack, 'access', _15 => _15.pop, 'call', _16 => _16(), 'optionalCall', _17 => _17(patchableContext)]);
+        _optionalChain([this, 'access', _8 => _8.cleanupStack, 'access', _9 => _9.pop, 'call', _10 => _10(), 'optionalCall', _11 => _11(patchableContext)]);
       }
     });
   }
@@ -685,7 +499,7 @@ var FSM = class {
     this.currentContext.allowPatching((patchableContext) => {
       for (const pattern of enterPatterns) {
         const enterFn = this.enterFns.get(pattern);
-        const cleanupFn = _optionalChain([enterFn, 'optionalCall', _18 => _18(patchableContext)]);
+        const cleanupFn = _optionalChain([enterFn, 'optionalCall', _12 => _12(patchableContext)]);
         if (typeof cleanupFn === "function") {
           this.cleanupStack.push(cleanupFn);
         } else {
@@ -812,12 +626,51 @@ async function withTimeout(promise, millis, errmsg = "Timed out") {
   return Promise.race([promise, timer$]).finally(() => clearTimeout(timerID));
 }
 
-// src/connection.ts
-function newToLegacyStatus(status) {
-  switch (status) {
-    case "connecting":
-      return "connecting";
-    case "connected":
+// 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":
       return "open";
     case "reconnecting":
       return "unavailable";
@@ -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 (_optionalChain([serverMsg, 'optionalAccess', _13 => _13.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)]
@@ -1156,7 +1042,7 @@ function createConnectionStateMachine(delegates, enableDebugLogging) {
   const sendHeartbeat = {
     target: "@ok.awaiting-pong",
     effect: (ctx) => {
-      _optionalChain([ctx, 'access', _19 => _19.socket, 'optionalAccess', _20 => _20.send, 'call', _21 => _21("ping")]);
+      _optionalChain([ctx, 'access', _14 => _14.socket, 'optionalAccess', _15 => _15.send, 'call', _16 => _16("ping")]);
     }
   };
   machine.addTimedTransition("@ok.connected", HEARTBEAT_INTERVAL, sendHeartbeat).addTransitions("@ok.connected", {
@@ -1191,7 +1077,7 @@ function createConnectionStateMachine(delegates, enableDebugLogging) {
     // socket, or not. So always check to see if the socket is still OPEN or
     // not. When still OPEN, don't transition.
     EXPLICIT_SOCKET_ERROR: (_, context) => {
-      if (_optionalChain([context, 'access', _22 => _22.socket, 'optionalAccess', _23 => _23.readyState]) === 1) {
+      if (_optionalChain([context, 'access', _17 => _17.socket, 'optionalAccess', _18 => _18.readyState]) === 1) {
         return null;
       }
       return {
@@ -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 {
@@ -1243,17 +1129,17 @@ function createConnectionStateMachine(delegates, enableDebugLogging) {
         machine.send({ type: "NAVIGATOR_ONLINE" });
       }
       function onVisibilityChange() {
-        if (_optionalChain([doc, 'optionalAccess', _24 => _24.visibilityState]) === "visible") {
+        if (_optionalChain([doc, 'optionalAccess', _19 => _19.visibilityState]) === "visible") {
           machine.send({ type: "WINDOW_GOT_FOCUS" });
         }
       }
-      _optionalChain([win, 'optionalAccess', _25 => _25.addEventListener, 'call', _26 => _26("online", onNetworkBackOnline)]);
-      _optionalChain([win, 'optionalAccess', _27 => _27.addEventListener, 'call', _28 => _28("offline", onNetworkOffline)]);
-      _optionalChain([root, 'optionalAccess', _29 => _29.addEventListener, 'call', _30 => _30("visibilitychange", onVisibilityChange)]);
+      _optionalChain([win, 'optionalAccess', _20 => _20.addEventListener, 'call', _21 => _21("online", onNetworkBackOnline)]);
+      _optionalChain([win, 'optionalAccess', _22 => _22.addEventListener, 'call', _23 => _23("offline", onNetworkOffline)]);
+      _optionalChain([root, 'optionalAccess', _24 => _24.addEventListener, 'call', _25 => _25("visibilitychange", onVisibilityChange)]);
       return () => {
-        _optionalChain([root, 'optionalAccess', _31 => _31.removeEventListener, 'call', _32 => _32("visibilitychange", onVisibilityChange)]);
-        _optionalChain([win, 'optionalAccess', _33 => _33.removeEventListener, 'call', _34 => _34("online", onNetworkBackOnline)]);
-        _optionalChain([win, 'optionalAccess', _35 => _35.removeEventListener, 'call', _36 => _36("offline", onNetworkOffline)]);
+        _optionalChain([root, 'optionalAccess', _26 => _26.removeEventListener, 'call', _27 => _27("visibilitychange", onVisibilityChange)]);
+        _optionalChain([win, 'optionalAccess', _28 => _28.removeEventListener, 'call', _29 => _29("online", onNetworkBackOnline)]);
+        _optionalChain([win, 'optionalAccess', _30 => _30.removeEventListener, 'call', _31 => _31("offline", onNetworkOffline)]);
         teardownSocket(ctx.socket);
       };
     });
@@ -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" });
@@ -1342,7 +1228,7 @@ var ManagedSocket = class {
    * message if this is somehow impossible.
    */
   send(data) {
-    const socket = _optionalChain([this, 'access', _37 => _37.machine, 'access', _38 => _38.context, 'optionalAccess', _39 => _39.socket]);
+    const socket = _optionalChain([this, 'access', _32 => _32.machine, 'access', _33 => _33.context, 'optionalAccess', _34 => _34.socket]);
     if (socket === null) {
       warn("Cannot send: not connected yet", data);
     } else if (socket.readyState !== 1) {
@@ -1360,121 +1246,632 @@ 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 = _nullishCoalesce(_optionalChain([authOptions, 'access', _35 => _35.polyfills, 'optionalAccess', _36 => _36.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) : (
+  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 (!(_optionalChain([options, 'optionalAccess', _37 => _37.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 && _optionalChain([event, 'access', _38 => _38.data, 'optionalAccess', _39 => _39.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 = _nullishCoalesce(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: _nullishCoalesce(_optionalChain([root, 'optionalAccess', _40 => _40.toTreeNode, 'call', _41 => _41("root"), 'access', _42 => _42.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
   );
@@ -1721,7 +2118,7 @@ var LiveRegister = class _LiveRegister extends AbstractCrdt {
     return [
       {
         type: 8 /* CREATE_REGISTER */,
-        opId: _optionalChain([pool, 'optionalAccess', _40 => _40.generateOpId, 'call', _41 => _41()]),
+        opId: _optionalChain([pool, 'optionalAccess', _43 => _43.generateOpId, 'call', _44 => _44()]),
         id: this._id,
         parentId,
         parentKey,
@@ -1812,7 +2209,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
     const ops = [];
     const op = {
       id: this._id,
-      opId: _optionalChain([pool, 'optionalAccess', _42 => _42.generateOpId, 'call', _43 => _43()]),
+      opId: _optionalChain([pool, 'optionalAccess', _45 => _45.generateOpId, 'call', _46 => _46()]),
       type: 2 /* CREATE_LIST */,
       parentId,
       parentKey
@@ -2080,7 +2477,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
   _applyInsertUndoRedo(op) {
     const { id, parentKey: key } = op;
     const child = creationOpToLiveNode(op);
-    if (_optionalChain([this, 'access', _44 => _44._pool, 'optionalAccess', _45 => _45.getNode, 'call', _46 => _46(id)]) !== void 0) {
+    if (_optionalChain([this, 'access', _47 => _47._pool, 'optionalAccess', _48 => _48.getNode, 'call', _49 => _49(id)]) !== void 0) {
       return { modified: false };
     }
     child._attach(id, nn(this._pool));
@@ -2088,8 +2485,8 @@ var LiveList = class _LiveList extends AbstractCrdt {
     const existingItemIndex = this._indexOfPosition(key);
     let newKey = key;
     if (existingItemIndex !== -1) {
-      const before2 = _optionalChain([this, 'access', _47 => _47._items, 'access', _48 => _48[existingItemIndex], 'optionalAccess', _49 => _49._parentPos]);
-      const after2 = _optionalChain([this, 'access', _50 => _50._items, 'access', _51 => _51[existingItemIndex + 1], 'optionalAccess', _52 => _52._parentPos]);
+      const before2 = _optionalChain([this, 'access', _50 => _50._items, 'access', _51 => _51[existingItemIndex], 'optionalAccess', _52 => _52._parentPos]);
+      const after2 = _optionalChain([this, 'access', _53 => _53._items, 'access', _54 => _54[existingItemIndex + 1], 'optionalAccess', _55 => _55._parentPos]);
       newKey = makePosition(before2, after2);
       child._setParentLink(this, newKey);
     }
@@ -2104,7 +2501,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
   _applySetUndoRedo(op) {
     const { id, parentKey: key } = op;
     const child = creationOpToLiveNode(op);
-    if (_optionalChain([this, 'access', _53 => _53._pool, 'optionalAccess', _54 => _54.getNode, 'call', _55 => _55(id)]) !== void 0) {
+    if (_optionalChain([this, 'access', _56 => _56._pool, 'optionalAccess', _57 => _57.getNode, 'call', _58 => _58(id)]) !== void 0) {
       return { modified: false };
     }
     this._unacknowledgedSets.set(key, nn(op.opId));
@@ -2226,7 +2623,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
     } else {
       this._items[existingItemIndex]._setParentLink(
         this,
-        makePosition(newKey, _optionalChain([this, 'access', _56 => _56._items, 'access', _57 => _57[existingItemIndex + 1], 'optionalAccess', _58 => _58._parentPos]))
+        makePosition(newKey, _optionalChain([this, 'access', _59 => _59._items, 'access', _60 => _60[existingItemIndex + 1], 'optionalAccess', _61 => _61._parentPos]))
       );
       const previousIndex = this._items.indexOf(child);
       child._setParentLink(this, newKey);
@@ -2252,7 +2649,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
       if (existingItemIndex !== -1) {
         this._items[existingItemIndex]._setParentLink(
           this,
-          makePosition(newKey, _optionalChain([this, 'access', _59 => _59._items, 'access', _60 => _60[existingItemIndex + 1], 'optionalAccess', _61 => _61._parentPos]))
+          makePosition(newKey, _optionalChain([this, 'access', _62 => _62._items, 'access', _63 => _63[existingItemIndex + 1], 'optionalAccess', _64 => _64._parentPos]))
         );
       }
       child._setParentLink(this, newKey);
@@ -2271,7 +2668,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
       if (existingItemIndex !== -1) {
         this._items[existingItemIndex]._setParentLink(
           this,
-          makePosition(newKey, _optionalChain([this, 'access', _62 => _62._items, 'access', _63 => _63[existingItemIndex + 1], 'optionalAccess', _64 => _64._parentPos]))
+          makePosition(newKey, _optionalChain([this, 'access', _65 => _65._items, 'access', _66 => _66[existingItemIndex + 1], 'optionalAccess', _67 => _67._parentPos]))
         );
       }
       child._setParentLink(this, newKey);
@@ -2299,7 +2696,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
     if (existingItemIndex !== -1) {
       this._items[existingItemIndex]._setParentLink(
         this,
-        makePosition(newKey, _optionalChain([this, 'access', _65 => _65._items, 'access', _66 => _66[existingItemIndex + 1], 'optionalAccess', _67 => _67._parentPos]))
+        makePosition(newKey, _optionalChain([this, 'access', _68 => _68._items, 'access', _69 => _69[existingItemIndex + 1], 'optionalAccess', _70 => _70._parentPos]))
       );
     }
     child._setParentLink(this, newKey);
@@ -2357,7 +2754,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
    * @param element The element to add to the end of the LiveList.
    */
   push(element) {
-    _optionalChain([this, 'access', _68 => _68._pool, 'optionalAccess', _69 => _69.assertStorageIsWritable, 'call', _70 => _70()]);
+    _optionalChain([this, 'access', _71 => _71._pool, 'optionalAccess', _72 => _72.assertStorageIsWritable, 'call', _73 => _73()]);
     return this.insert(element, this.length);
   }
   /**
@@ -2366,7 +2763,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
    * @param index The index at which you want to insert the element.
    */
   insert(element, index) {
-    _optionalChain([this, 'access', _71 => _71._pool, 'optionalAccess', _72 => _72.assertStorageIsWritable, 'call', _73 => _73()]);
+    _optionalChain([this, 'access', _74 => _74._pool, 'optionalAccess', _75 => _75.assertStorageIsWritable, 'call', _76 => _76()]);
     if (index < 0 || index > this._items.length) {
       throw new Error(
         `Cannot insert list item at index "${index}". index should be between 0 and ${this._items.length}`
@@ -2396,7 +2793,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
    * @param targetIndex The index where the element should be after moving.
    */
   move(index, targetIndex) {
-    _optionalChain([this, 'access', _74 => _74._pool, 'optionalAccess', _75 => _75.assertStorageIsWritable, 'call', _76 => _76()]);
+    _optionalChain([this, 'access', _77 => _77._pool, 'optionalAccess', _78 => _78.assertStorageIsWritable, 'call', _79 => _79()]);
     if (targetIndex < 0) {
       throw new Error("targetIndex cannot be less than 0");
     }
@@ -2454,7 +2851,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
    * @param index The index of the element to delete
    */
   delete(index) {
-    _optionalChain([this, 'access', _77 => _77._pool, 'optionalAccess', _78 => _78.assertStorageIsWritable, 'call', _79 => _79()]);
+    _optionalChain([this, 'access', _80 => _80._pool, 'optionalAccess', _81 => _81.assertStorageIsWritable, 'call', _82 => _82()]);
     if (index < 0 || index >= this._items.length) {
       throw new Error(
         `Cannot delete list item at index "${index}". index should be between 0 and ${this._items.length - 1}`
@@ -2487,7 +2884,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
     }
   }
   clear() {
-    _optionalChain([this, 'access', _80 => _80._pool, 'optionalAccess', _81 => _81.assertStorageIsWritable, 'call', _82 => _82()]);
+    _optionalChain([this, 'access', _83 => _83._pool, 'optionalAccess', _84 => _84.assertStorageIsWritable, 'call', _85 => _85()]);
     if (this._pool) {
       const ops = [];
       const reverseOps = [];
@@ -2521,7 +2918,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
     }
   }
   set(index, item) {
-    _optionalChain([this, 'access', _83 => _83._pool, 'optionalAccess', _84 => _84.assertStorageIsWritable, 'call', _85 => _85()]);
+    _optionalChain([this, 'access', _86 => _86._pool, 'optionalAccess', _87 => _87.assertStorageIsWritable, 'call', _88 => _88()]);
     if (index < 0 || index >= this._items.length) {
       throw new Error(
         `Cannot set list item at index "${index}". index should be between 0 and ${this._items.length - 1}`
@@ -2669,7 +3066,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
   _shiftItemPosition(index, key) {
     const shiftedPosition = makePosition(
       key,
-      this._items.length > index + 1 ? _optionalChain([this, 'access', _86 => _86._items, 'access', _87 => _87[index + 1], 'optionalAccess', _88 => _88._parentPos]) : void 0
+      this._items.length > index + 1 ? _optionalChain([this, 'access', _89 => _89._items, 'access', _90 => _90[index + 1], 'optionalAccess', _91 => _91._parentPos]) : void 0
     );
     this._items[index]._setParentLink(this, shiftedPosition);
   }
@@ -2795,7 +3192,7 @@ var LiveMap = class _LiveMap extends AbstractCrdt {
     const ops = [];
     const op = {
       id: this._id,
-      opId: _optionalChain([pool, 'optionalAccess', _89 => _89.generateOpId, 'call', _90 => _90()]),
+      opId: _optionalChain([pool, 'optionalAccess', _92 => _92.generateOpId, 'call', _93 => _93()]),
       type: 7 /* CREATE_MAP */,
       parentId,
       parentKey
@@ -2942,7 +3339,7 @@ var LiveMap = class _LiveMap extends AbstractCrdt {
    * @param value The value of the element to add. Should be serializable to JSON.
    */
   set(key, value) {
-    _optionalChain([this, 'access', _91 => _91._pool, 'optionalAccess', _92 => _92.assertStorageIsWritable, 'call', _93 => _93()]);
+    _optionalChain([this, 'access', _94 => _94._pool, 'optionalAccess', _95 => _95.assertStorageIsWritable, 'call', _96 => _96()]);
     const oldValue = this._map.get(key);
     if (oldValue) {
       oldValue._detach();
@@ -2988,7 +3385,7 @@ var LiveMap = class _LiveMap extends AbstractCrdt {
    * @returns true if an element existed and has been removed, or false if the element does not exist.
    */
   delete(key) {
-    _optionalChain([this, 'access', _94 => _94._pool, 'optionalAccess', _95 => _95.assertStorageIsWritable, 'call', _96 => _96()]);
+    _optionalChain([this, 'access', _97 => _97._pool, 'optionalAccess', _98 => _98.assertStorageIsWritable, 'call', _99 => _99()]);
     const item = this._map.get(key);
     if (item === void 0) {
       return false;
@@ -3162,7 +3559,7 @@ var LiveObject = class _LiveObject extends AbstractCrdt {
     if (this._id === void 0) {
       throw new Error("Cannot serialize item is not attached");
     }
-    const opId = _optionalChain([pool, 'optionalAccess', _97 => _97.generateOpId, 'call', _98 => _98()]);
+    const opId = _optionalChain([pool, 'optionalAccess', _100 => _100.generateOpId, 'call', _101 => _101()]);
     const ops = [];
     const op = parentId !== void 0 && parentKey !== void 0 ? {
       type: 4 /* CREATE_OBJECT */,
@@ -3443,7 +3840,7 @@ var LiveObject = class _LiveObject extends AbstractCrdt {
    * @param value The value of the property to add
    */
   set(key, value) {
-    _optionalChain([this, 'access', _99 => _99._pool, 'optionalAccess', _100 => _100.assertStorageIsWritable, 'call', _101 => _101()]);
+    _optionalChain([this, 'access', _102 => _102._pool, 'optionalAccess', _103 => _103.assertStorageIsWritable, 'call', _104 => _104()]);
     this.update({ [key]: value });
   }
   /**
@@ -3458,7 +3855,7 @@ var LiveObject = class _LiveObject extends AbstractCrdt {
    * @param key The key of the property to delete
    */
   delete(key) {
-    _optionalChain([this, 'access', _102 => _102._pool, 'optionalAccess', _103 => _103.assertStorageIsWritable, 'call', _104 => _104()]);
+    _optionalChain([this, 'access', _105 => _105._pool, 'optionalAccess', _106 => _106.assertStorageIsWritable, 'call', _107 => _107()]);
     const keyAsString = key;
     const oldValue = this._map.get(keyAsString);
     if (oldValue === void 0) {
@@ -3511,7 +3908,7 @@ var LiveObject = class _LiveObject extends AbstractCrdt {
    * @param patch The object used to overrides properties
    */
   update(patch) {
-    _optionalChain([this, 'access', _105 => _105._pool, 'optionalAccess', _106 => _106.assertStorageIsWritable, 'call', _107 => _107()]);
+    _optionalChain([this, 'access', _108 => _108._pool, 'optionalAccess', _109 => _109.assertStorageIsWritable, 'call', _110 => _110()]);
     if (this._pool === void 0 || this._id === void 0) {
       for (const key in patch) {
         const newValue = patch[key];
@@ -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 = _nullishCoalesce(config.delegates, () => ( {
-    authenticate: makeAuthDelegateForRoom(
-      config.roomId,
-      config.authentication,
-      _optionalChain([config, 'access', _108 => _108.polyfills, 'optionalAccess', _109 => _109.fetch])
-    ),
-    createSocket: makeCreateSocketDelegateForRoom(
-      config.liveblocksServer,
-      _optionalChain([config, 'access', _110 => _110.polyfills, 'optionalAccess', _111 => _111.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 = _nullishCoalesce(config.unstable_batchedUpdates, () => ( doNotBatchUpdates));
-  let lastToken;
+  let lastTokenKey;
   function onStatusDidChange(newStatus) {
-    const token = _optionalChain([managedSocket, 'access', _112 => _112.token, 'optionalAccess', _113 => _113.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 (_optionalChain([context, 'access', _114 => _114.sessionInfo, 'access', _115 => _115.current, 'optionalAccess', _116 => _116.isReadOnly])) {
+      const scopes = _optionalChain([context, 'access', _111 => _111.dynamicSessionInfo, 'access', _112 => _112.current, 'optionalAccess', _113 => _113.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,12 +4741,13 @@ 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 && _optionalChain([managedSocket, 'access', _117 => _117.token, 'optionalAccess', _118 => _118.raw]) && config.httpSendEndpoint) {
+      if (size > MAX_MESSAGE_SIZE && // TODO: support public api key auth in REST API
+      _optionalChain([managedSocket, 'access', _114 => _114.authValue, 'optionalAccess', _115 => _115.type]) === "secret" && config.httpSendEndpoint) {
         void httpSend(
           message,
-          managedSocket.token.raw,
+          managedSocket.authValue.token.raw,
           config.httpSendEndpoint,
-          _optionalChain([config, 'access', _119 => _119.polyfills, 'optionalAccess', _120 => _120.fetch])
+          _optionalChain([config, 'access', _116 => _116.polyfills, 'optionalAccess', _117 => _117.fetch])
         ).then((resp) => {
           if (!resp.ok && resp.status === 403) {
             managedSocket.reconnect();
@@ -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,11 +4999,11 @@ 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 (_optionalChain([options2, 'optionalAccess', _121 => _121.addToHistory])) {
+      if (_optionalChain([options2, 'optionalAccess', _118 => _118.addToHistory])) {
         context.activeBatch.reverseOps.unshift({
           type: "presence",
           data: oldValues
@@ -4639,7 +5013,7 @@ function createRoom(options, config) {
     } else {
       flushNowOrSoon();
       batchUpdates(() => {
-        if (_optionalChain([options2, 'optionalAccess', _122 => _122.addToHistory])) {
+        if (_optionalChain([options2, 'optionalAccess', _119 => _119.addToHistory])) {
           addToUndoStack(
             [{ type: "presence", data: oldValues }],
             doNotBatchUpdates
@@ -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,14 +5183,14 @@ 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 */: {
             const unacknowledgedOps = new Map(context.unacknowledgedOps);
             createOrUpdateRootFromMessage(message, doNotBatchUpdates);
             applyAndSendOps(unacknowledgedOps, doNotBatchUpdates);
-            _optionalChain([_resolveStoragePromise, 'optionalCall', _123 => _123()]);
+            _optionalChain([_resolveStoragePromise, 'optionalCall', _120 => _120()]);
             notifyStorageStatus();
             eventHub.storageDidLoad.notify();
             break;
@@ -4836,7 +5213,7 @@ function createRoom(options, config) {
             if (process.env.NODE_ENV !== "production") {
               const traces = /* @__PURE__ */ new Set();
               for (const opId of message.opIds) {
-                const trace = _optionalChain([context, 'access', _124 => _124.opStackTraces, 'optionalAccess', _125 => _125.get, 'call', _126 => _126(opId)]);
+                const trace = _optionalChain([context, 'access', _121 => _121.opStackTraces, 'optionalAccess', _122 => _122.get, 'call', _123 => _123(opId)]);
                 if (trace) {
                   traces.add(trace);
                 }
@@ -5124,7 +5501,7 @@ ${Array.from(traces).join("\n\n")}`
       /* NOTE: Exposing __internal here only to allow testing implementation details in unit tests */
       __internal: {
         get presenceBuffer() {
-          return deepClone(_nullishCoalesce(_optionalChain([context, 'access', _127 => _127.buffer, 'access', _128 => _128.presenceUpdates, 'optionalAccess', _129 => _129.data]), () => ( null)));
+          return deepClone(_nullishCoalesce(_optionalChain([context, 'access', _124 => _124.buffer, 'access', _125 => _125.presenceUpdates, 'optionalAccess', _126 => _126.data]), () => ( null)));
         },
         // prettier-ignore
         get undoStack() {
@@ -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
@@ -5253,139 +5629,61 @@ function makeClassicSubscribeFn(events) {
       } else {
         throw new Error("Please specify a listener callback");
       }
-    }
-    if (isLiveNode(first)) {
-      const node = first;
-      if (_optionalChain([options, 'optionalAccess', _130 => _130.isDeep])) {
-        const storageCallback = second;
-        return subscribeToLiveStructureDeeply(node, storageCallback);
-      } else {
-        const nodeCallback = second;
-        return subscribeToLiveStructureShallowly(node, nodeCallback);
-      }
-    }
-    throw new Error(`"${String(first)}" is not a valid event name`);
-  }
-  return subscribe;
-}
-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) => {
-    const ws = _nullishCoalesce(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"}`
-    );
-  };
-}
-async function httpSend(message, token, endpoint, fetchPolyfill) {
-  const fetcher = fetchPolyfill || /* istanbul ignore next */
-  fetch;
-  return fetcher(endpoint, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${token}`
-    },
-    body: message
-  });
-}
-function makeAuthDelegateForRoom(roomId, authentication, fetchPolyfill) {
-  const fetcher = _nullishCoalesce(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);
-        }
+    }
+    if (isLiveNode(first)) {
+      const node = first;
+      if (_optionalChain([options, 'optionalAccess', _127 => _127.isDeep])) {
+        const storageCallback = second;
+        return subscribeToLiveStructureDeeply(node, storageCallback);
       } 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: "..." }'
-        );
+        const nodeCallback = second;
+        return subscribeToLiveStructureShallowly(node, nodeCallback);
       }
-    };
-  } else {
-    throw new Error("Internal error. Unexpected authentication type");
+    }
+    throw new Error(`"${String(first)}" is not a valid event name`);
   }
+  return subscribe;
 }
-async function fetchAuthEndpoint(fetch2, endpoint, body) {
-  const res = await fetch2(endpoint, {
+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 makeAuthDelegateForRoom(roomId, authManager) {
+  return async () => {
+    return authManager.getAuthValue("room:read", roomId);
+  };
+}
+function makeCreateSocketDelegateForRoom(roomId, liveblocksServer, WebSocketPolyfill) {
+  return (authValue) => {
+    const ws = _nullishCoalesce(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 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) {
+  const fetcher = fetchPolyfill || /* istanbul ignore next */
+  fetch;
+  return fetcher(endpoint, {
     method: "POST",
     headers: {
-      "Content-Type": "application/json"
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${token}`
     },
-    // Credentials are needed to support authentication with cookies
-    credentials: "include",
-    body: JSON.stringify(body)
+    body: message
   });
-  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
@@ -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(
     _nullishCoalesce(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: _nullishCoalesce(clientOptions.mockedDelegates, () => ( {
+          createSocket: makeCreateSocketDelegateForRoom(
+            roomId,
+            getServerFromClientOptions(clientOptions),
+            _optionalChain([clientOptions, 'access', _128 => _128.polyfills, 'optionalAccess', _129 => _129.WebSocket])
+          ),
+          authenticate: makeAuthDelegateForRoom(roomId, authManager)
+        })),
         enableDebugLogging: clientOptions.enableDebugLogging,
-        unstable_batchedUpdates: _optionalChain([options2, 'optionalAccess', _131 => _131.unstable_batchedUpdates]),
+        unstable_batchedUpdates: _optionalChain([options2, 'optionalAccess', _130 => _130.unstable_batchedUpdates]),
         liveblocksServer: getServerFromClientOptions(clientOptions),
-        authentication: prepareAuthentication(clientOptions, roomId),
         httpSendEndpoint: buildLiveblocksHttpSendEndpoint(
           clientOptions,
           roomId
@@ -5448,7 +5753,7 @@ function createClient(options) {
     const shouldConnect = _nullishCoalesce(options2.shouldInitiallyConnect, () => ( true));
     if (shouldConnect) {
       if (typeof atob === "undefined") {
-        if (_optionalChain([clientOptions, 'access', _132 => _132.polyfills, 'optionalAccess', _133 => _133.atob]) === void 0) {
+        if (_optionalChain([clientOptions, 'access', _131 => _131.polyfills, 'optionalAccess', _132 => _132.atob]) === void 0) {
           throw new Error(
             "You need to polyfill atob to use the client in your environment. Please follow the instructions at https://liveblocks.io/docs/errors/liveblocks-client/atob-polyfill"
           );
@@ -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
@@ -5781,12 +6049,12 @@ function legacy_patchImmutableNode(state, path, update) {
         }
         const newState = Object.assign({}, state);
         for (const key in update.updates) {
-          if (_optionalChain([update, 'access', _134 => _134.updates, 'access', _135 => _135[key], 'optionalAccess', _136 => _136.type]) === "update") {
+          if (_optionalChain([update, 'access', _133 => _133.updates, 'access', _134 => _134[key], 'optionalAccess', _135 => _135.type]) === "update") {
             const val = update.node.get(key);
             if (val !== void 0) {
               newState[key] = lsonToJson(val);
             }
-          } else if (_optionalChain([update, 'access', _137 => _137.updates, 'access', _138 => _138[key], 'optionalAccess', _139 => _139.type]) === "delete") {
+          } else if (_optionalChain([update, 'access', _136 => _136.updates, 'access', _137 => _137[key], 'optionalAccess', _138 => _138.type]) === "delete") {
             delete newState[key];
           }
         }
@@ -5847,12 +6115,12 @@ function legacy_patchImmutableNode(state, path, update) {
         }
         const newState = Object.assign({}, state);
         for (const key in update.updates) {
-          if (_optionalChain([update, 'access', _140 => _140.updates, 'access', _141 => _141[key], 'optionalAccess', _142 => _142.type]) === "update") {
+          if (_optionalChain([update, 'access', _139 => _139.updates, 'access', _140 => _140[key], 'optionalAccess', _141 => _141.type]) === "update") {
             const value = update.node.get(key);
             if (value !== void 0) {
               newState[key] = lsonToJson(value);
             }
-          } else if (_optionalChain([update, 'access', _143 => _143.updates, 'access', _144 => _144[key], 'optionalAccess', _145 => _145.type]) === "delete") {
+          } else if (_optionalChain([update, 'access', _142 => _142.updates, 'access', _143 => _143[key], 'optionalAccess', _144 => _144.type]) === "delete") {
             delete newState[key];
           }
         }
@@ -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 = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _145 => _145.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,
+      _nullishCoalesce(overrideAsyncFunction, () => ( asyncFunction)),
+      options
+    );
+    cache.set(key, cacheItem);
+    return cacheItem;
+  }
+  function get(key) {
+    return create(key).get();
+  }
+  function getState(key) {
+    return _optionalChain([cache, 'access', _146 => _146.get, 'call', _147 => _147(key), 'optionalAccess', _148 => _148.getState, 'call', _149 => _149()]);
+  }
+  function revalidate(key) {
+    return create(key).revalidate();
+  }
+  function subscribe(key, callback) {
+    return _nullishCoalesce(create(key).subscribe(callback), () => ( noop));
+  }
+  function subscribeOnce(key, callback) {
+    return _nullishCoalesce(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 (e3) {
+      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: {
+        ..._optionalChain([options, 'optionalAccess', _150 => _150.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);
@@ -5974,5 +6602,11 @@ detectDupes(PKG_NAME, PKG_VERSION, PKG_FORMAT);
 
 
 
-exports.ClientMsgCode = ClientMsgCode; exports.CrdtType = CrdtType; exports.LiveList = LiveList; exports.LiveMap = LiveMap; exports.LiveObject = LiveObject; exports.OpCode = OpCode; exports.ServerMsgCode = ServerMsgCode; exports.WebsocketCloseCodes = WebsocketCloseCodes; exports.asArrayWithLegacyMethods = asArrayWithLegacyMethods; exports.asPos = asPos; exports.assert = assert; exports.assertNever = assertNever; exports.b64decode = b64decode; exports.createClient = createClient; exports.deprecate = deprecate; exports.deprecateIf = deprecateIf; exports.detectDupes = detectDupes; exports.errorIf = errorIf; exports.freeze = freeze; exports.isChildCrdt = isChildCrdt; exports.isJsonArray = isJsonArray; exports.isJsonObject = isJsonObject; exports.isJsonScalar = isJsonScalar; exports.isPlainObject = isPlainObject; exports.isRootCrdt = isRootCrdt; exports.legacy_patchImmutableObject = legacy_patchImmutableObject; exports.lsonToJson = lsonToJson; exports.makePosition = makePosition; exports.nn = nn; exports.patchLiveObjectKey = patchLiveObjectKey; exports.shallow = shallow; exports.throwUsageError = throwUsageError; exports.toPlainLson = toPlainLson; exports.tryParseJson = tryParseJson; exports.withTimeout = withTimeout;
+
+
+
+
+
+
+exports.ClientMsgCode = ClientMsgCode; exports.CrdtType = CrdtType; exports.LiveList = LiveList; exports.LiveMap = LiveMap; exports.LiveObject = LiveObject; exports.OpCode = OpCode; exports.ServerMsgCode = ServerMsgCode; exports.WebsocketCloseCodes = WebsocketCloseCodes; exports.asArrayWithLegacyMethods = asArrayWithLegacyMethods; exports.asPos = asPos; exports.assert = assert; exports.assertNever = assertNever; exports.b64decode = b64decode; exports.console = fancy_console_exports; exports.createAsyncCache = createAsyncCache; exports.createClient = createClient; exports.createCommentsApi = createCommentsApi; exports.deprecate = deprecate; exports.deprecateIf = deprecateIf; exports.detectDupes = detectDupes; exports.errorIf = errorIf; exports.freeze = freeze; exports.isChildCrdt = isChildCrdt; exports.isCommentBodyMention = isCommentBodyMention; exports.isJsonArray = isJsonArray; exports.isJsonObject = isJsonObject; exports.isJsonScalar = isJsonScalar; exports.isPlainObject = isPlainObject; exports.isRootCrdt = isRootCrdt; exports.legacy_patchImmutableObject = legacy_patchImmutableObject; exports.lsonToJson = lsonToJson; exports.makeEventSource = makeEventSource; exports.makePoller = makePoller; exports.makePosition = makePosition; exports.nn = nn; exports.patchLiveObjectKey = patchLiveObjectKey; exports.shallow = shallow; exports.throwUsageError = throwUsageError; exports.toPlainLson = toPlainLson; exports.tryParseJson = tryParseJson; exports.withTimeout = withTimeout;
 //# sourceMappingURL=index.js.map