@liveblocks/core 1.2.0-internal6 → 1.2.0

package/dist/index.mjs

@@ -1,3 +1,81 @@
+// src/version.ts
+var PKG_NAME = "@liveblocks/core";
+var PKG_VERSION = "1.2.0";
+var PKG_FORMAT = "esm";
+
+// src/dupe-detection.ts
+var g = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : {};
+var crossLinkedDocs = "https://liveblocks.io/docs/errors/cross-linked";
+var dupesDocs = "https://liveblocks.io/docs/errors/dupes";
+var SPACE = " ";
+function error(msg) {
+  if (process.env.NODE_ENV === "production") {
+    console.error(msg);
+  } else {
+    throw new Error(msg);
+  }
+}
+function detectDupes(pkgName, pkgVersion, pkgFormat) {
+  const pkgId = Symbol.for(pkgName);
+  const pkgBuildInfo = pkgFormat ? `${pkgVersion || "dev"} (${pkgFormat})` : pkgVersion || "dev";
+  if (!g[pkgId]) {
+    g[pkgId] = pkgBuildInfo;
+  } else if (g[pkgId] === pkgBuildInfo) {
+  } else {
+    const msg = [
+      `Multiple copies of Liveblocks are being loaded in your project. This will cause issues! See ${dupesDocs + SPACE}`,
+      "",
+      "Conflicts:",
+      `- ${pkgName} ${g[pkgId]} (already loaded)`,
+      `- ${pkgName} ${pkgBuildInfo} (trying to load this now)`
+    ].join("\n");
+    error(msg);
+  }
+  if (pkgVersion && PKG_VERSION && pkgVersion !== PKG_VERSION) {
+    error(
+      [
+        `Cross-linked versions of Liveblocks found, which will cause issues! See ${crossLinkedDocs + SPACE}`,
+        "",
+        "Conflicts:",
+        `- ${PKG_NAME} is at ${PKG_VERSION}`,
+        `- ${pkgName} is at ${pkgVersion}`,
+        "",
+        "Always upgrade all Liveblocks packages to the same version number."
+      ].join("\n")
+    );
+  }
+}
+
+// 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();
@@ -71,187 +149,6 @@ function makeEventSource() {
   };
 }
 
-// src/devtools/bridge.ts
-var _bridgeActive = false;
-function activateBridge(allowed) {
-  _bridgeActive = allowed;
-}
-function sendToPanel(message, options) {
-  if (process.env.NODE_ENV === "production" || typeof window === "undefined") {
-    return;
-  }
-  const fullMsg = {
-    ...message,
-    source: "liveblocks-devtools-client"
-  };
-  if (!(options?.force || _bridgeActive)) {
-    return;
-  }
-  window.postMessage(fullMsg, "*");
-}
-var eventSource = makeEventSource();
-if (process.env.NODE_ENV !== "production" && typeof window !== "undefined") {
-  window.addEventListener("message", (event) => {
-    if (event.source === window && event.data?.source === "liveblocks-devtools-panel") {
-      eventSource.notify(event.data);
-    } else {
-    }
-  });
-}
-var onMessageFromPanel = eventSource.observable;
-
-// src/devtools/index.ts
-var VERSION = true ? (
-  /* istanbul ignore next */
-  "1.2.0-internal6"
-) : "dev";
-var _devtoolsSetupHasRun = false;
-function setupDevTools(getAllRooms) {
-  if (process.env.NODE_ENV === "production" || typeof window === "undefined") {
-    return;
-  }
-  if (_devtoolsSetupHasRun) {
-    return;
-  }
-  _devtoolsSetupHasRun = true;
-  onMessageFromPanel.subscribe((msg) => {
-    switch (msg.msg) {
-      case "connect": {
-        activateBridge(true);
-        for (const roomId of getAllRooms()) {
-          sendToPanel({
-            msg: "room::available",
-            roomId,
-            clientVersion: VERSION
-          });
-        }
-        break;
-      }
-    }
-  });
-  sendToPanel({ msg: "wake-up-devtools" }, { force: true });
-}
-var unsubsByRoomId = /* @__PURE__ */ new Map();
-function stopSyncStream(roomId) {
-  const unsubs = unsubsByRoomId.get(roomId) ?? [];
-  unsubsByRoomId.delete(roomId);
-  for (const unsub of unsubs) {
-    unsub();
-  }
-}
-function startSyncStream(room) {
-  stopSyncStream(room.id);
-  fullSync(room);
-  unsubsByRoomId.set(room.id, [
-    // When the connection status changes
-    room.events.status.subscribe(() => partialSyncConnection(room)),
-    // When storage initializes, send the update
-    room.events.storageDidLoad.subscribeOnce(() => partialSyncStorage(room)),
-    // Any time storage updates, send the new storage root
-    room.events.storage.subscribe(() => partialSyncStorage(room)),
-    // Any time "me" or "others" updates, send the new values accordingly
-    room.events.me.subscribe(() => partialSyncMe(room)),
-    room.events.others.subscribe(() => partialSyncOthers(room))
-  ]);
-}
-function partialSyncConnection(room) {
-  sendToPanel({
-    msg: "room::sync::partial",
-    roomId: room.id,
-    status: room.getStatus()
-  });
-}
-function partialSyncStorage(room) {
-  const root = room.getStorageSnapshot();
-  if (root) {
-    sendToPanel({
-      msg: "room::sync::partial",
-      roomId: room.id,
-      storage: root.toTreeNode("root").payload
-    });
-  }
-}
-function partialSyncMe(room) {
-  const me = room.__internal.getSelf_forDevTools();
-  if (me) {
-    sendToPanel({
-      msg: "room::sync::partial",
-      roomId: room.id,
-      me
-    });
-  }
-}
-function partialSyncOthers(room) {
-  const others = room.__internal.getOthers_forDevTools();
-  if (others) {
-    sendToPanel({
-      msg: "room::sync::partial",
-      roomId: room.id,
-      others
-    });
-  }
-}
-function fullSync(room) {
-  const root = room.getStorageSnapshot();
-  const me = room.__internal.getSelf_forDevTools();
-  const others = room.__internal.getOthers_forDevTools();
-  sendToPanel({
-    msg: "room::sync::full",
-    roomId: room.id,
-    status: room.getStatus(),
-    storage: root?.toTreeNode("root").payload ?? null,
-    me,
-    others
-  });
-}
-var roomChannelListeners = /* @__PURE__ */ new Map();
-function stopRoomChannelListener(roomId) {
-  const listener = roomChannelListeners.get(roomId);
-  roomChannelListeners.delete(roomId);
-  if (listener) {
-    listener();
-  }
-}
-function linkDevTools(roomId, room) {
-  if (process.env.NODE_ENV === "production" || typeof window === "undefined") {
-    return;
-  }
-  sendToPanel({ msg: "room::available", roomId, clientVersion: VERSION });
-  stopRoomChannelListener(roomId);
-  roomChannelListeners.set(
-    roomId,
-    // Returns the unsubscribe callback, that we store in the
-    // roomChannelListeners registry
-    onMessageFromPanel.subscribe((msg) => {
-      switch (msg.msg) {
-        case "room::subscribe": {
-          if (msg.roomId === roomId) {
-            startSyncStream(room);
-          }
-          break;
-        }
-        case "room::unsubscribe": {
-          if (msg.roomId === roomId) {
-            stopSyncStream(roomId);
-          }
-          break;
-        }
-      }
-    })
-  );
-}
-function unlinkDevTools(roomId) {
-  if (process.env.NODE_ENV === "production" || typeof window === "undefined") {
-    return;
-  }
-  stopSyncStream(roomId);
-  stopRoomChannelListener(roomId);
-  sendToPanel({
-    msg: "room::unavailable",
-    roomId
-  });
-}
-
 // src/lib/fancy-console.ts
 var badge = "background:#0e0d12;border-radius:9999px;color:#fff;padding:3px 7px;font-family:sans-serif;font-weight:600;";
 var bold = "font-weight:600";
@@ -262,7 +159,7 @@ function wrap(method) {
   );
 }
 var warn = wrap("warn");
-var error = wrap("error");
+var error2 = wrap("error");
 function wrapWithTitle(method) {
   return typeof window === "undefined" || process.env.NODE_ENV === "test" ? console[method] : (
     /* istanbul ignore next */
@@ -278,83 +175,32 @@ 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);
-    }
+// src/lib/fsm.ts
+function distance(state1, state2) {
+  if (state1 === state2) {
+    return [0, 0];
   }
-}
-function deprecateIf(condition, message, key = message) {
-  if (process.env.NODE_ENV !== "production") {
-    if (condition) {
-      deprecate(message, key);
+  const chunks1 = state1.split(".");
+  const chunks2 = state2.split(".");
+  const minLen = Math.min(chunks1.length, chunks2.length);
+  let shared = 0;
+  for (; shared < minLen; shared++) {
+    if (chunks1[shared] !== chunks2[shared]) {
+      break;
     }
   }
+  const up = chunks1.length - shared;
+  const down = chunks2.length - shared;
+  return [up, down];
 }
-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 patterns(targetState, levels) {
+  const parts = targetState.split(".");
+  if (levels < 1 || levels > parts.length + 1) {
+    throw new Error("Invalid number of levels");
   }
-}
-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) {
-    return [0, 0];
-  }
-  const chunks1 = state1.split(".");
-  const chunks2 = state2.split(".");
-  const minLen = Math.min(chunks1.length, chunks2.length);
-  let shared = 0;
-  for (; shared < minLen; shared++) {
-    if (chunks1[shared] !== chunks2[shared]) {
-      break;
-    }
-  }
-  const up = chunks1.length - shared;
-  const down = chunks2.length - shared;
-  return [up, down];
-}
-function patterns(targetState, levels) {
-  const parts = targetState.split(".");
-  if (levels < 1 || levels > parts.length + 1) {
-    throw new Error("Invalid number of levels");
-  }
-  const result = [];
-  if (levels > parts.length) {
-    result.push("*");
+  const result = [];
+  if (levels > parts.length) {
+    result.push("*");
   }
   for (let i = parts.length - levels + 1; i < parts.length; i++) {
     const slice = parts.slice(0, i);
@@ -726,6 +572,9 @@ function tryParseJson(rawMessage) {
     return void 0;
   }
 }
+function deepClone(items) {
+  return JSON.parse(JSON.stringify(items));
+}
 function b64decode(b64value) {
   try {
     const formattedValue = b64value.replace(/-/g, "+").replace(/_/g, "/");
@@ -764,6 +613,45 @@ async function withTimeout(promise, millis, errmsg = "Timed out") {
   return Promise.race([promise, timer$]).finally(() => clearTimeout(timerID));
 }
 
+// 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) {
@@ -833,7 +721,7 @@ function resetSuccessCount(context) {
   context.patch({ successCount: 0 });
 }
 function log(level, message) {
-  const logger = level === 2 /* ERROR */ ? error : level === 1 /* WARN */ ? warn : (
+  const logger = level === 2 /* ERROR */ ? error2 : level === 1 /* WARN */ ? warn : (
     /* black hole */
     () => {
     }
@@ -865,11 +753,8 @@ var logPermanentClose = log(
   1 /* WARN */,
   "Connection to WebSocket closed permanently. Won't retry."
 );
-function isCloseEvent(error2) {
-  return !(error2 instanceof Error) && error2.type === "close";
-}
-function isCustomCloseEvent(error2) {
-  return isCloseEvent(error2) && error2.code >= 4e3 && error2.code < 4100;
+function isCloseEvent(error3) {
+  return !(error3 instanceof Error) && error3.type === "close";
 }
 function enableTracing(machine) {
   const start = (/* @__PURE__ */ new Date()).getTime();
@@ -921,13 +806,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
   };
@@ -941,9 +832,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", {
@@ -962,7 +853,7 @@ function createConnectionStateMachine(delegates, enableDebugLogging) {
     (okEvent) => ({
       target: "@connecting.busy",
       effect: assign({
-        token: okEvent.data,
+        authValue: okEvent.data,
         backoffDelay: RESET_DELAY
       })
     }),
@@ -971,7 +862,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 {
@@ -1021,16 +915,29 @@ function createConnectionStateMachine(delegates, enableDebugLogging) {
       let capturedPrematureEvent = null;
       const connect$ = new Promise(
         (resolve, rej) => {
-          if (ctx.token === null) {
-            throw new Error("No auth token");
+          if (ctx.authValue === null) {
+            throw new Error("No auth authValue");
           }
-          const socket = delegates.createSocket(ctx.token);
+          const socket = delegates.createSocket(ctx.authValue);
           function reject(event) {
             capturedPrematureEvent = event;
             socket.removeEventListener("message", onSocketMessage);
             rej(event);
           }
+          const [actor$, didReceiveActor] = controlledPromise();
+          if (!options.waitForActorId) {
+            didReceiveActor();
+          }
+          function waitForActorId(event) {
+            const serverMsg = tryParseJson(event.data);
+            if (serverMsg?.type === 104 /* ROOM_STATE */) {
+              didReceiveActor();
+            }
+          }
           socket.addEventListener("message", onSocketMessage);
+          if (options.waitForActorId) {
+            socket.addEventListener("message", waitForActorId);
+          }
           socket.addEventListener("error", reject);
           socket.addEventListener("close", reject);
           socket.addEventListener("open", () => {
@@ -1039,8 +946,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]);
+            });
           });
         }
       );
@@ -1081,24 +991,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)]
@@ -1152,29 +1073,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 {
@@ -1213,7 +1134,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();
@@ -1234,7 +1155,7 @@ var ManagedSocket = class {
   constructor(delegates, enableDebugLogging = false) {
     const { machine, events, cleanups } = createConnectionStateMachine(
       delegates,
-      enableDebugLogging
+      { waitForActorId: true, enableDebugLogging }
     );
     this.machine = machine;
     this.events = events;
@@ -1251,10 +1172,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
@@ -1265,7 +1186,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" });
@@ -1289,28 +1210,444 @@ var ManagedSocket = class {
       cleanup();
     }
   }
-  /**
-   * Safely send a message to the current WebSocket connection. Will emit a log
-   * message if this is somehow impossible.
-   */
-  send(data) {
-    const socket = this.machine.context?.socket;
-    if (socket === null) {
-      warn("Cannot send: not connected yet", data);
-    } else if (socket.readyState !== 1) {
-      warn("Cannot send: WebSocket no longer open", data);
-    } else {
-      socket.send(data);
+  /**
+   * Safely send a message to the current WebSocket connection. Will emit a log
+   * message if this is somehow impossible.
+   */
+  send(data) {
+    const socket = this.machine.context?.socket;
+    if (socket === null) {
+      warn("Cannot send: not connected yet", data);
+    } else if (socket.readyState !== 1) {
+      warn("Cannot send: WebSocket no longer open", data);
+    } else {
+      socket.send(data);
+    }
+  }
+  /**
+   * NOTE: Used by the E2E app only, to simulate explicit events.
+   * Not ideal to keep exposed :(
+   */
+  _privateSendMachineEvent(event) {
+    this.machine.send(event);
+  }
+};
+
+// src/protocol/AuthToken.ts
+function canWriteStorage(scopes) {
+  return scopes.includes("room:write" /* Write */);
+}
+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
+  };
+}
+
+// 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 */);
+    }
+    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;
+          }
+        }
+      }
+    }
+    return void 0;
+  }
+  async function makeAuthRequest(roomId) {
+    const fetcher = authOptions.polyfills?.fetch ?? (typeof window === "undefined" ? void 0 : window.fetch);
+    if (authentication.type === "private") {
+      if (fetcher === void 0) {
+        throw new StopRetrying(
+          "To use Liveblocks client in a non-dom environment with a url as auth endpoint, you need to provide a fetch polyfill."
+        );
+      }
+      const response = await fetchAuthEndpoint(fetcher, authentication.url, {
+        room: roomId
+      });
+      return parseAuthToken(response.token);
+    }
+    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");
+  }
+  async function getAuthValue(requestedScope, roomId) {
+    if (authentication.type === "public") {
+      return { type: "public", publicApiKey: authentication.publicApiKey };
+    }
+    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 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"
+    );
+  }
+  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
+    };
+  }
+  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"
+  );
+}
+async function fetchAuthEndpoint(fetch2, endpoint, body) {
+  const res = await fetch2(endpoint, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(body)
+  });
+  if (!res.ok) {
+    const reason = `${(await res.text()).trim() || "reason not provided in auth response"} (${res.status} returned by POST ${endpoint})`;
+    if (res.status === 401 || res.status === 403) {
+      throw new StopRetrying(`Unauthorized: ${reason}`);
+    } else {
+      throw new Error(`Failed to authenticate: ${reason}`);
+    }
+  }
+  let data;
+  try {
+    data = await res.json();
+  } catch (er) {
+    throw new Error(
+      `Expected a JSON response when doing a POST request on "${endpoint}". ${String(
+        er
+      )}`
+    );
+  }
+  if (!isPlainObject(data) || typeof data.token !== "string") {
+    throw new Error(
+      `Expected a JSON response of the form \`{ token: "..." }\` when doing a POST request on "${endpoint}", but got ${JSON.stringify(
+        data
+      )}`
+    );
+  }
+  const { token } = data;
+  return { token };
+}
+
+// src/devtools/bridge.ts
+var _bridgeActive = false;
+function activateBridge(allowed) {
+  _bridgeActive = allowed;
+}
+function sendToPanel(message, options) {
+  if (process.env.NODE_ENV === "production" || typeof window === "undefined") {
+    return;
+  }
+  const fullMsg = {
+    ...message,
+    source: "liveblocks-devtools-client"
+  };
+  if (!(options?.force || _bridgeActive)) {
+    return;
+  }
+  window.postMessage(fullMsg, "*");
+}
+var eventSource = makeEventSource();
+if (process.env.NODE_ENV !== "production" && typeof window !== "undefined") {
+  window.addEventListener("message", (event) => {
+    if (event.source === window && event.data?.source === "liveblocks-devtools-panel") {
+      eventSource.notify(event.data);
+    } else {
+    }
+  });
+}
+var onMessageFromPanel = eventSource.observable;
+
+// src/devtools/index.ts
+var VERSION = PKG_VERSION || "dev";
+var _devtoolsSetupHasRun = false;
+function setupDevTools(getAllRooms) {
+  if (process.env.NODE_ENV === "production" || typeof window === "undefined") {
+    return;
+  }
+  if (_devtoolsSetupHasRun) {
+    return;
+  }
+  _devtoolsSetupHasRun = true;
+  onMessageFromPanel.subscribe((msg) => {
+    switch (msg.msg) {
+      case "connect": {
+        activateBridge(true);
+        for (const roomId of getAllRooms()) {
+          sendToPanel({
+            msg: "room::available",
+            roomId,
+            clientVersion: VERSION
+          });
+        }
+        break;
+      }
+    }
+  });
+  sendToPanel({ msg: "wake-up-devtools" }, { force: true });
+}
+var unsubsByRoomId = /* @__PURE__ */ new Map();
+function stopSyncStream(roomId) {
+  const unsubs = unsubsByRoomId.get(roomId) ?? [];
+  unsubsByRoomId.delete(roomId);
+  for (const unsub of unsubs) {
+    unsub();
+  }
+}
+function startSyncStream(room) {
+  stopSyncStream(room.id);
+  fullSync(room);
+  unsubsByRoomId.set(room.id, [
+    // When the connection status changes
+    room.events.status.subscribe(() => partialSyncConnection(room)),
+    // When storage initializes, send the update
+    room.events.storageDidLoad.subscribeOnce(() => partialSyncStorage(room)),
+    // Any time storage updates, send the new storage root
+    room.events.storage.subscribe(() => partialSyncStorage(room)),
+    // Any time "me" or "others" updates, send the new values accordingly
+    room.events.self.subscribe(() => partialSyncMe(room)),
+    room.events.others.subscribe(() => partialSyncOthers(room))
+  ]);
+}
+function partialSyncConnection(room) {
+  sendToPanel({
+    msg: "room::sync::partial",
+    roomId: room.id,
+    status: room.getStatus()
+  });
+}
+function partialSyncStorage(room) {
+  const root = room.getStorageSnapshot();
+  if (root) {
+    sendToPanel({
+      msg: "room::sync::partial",
+      roomId: room.id,
+      storage: root.toTreeNode("root").payload
+    });
+  }
+}
+function partialSyncMe(room) {
+  const me = room.__internal.getSelf_forDevTools();
+  if (me) {
+    sendToPanel({
+      msg: "room::sync::partial",
+      roomId: room.id,
+      me
+    });
+  }
+}
+function partialSyncOthers(room) {
+  const others = room.__internal.getOthers_forDevTools();
+  if (others) {
+    sendToPanel({
+      msg: "room::sync::partial",
+      roomId: room.id,
+      others
+    });
+  }
+}
+function fullSync(room) {
+  const root = room.getStorageSnapshot();
+  const me = room.__internal.getSelf_forDevTools();
+  const others = room.__internal.getOthers_forDevTools();
+  sendToPanel({
+    msg: "room::sync::full",
+    roomId: room.id,
+    status: room.getStatus(),
+    storage: root?.toTreeNode("root").payload ?? null,
+    me,
+    others
+  });
+}
+var roomChannelListeners = /* @__PURE__ */ new Map();
+function stopRoomChannelListener(roomId) {
+  const listener = roomChannelListeners.get(roomId);
+  roomChannelListeners.delete(roomId);
+  if (listener) {
+    listener();
+  }
+}
+function linkDevTools(roomId, room) {
+  if (process.env.NODE_ENV === "production" || typeof window === "undefined") {
+    return;
+  }
+  sendToPanel({ msg: "room::available", roomId, clientVersion: VERSION });
+  stopRoomChannelListener(roomId);
+  roomChannelListeners.set(
+    roomId,
+    // Returns the unsubscribe callback, that we store in the
+    // roomChannelListeners registry
+    onMessageFromPanel.subscribe((msg) => {
+      switch (msg.msg) {
+        case "room::subscribe": {
+          if (msg.roomId === roomId) {
+            startSyncStream(room);
+          }
+          break;
+        }
+        case "room::unsubscribe": {
+          if (msg.roomId === roomId) {
+            stopSyncStream(roomId);
+          }
+          break;
+        }
+      }
+    })
+  );
+}
+function unlinkDevTools(roomId) {
+  if (process.env.NODE_ENV === "production" || typeof window === "undefined") {
+    return;
+  }
+  stopSyncStream(roomId);
+  stopRoomChannelListener(roomId);
+  sendToPanel({
+    msg: "room::unavailable",
+    roomId
+  });
+}
+
+// src/lib/deprecation.ts
+var _emittedDeprecationWarnings = /* @__PURE__ */ new Set();
+function deprecate(message, key = message) {
+  if (process.env.NODE_ENV !== "production") {
+    if (!_emittedDeprecationWarnings.has(key)) {
+      _emittedDeprecationWarnings.add(key);
+      errorWithTitle("Deprecation warning", message);
+    }
+  }
+}
+function deprecateIf(condition, message, key = message) {
+  if (process.env.NODE_ENV !== "production") {
+    if (condition) {
+      deprecate(message, key);
     }
   }
-  /**
-   * NOTE: Used by the E2E app only, to simulate explicit events.
-   * Not ideal to keep exposed :(
-   */
-  _privateSendMachineEvent(event) {
-    this.machine.send(event);
+}
+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/position.ts
 var MIN_CODE = 32;
@@ -3844,35 +4181,6 @@ function isJsonObject(data) {
   return !isJsonScalar(data) && !isJsonArray(data);
 }
 
-// src/protocol/AuthToken.ts
-function isTokenExpired(token) {
-  const now = Date.now() / 1e3;
-  const valid = now <= token.exp - 300 && now >= token.iat - 300;
-  return !valid;
-}
-function isStringList(value) {
-  return Array.isArray(value) && value.every((i) => typeof i === "string");
-}
-function isMinimalTokenPayload(data) {
-  return isPlainObject(data) && typeof data.iat === "number" && typeof data.exp === "number" && 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";
@@ -3884,20 +4192,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", {
@@ -3949,7 +4243,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 {
   //
@@ -3957,50 +4263,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();
   }
@@ -4008,14 +4317,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);
     }
   }
@@ -4024,8 +4336,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);
   }
   /**
@@ -4033,8 +4345,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);
     }
   }
@@ -4044,13 +4356,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);
     }
   }
@@ -4070,10 +4382,10 @@ var PatchableRef = class extends ImmutableRef {
    * Patches the current object.
    */
   patch(patch) {
-    const oldMe = this._data;
-    const newMe = merge(oldMe, patch);
-    if (oldMe !== newMe) {
-      this._data = freeze(newMe);
+    const oldData = this._data;
+    const newData = merge(oldData, patch);
+    if (oldData !== newData) {
+      this._data = freeze(newData);
       this.invalidate();
     }
   }
@@ -4130,17 +4442,7 @@ function userToTreeNode(key, user) {
 function createRoom(options, config) {
   const initialPresence = typeof options.initialPresence === "function" ? options.initialPresence(config.roomId) : options.initialPresence;
   const initialStorage = typeof options.initialStorage === "function" ? options.initialStorage(config.roomId) : options.initialStorage;
-  const delegates = config.delegates ?? {
-    authenticate: makeAuthDelegateForRoom(
-      config.roomId,
-      config.authentication,
-      config.polyfills?.fetch
-    ),
-    createSocket: makeCreateSocketDelegateForRoom(
-      config.liveblocksServer,
-      config.polyfills?.WebSocket
-    )
-  };
+  const delegates = config.delegates;
   const managedSocket = new ManagedSocket(
     delegates,
     config.enableDebugLogging
@@ -4149,7 +4451,7 @@ function createRoom(options, config) {
     buffer: {
       flushTimerID: void 0,
       lastFlushedAt: 0,
-      me: (
+      presenceUpdates: (
         // Queue up the initial presence message as a Full Presence™ update
         {
           type: "full",
@@ -4159,8 +4461,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,
@@ -4179,22 +4482,31 @@ function createRoom(options, config) {
   };
   const doNotBatchUpdates = (cb) => cb();
   const batchUpdates = config.unstable_batchedUpdates ?? doNotBatchUpdates;
-  let lastToken;
+  let lastTokenKey;
   function onStatusDidChange(newStatus) {
-    const token = managedSocket.token?.parsed;
-    if (token !== void 0 && token !== lastToken) {
-      context.sessionInfo.set({
-        userInfo: token.info,
-        userId: token.id,
-        // NOTE: In the future, these fields will get assigned in the connection phase
-        actor: token.actor,
-        isReadOnly: isStorageReadOnly(token.scopes)
-      });
-      lastToken = token;
+    const authValue = managedSocket.authValue;
+    if (authValue !== null) {
+      const tokenKey = authValue.type === "secret" ? authValue.token.raw : authValue.publicApiKey;
+      if (tokenKey !== lastTokenKey) {
+        lastTokenKey = tokenKey;
+        if (authValue.type === "secret") {
+          const token = authValue.token.parsed;
+          context.staticSessionInfo.set({
+            userId: token.k === "sec-legacy" /* SECRET_LEGACY */ ? token.id : token.uid,
+            userInfo: token.k === "sec-legacy" /* SECRET_LEGACY */ ? token.info : token.ui
+          });
+        } else {
+          context.staticSessionInfo.set({
+            userId: void 0,
+            userInfo: void 0
+          });
+        }
+      }
     }
     batchUpdates(() => {
       eventHub.status.notify(newStatus);
       eventHub.connection.notify(newToLegacyStatus(newStatus));
+      notifySelfChanged(doNotBatchUpdates);
     });
   }
   let _connectionLossTimerId;
@@ -4226,20 +4538,15 @@ function createRoom(options, config) {
     }
   }
   function onDidConnect() {
-    const sessionInfo = context.sessionInfo.current;
-    if (sessionInfo === null) {
-      throw new Error("Unexpected missing session info");
-    }
-    context.buffer.me = {
+    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 });
     }
@@ -4256,7 +4563,7 @@ function createRoom(options, config) {
   managedSocket.events.onLiveblocksError.subscribe((err) => {
     batchUpdates(() => {
       if (process.env.NODE_ENV !== "production") {
-        error(
+        error2(
           `Connection to websocket server closed. Reason: ${err.message} (code: ${err.code}).`
         );
       }
@@ -4304,7 +4611,12 @@ function createRoom(options, config) {
       }
     },
     assertStorageIsWritable: () => {
-      if (context.sessionInfo.current?.isReadOnly) {
+      const scopes = context.dynamicSessionInfo.current?.scopes;
+      if (scopes === void 0) {
+        return;
+      }
+      const canWrite = canWriteStorage(scopes);
+      if (!canWrite) {
         throw new Error(
           "Cannot write to storage with a read only user, please ensure the user has write permissions"
         );
@@ -4318,7 +4630,8 @@ function createRoom(options, config) {
     // New/recommended API
     lostConnection: makeEventSource(),
     customEvent: makeEventSource(),
-    me: makeEventSource(),
+    self: makeEventSource(),
+    myPresence: makeEventSource(),
     others: makeEventSource(),
     error: makeEventSource(),
     storage: makeEventSource(),
@@ -4331,16 +4644,18 @@ function createRoom(options, config) {
     const message = JSON.stringify(messageOrMessages);
     if (config.unstable_fallbackToHTTP) {
       const size = new TextEncoder().encode(message).length;
-      if (size > MAX_MESSAGE_SIZE && managedSocket.token?.raw && config.httpSendEndpoint) {
-        if (isTokenExpired(managedSocket.token.parsed)) {
-          return managedSocket.reconnect();
-        }
+      if (size > MAX_MESSAGE_SIZE && // TODO: support public api key auth in REST API
+      managedSocket.authValue?.type === "secret" && config.httpSendEndpoint) {
         void httpSend(
           message,
-          managedSocket.token.raw,
+          managedSocket.authValue.token.raw,
           config.httpSendEndpoint,
           config.polyfills?.fetch
-        );
+        ).then((resp) => {
+          if (!resp.ok && resp.status === 403) {
+            managedSocket.reconnect();
+          }
+        });
         warn(
           "Message was too large for websockets and sent over HTTP instead"
         );
@@ -4350,18 +4665,36 @@ 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;
+  function notifySelfChanged(batchedUpdatesWrapper) {
+    const currSelf = self.current;
+    if (currSelf !== null && currSelf !== _lastSelf) {
+      batchedUpdatesWrapper(() => {
+        eventHub.self.notify(currSelf);
+      });
+      _lastSelf = currSelf;
+    }
+  }
   const selfAsTreeNode = new DerivedRef(
     self,
     (me) => me !== null ? userToTreeNode("Me", me) : null
@@ -4420,16 +4753,18 @@ function createRoom(options, config) {
         }
       }
       if (presence) {
-        eventHub.me.notify(context.me.current);
+        notifySelfChanged(doNotBatchUpdates);
+        eventHub.myPresence.notify(context.myPresence.current);
       }
       if (storageUpdates.size > 0) {
         const updates = Array.from(storageUpdates.values());
         eventHub.storage.notify(updates);
       }
+      notifyStorageStatus();
     });
   }
   function getConnectionId() {
-    const info = context.sessionInfo.current;
+    const info = context.dynamicSessionInfo.current;
     if (info) {
       return info.actor;
     }
@@ -4458,14 +4793,14 @@ 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);
-        if (context.buffer.me === null) {
-          context.buffer.me = { type: "partial", data: op.data };
+        context.myPresence.patch(op.data);
+        if (context.buffer.presenceUpdates === null) {
+          context.buffer.presenceUpdates = { type: "partial", data: op.data };
         } else {
           for (const key in op.data) {
-            context.buffer.me.data[key] = op.data[key];
+            context.buffer.presenceUpdates.data[key] = op.data[key];
           }
         }
         output.reverse.unshift(reverse);
@@ -4501,7 +4836,6 @@ function createRoom(options, config) {
         }
       }
     }
-    notifyStorageStatus();
     return {
       ops,
       reverse: output.reverse,
@@ -4556,8 +4890,8 @@ function createRoom(options, config) {
   }
   function updatePresence(patch, options2) {
     const oldValues = {};
-    if (context.buffer.me === null) {
-      context.buffer.me = {
+    if (context.buffer.presenceUpdates === null) {
+      context.buffer.presenceUpdates = {
         type: "partial",
         data: {}
       };
@@ -4567,10 +4901,10 @@ function createRoom(options, config) {
       if (overrideValue === void 0) {
         continue;
       }
-      context.buffer.me.data[key] = overrideValue;
-      oldValues[key] = context.me.current[key];
+      context.buffer.presenceUpdates.data[key] = overrideValue;
+      oldValues[key] = context.myPresence.current[key];
     }
-    context.me.patch(patch);
+    context.myPresence.patch(patch);
     if (context.activeBatch) {
       if (options2?.addToHistory) {
         context.activeBatch.reverseOps.unshift({
@@ -4592,9 +4926,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);
@@ -4625,11 +4956,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) {
@@ -4639,7 +4976,7 @@ function createRoom(options, config) {
         connectionId,
         user.id,
         user.info,
-        isStorageReadOnly(user.scopes)
+        user.scopes
       );
     }
     return { type: "reset" };
@@ -4660,11 +4997,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();
@@ -4749,7 +5086,7 @@ function createRoom(options, config) {
             break;
           }
           case 104 /* ROOM_STATE */: {
-            updates.others.push(onRoomStateMessage(message));
+            updates.others.push(onRoomStateMessage(message, doNotBatchUpdates));
             break;
           }
           case 200 /* INITIAL_STORAGE_STATE */: {
@@ -4828,7 +5165,7 @@ ${Array.from(traces).join("\n\n")}`
         lastFlushedAt: now,
         messages: [],
         storageOperations: [],
-        me: null
+        presenceUpdates: null
       };
     } else {
       clearTimeout(context.buffer.flushTimerID);
@@ -4840,18 +5177,18 @@ ${Array.from(traces).join("\n\n")}`
   }
   function serializeBuffer() {
     const messages = [];
-    if (context.buffer.me) {
+    if (context.buffer.presenceUpdates) {
       messages.push(
-        context.buffer.me.type === "full" ? {
+        context.buffer.presenceUpdates.type === "full" ? {
           type: 100 /* UPDATE_PRESENCE */,
           // Populating the `targetActor` field turns this message into
           // a Full Presence™ update message (not a patch), which will get
           // interpreted by other clients as such.
           targetActor: -1,
-          data: context.buffer.me.data
+          data: context.buffer.presenceUpdates.data
         } : {
           type: 100 /* UPDATE_PRESENCE */,
-          data: context.buffer.me.data
+          data: context.buffer.presenceUpdates.data
         }
       );
     }
@@ -5053,7 +5390,8 @@ ${Array.from(traces).join("\n\n")}`
     lostConnection: eventHub.lostConnection.observable,
     customEvent: eventHub.customEvent.observable,
     others: eventHub.others.observable,
-    me: eventHub.me.observable,
+    self: eventHub.self.observable,
+    myPresence: eventHub.myPresence.observable,
     error: eventHub.error.observable,
     storage: eventHub.storage.observable,
     history: eventHub.history.observable,
@@ -5061,65 +5399,70 @@ ${Array.from(traces).join("\n\n")}`
     storageStatus: eventHub.storageStatus.observable,
     ydoc: eventHub.ydoc.observable
   };
-  return {
-    /* NOTE: Exposing __internal here only to allow testing implementation details in unit tests */
-    __internal: {
-      get buffer() {
-        return context.buffer;
-      },
-      // prettier-ignore
-      get undoStack() {
-        return context.undoStack;
+  return Object.defineProperty(
+    {
+      /* NOTE: Exposing __internal here only to allow testing implementation details in unit tests */
+      __internal: {
+        get presenceBuffer() {
+          return deepClone(context.buffer.presenceUpdates?.data ?? null);
+        },
+        // prettier-ignore
+        get undoStack() {
+          return deepClone(context.undoStack);
+        },
+        // prettier-ignore
+        get nodeCount() {
+          return context.nodes.size;
+        },
+        // prettier-ignore
+        // Support for the Liveblocks browser extension
+        getSelf_forDevTools: () => selfAsTreeNode.current,
+        getOthers_forDevTools: () => others_forDevTools.current,
+        // prettier-ignore
+        send: {
+          // These exist only for our E2E testing app
+          explicitClose: (event) => managedSocket._privateSendMachineEvent({ type: "EXPLICIT_SOCKET_CLOSE", event }),
+          implicitClose: () => managedSocket._privateSendMachineEvent({ type: "NAVIGATOR_OFFLINE" })
+        }
       },
-      // prettier-ignore
-      get nodeCount() {
-        return context.nodes.size;
+      id: config.roomId,
+      subscribe: makeClassicSubscribeFn(events),
+      connect: () => managedSocket.connect(),
+      reconnect: () => managedSocket.reconnect(),
+      disconnect: () => managedSocket.disconnect(),
+      destroy: () => managedSocket.destroy(),
+      // Presence
+      updatePresence,
+      updateYDoc,
+      broadcastEvent,
+      // Storage
+      batch,
+      history: {
+        undo,
+        redo,
+        canUndo,
+        canRedo,
+        pause: pauseHistory,
+        resume: resumeHistory
       },
-      // prettier-ignore
-      // Support for the Liveblocks browser extension
-      getSelf_forDevTools: () => selfAsTreeNode.current,
-      getOthers_forDevTools: () => others_forDevTools.current,
-      // prettier-ignore
-      send: {
-        // These exist only for our E2E testing app
-        explicitClose: (event) => managedSocket._privateSendMachineEvent({ type: "EXPLICIT_SOCKET_CLOSE", event }),
-        implicitClose: () => managedSocket._privateSendMachineEvent({ type: "NAVIGATOR_OFFLINE" })
-      }
-    },
-    id: config.roomId,
-    subscribe: makeClassicSubscribeFn(events),
-    connect: () => managedSocket.connect(),
-    reconnect: () => managedSocket.reconnect(),
-    disconnect: () => managedSocket.disconnect(),
-    destroy: () => managedSocket.destroy(),
-    // Presence
-    updatePresence,
-    updateYDoc,
-    broadcastEvent,
-    // Storage
-    batch,
-    history: {
-      undo,
-      redo,
-      canUndo,
-      canRedo,
-      pause: pauseHistory,
-      resume: resumeHistory
+      fetchYDoc,
+      getStorage,
+      getStorageSnapshot,
+      getStorageStatus,
+      events,
+      // Core
+      getStatus: () => managedSocket.getStatus(),
+      getConnectionState: () => managedSocket.getLegacyStatus(),
+      getSelf: () => self.current,
+      // Presence
+      getPresence: () => context.myPresence.current,
+      getOthers: () => context.others.current
     },
-    fetchYDoc,
-    getStorage,
-    getStorageSnapshot,
-    getStorageStatus,
-    events,
-    // Core
-    getStatus: () => managedSocket.getStatus(),
-    getConnectionState: () => managedSocket.getLegacyStatus(),
-    isSelfAware: () => context.sessionInfo.current !== null,
-    getSelf: () => self.current,
-    // Presence
-    getPresence: () => context.me.current,
-    getOthers: () => context.others.current
-  };
+    // Explictly make the __internal field non-enumerable, to avoid aggressive
+    // freezing when used with Immer
+    "__internal",
+    { enumerable: false }
+  );
 }
 function makeClassicSubscribeFn(events) {
   function subscribeToLiveStructureDeeply(node, callback) {
@@ -5153,7 +5496,7 @@ function makeClassicSubscribeFn(events) {
             callback
           );
         case "my-presence":
-          return events.me.subscribe(callback);
+          return events.myPresence.subscribe(callback);
         case "others": {
           const cb = callback;
           return events.others.subscribe(
@@ -5207,24 +5550,30 @@ function makeClassicSubscribeFn(events) {
 function isRoomEventName(value) {
   return value === "my-presence" || value === "others" || value === "event" || value === "error" || value === "history" || value === "status" || value === "storage-status" || value === "lost-connection" || value === "connection";
 }
-function makeCreateSocketDelegateForRoom(liveblocksServer, WebSocketPolyfill) {
-  return (richToken) => {
+function makeAuthDelegateForRoom(roomId, authManager) {
+  return async () => {
+    return authManager.getAuthValue("room:read", roomId);
+  };
+}
+function makeCreateSocketDelegateForRoom(roomId, liveblocksServer, WebSocketPolyfill) {
+  return (authValue) => {
     const ws = WebSocketPolyfill ?? (typeof WebSocket === "undefined" ? void 0 : WebSocket);
     if (ws === void 0) {
       throw new StopRetrying(
         "To use Liveblocks client in a non-dom environment, you need to provide a WebSocket polyfill."
       );
     }
-    const token = richToken.raw;
-    return new ws(
-      `${liveblocksServer}/?token=${token}&version=${// prettier-ignore
-      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-      // @ts-ignore (__PACKAGE_VERSION__ will be injected by the build script)
-      true ? (
-        /* istanbul ignore next */
-        "1.2.0-internal6"
-      ) : "dev"}`
-    );
+    const url = new URL(liveblocksServer);
+    url.searchParams.set("roomId", roomId);
+    if (authValue.type === "secret") {
+      url.searchParams.set("tok", authValue.token.raw);
+    } else if (authValue.type === "public") {
+      url.searchParams.set("pubkey", authValue.publicApiKey);
+    } else {
+      return assertNever(authValue, "Unhandled case");
+    }
+    url.searchParams.set("version", PKG_VERSION || "dev");
+    return new ws(url.toString());
   };
 }
 async function httpSend(message, token, endpoint, fetchPolyfill) {
@@ -5239,83 +5588,6 @@ async function httpSend(message, token, endpoint, fetchPolyfill) {
     body: message
   });
 }
-function makeAuthDelegateForRoom(roomId, authentication, fetchPolyfill) {
-  const fetcher = fetchPolyfill ?? (typeof window === "undefined" ? void 0 : window.fetch);
-  if (authentication.type === "public") {
-    return async () => {
-      if (fetcher === void 0) {
-        throw new StopRetrying(
-          "To use Liveblocks client in a non-dom environment with a publicApiKey, you need to provide a fetch polyfill."
-        );
-      }
-      return fetchAuthEndpoint(fetcher, authentication.url, {
-        room: roomId,
-        publicApiKey: authentication.publicApiKey
-      }).then(({ token }) => parseAuthToken(token));
-    };
-  } else if (authentication.type === "private") {
-    return async () => {
-      if (fetcher === void 0) {
-        throw new StopRetrying(
-          "To use Liveblocks client in a non-dom environment with a url as auth endpoint, you need to provide a fetch polyfill."
-        );
-      }
-      return fetchAuthEndpoint(fetcher, authentication.url, {
-        room: roomId
-      }).then(({ token }) => parseAuthToken(token));
-    };
-  } else if (authentication.type === "custom") {
-    return async () => {
-      const response = await authentication.callback(roomId);
-      if (!response || !response.token) {
-        throw new Error(
-          'We expect the authentication callback to return a token, but it does not. Hint: the return value should look like: { token: "..." }'
-        );
-      }
-      return parseAuthToken(response.token);
-    };
-  } else {
-    throw new Error("Internal error. Unexpected authentication type");
-  }
-}
-async function fetchAuthEndpoint(fetch2, endpoint, body) {
-  const res = await fetch2(endpoint, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json"
-    },
-    // Credentials are needed to support authentication with cookies
-    credentials: "include",
-    body: JSON.stringify(body)
-  });
-  if (!res.ok) {
-    const reason = `${(await res.text()).trim() || "reason not provided in auth response"} (${res.status} returned by POST ${endpoint})`;
-    if (res.status === 401 || res.status === 403) {
-      throw new StopRetrying(`Unauthorized: ${reason}`);
-    } else {
-      throw new Error(`Failed to authenticate: ${reason}`);
-    }
-  }
-  let data;
-  try {
-    data = await res.json();
-  } catch (er) {
-    throw new Error(
-      `Expected a JSON response when doing a POST request on "${endpoint}". ${String(
-        er
-      )}`
-    );
-  }
-  if (!isPlainObject(data) || typeof data.token !== "string") {
-    throw new Error(
-      `Expected a JSON response of the form \`{ token: "..." }\` when doing a POST request on "${endpoint}", but got ${JSON.stringify(
-        data
-      )}`
-    );
-  }
-  const { token } = data;
-  return { token };
-}
 
 // src/client.ts
 var MIN_THROTTLE = 16;
@@ -5327,7 +5599,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;
@@ -5335,6 +5607,7 @@ function createClient(options) {
   const lostConnectionTimeout = getLostConnectionTimeout(
     clientOptions.lostConnectionTimeout ?? DEFAULT_LOST_CONNECTION_TIMEOUT
   );
+  const authManager = createAuthManager(options);
   const rooms = /* @__PURE__ */ new Map();
   function getRoom(roomId) {
     const room = rooms.get(roomId);
@@ -5359,11 +5632,17 @@ function createClient(options) {
         throttleDelay,
         lostConnectionTimeout,
         polyfills: clientOptions.polyfills,
-        delegates: clientOptions.mockedDelegates,
+        delegates: clientOptions.mockedDelegates ?? {
+          createSocket: makeCreateSocketDelegateForRoom(
+            roomId,
+            getServerFromClientOptions(clientOptions),
+            clientOptions.polyfills?.WebSocket
+          ),
+          authenticate: makeAuthDelegateForRoom(roomId, authManager)
+        },
         enableDebugLogging: clientOptions.enableDebugLogging,
         unstable_batchedUpdates: options2?.unstable_batchedUpdates,
         liveblocksServer: getServerFromClientOptions(clientOptions),
-        authentication: prepareAuthentication(clientOptions, roomId),
         httpSendEndpoint: buildLiveblocksHttpSendEndpoint(
           clientOptions,
           roomId
@@ -5422,48 +5701,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);
@@ -5472,14 +5709,6 @@ function buildLiveblocksHttpSendEndpoint(options, roomId) {
     roomId
   )}/send-message`;
 }
-function buildLiveblocksPublicAuthorizeEndpoint(options, roomId) {
-  if (options.publicAuthorizeEndpoint) {
-    return options.publicAuthorizeEndpoint.replace("{roomId}", roomId);
-  }
-  return `https://api.liveblocks.io/v2/rooms/${encodeURIComponent(
-    roomId
-  )}/public/authorize`;
-}
 
 // src/crdts/utils.ts
 function toPlainLson(lson) {
@@ -5638,7 +5867,7 @@ function patchLiveObjectKey(liveObject, key, prev, next) {
   if (process.env.NODE_ENV !== "production") {
     const nonSerializableValue = findNonSerializableValue(next);
     if (nonSerializableValue) {
-      error(
+      error2(
         `New state path: '${nonSerializableValue.path}' value: '${String(
           nonSerializableValue.value
         )}' is not serializable.
@@ -5852,18 +6081,8 @@ 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/index.ts
+detectDupes(PKG_NAME, PKG_VERSION, PKG_FORMAT);
 export {
   ClientMsgCode,
   CrdtType,
@@ -5881,6 +6100,7 @@ export {
   createClient,
   deprecate,
   deprecateIf,
+  detectDupes,
   errorIf,
   freeze,
   isChildCrdt,