@liveblocks/core 1.0.8 → 1.0.10

package/dist/index.d.ts

@@ -129,6 +129,63 @@ declare type UpdateDelta = {
     type: "delete";
 };
 
+/**
+ * "Plain LSON" is a JSON-based format that's used when serializing Live structures
+ * to send them over HTTP (e.g. in the API endpoint to let users upload their initial
+ * Room storage, in the API endpoint to fetch a Room's storage, ...).
+ *
+ * In the client, you would typically create LSON values using:
+ *
+ *    new LiveObject({ x: 0, y: 0 })
+ *
+ * But over HTTP, this has to be serialized somehow. The "Plain LSON" format
+ * is what's used in the POST /init-storage-new endpoint, to allow users to
+ * control which parts of their data structure should be considered "Live"
+ * objects, and which parts are "normal" objects.
+ *
+ * So if they have a structure like:
+ *
+ *    { x: 0, y: 0 }
+ *
+ * And want to make it a Live object, they can serialize it by wrapping it in
+ * a special "annotation":
+ *
+ *    {
+ *      "liveblocksType": "LiveObject",
+ *      "data": { x: 0, y: 0 },
+ *    }
+ *
+ * This "Plain LSON" data format defines exactly those wrappings.
+ *
+ * To summarize:
+ *
+ *   LSON value            |  Plain LSON equivalent
+ *   ----------------------+----------------------------------------------
+ *   42                    |  42
+ *   [1, 2, 3]             |  [1, 2, 3]
+ *   { x: 0, y: 0 }        |  { x: 0, y: 0 }
+ *   ----------------------+----------------------------------------------
+ *   new LiveList(...)     |  { liveblocksType: "LiveList",   data: ... }
+ *   new LiveMap(...)      |  { liveblocksType: "LiveMap",    data: ... }
+ *   new LiveObject(...)   |  { liveblocksType: "LiveObject", data: ... }
+ *
+ */
+
+declare type PlainLsonFields = Record<string, PlainLson>;
+declare type PlainLsonObject = {
+    liveblocksType: "LiveObject";
+    data: PlainLsonFields;
+};
+declare type PlainLsonMap = {
+    liveblocksType: "LiveMap";
+    data: PlainLsonFields;
+};
+declare type PlainLsonList = {
+    liveblocksType: "LiveList";
+    data: PlainLson[];
+};
+declare type PlainLson = PlainLsonObject | PlainLsonMap | PlainLsonList | Json;
+
 declare type LiveObjectUpdateDelta<O extends {
     [key: string]: unknown;
 }> = {
@@ -197,6 +254,10 @@ declare class LiveObject<O extends LsonObject> extends AbstractCrdt {
 declare type ToImmutable<L extends Lson | LsonObject> = L extends LiveList<infer I> ? readonly ToImmutable<I>[] : L extends LiveObject<infer O> ? ToImmutable<O> : L extends LiveMap<infer K, infer V> ? ReadonlyMap<K, ToImmutable<V>> : L extends LsonObject ? {
     readonly [K in keyof L]: ToImmutable<Exclude<L[K], undefined>> | (undefined extends L[K] ? undefined : never);
 } : L extends Json ? L : never;
+/**
+ * Returns PlainLson for a given Json or LiveStructure, suitable for calling the storage init api
+ */
+declare function toPlainLson(lson: Lson): PlainLson;
 
 /**
  * A LiveMap notification that is sent in-client to any subscribers whenever
@@ -268,12 +329,15 @@ declare class LiveMap<TKey extends string, TValue extends Lson> extends Abstract
 }
 
 declare type StorageCallback = (updates: StorageUpdate[]) => void;
+declare type LiveMapUpdate = LiveMapUpdates<string, Lson>;
+declare type LiveObjectUpdate = LiveObjectUpdates<LsonObject>;
+declare type LiveListUpdate = LiveListUpdates<Lson>;
 /**
  * The payload of notifications sent (in-client) when LiveStructures change.
  * Messages of this kind are not originating from the network, but are 100%
  * in-client.
  */
-declare type StorageUpdate = LiveMapUpdates<string, Lson> | LiveObjectUpdates<LsonObject> | LiveListUpdates<Lson>;
+declare type StorageUpdate = LiveMapUpdate | LiveObjectUpdate | LiveListUpdate;
 
 declare abstract class AbstractCrdt {
     get roomId(): string | null;
@@ -1051,6 +1115,7 @@ declare type AuthEndpoint = string | ((room: string) => Promise<{
 declare type ClientOptions = {
     throttle?: number;
     polyfills?: Polyfills;
+    unstable_fallbackToHTTP?: boolean;
     /**
      * Backward-compatible way to set `polyfills.fetch`.
      */
@@ -1546,63 +1611,6 @@ SerializedCrdt>;
 declare type ParentToChildNodeMap = Map<string, // Parent's node ID
 IdTuple<SerializedChild>[]>;
 
-/**
- * "Plain LSON" is a JSON-based format that's used when serializing Live structures
- * to send them over HTTP (e.g. in the API endpoint to let users upload their initial
- * Room storage, in the API endpoint to fetch a Room's storage, ...).
- *
- * In the client, you would typically create LSON values using:
- *
- *    new LiveObject({ x: 0, y: 0 })
- *
- * But over HTTP, this has to be serialized somehow. The "Plain LSON" format
- * is what's used in the POST /init-storage-new endpoint, to allow users to
- * control which parts of their data structure should be considered "Live"
- * objects, and which parts are "normal" objects.
- *
- * So if they have a structure like:
- *
- *    { x: 0, y: 0 }
- *
- * And want to make it a Live object, they can serialize it by wrapping it in
- * a special "annotation":
- *
- *    {
- *      "liveblocksType": "LiveObject",
- *      "data": { x: 0, y: 0 },
- *    }
- *
- * This "Plain LSON" data format defines exactly those wrappings.
- *
- * To summarize:
- *
- *   LSON value            |  Plain LSON equivalent
- *   ----------------------+----------------------------------------------
- *   42                    |  42
- *   [1, 2, 3]             |  [1, 2, 3]
- *   { x: 0, y: 0 }        |  { x: 0, y: 0 }
- *   ----------------------+----------------------------------------------
- *   new LiveList(...)     |  { liveblocksType: "LiveList",   data: ... }
- *   new LiveMap(...)      |  { liveblocksType: "LiveMap",    data: ... }
- *   new LiveObject(...)   |  { liveblocksType: "LiveObject", data: ... }
- *
- */
-
-declare type PlainLsonFields = Record<string, PlainLson>;
-declare type PlainLsonObject = {
-    liveblocksType: "LiveObject";
-    data: PlainLsonFields;
-};
-declare type PlainLsonMap = {
-    liveblocksType: "LiveMap";
-    data: PlainLsonFields;
-};
-declare type PlainLsonList = {
-    liveblocksType: "LiveList";
-    data: PlainLson[];
-};
-declare type PlainLson = PlainLsonObject | PlainLsonMap | PlainLsonList | Json;
-
 declare type JsonTreeNode = {
     readonly type: "Json";
     readonly id: string;
@@ -1779,4 +1787,4 @@ declare type EnsureJson<T> = [
     [K in keyof T]: EnsureJson<T[K]>;
 };
 
-export { AckOp, AppOnlyAuthToken, AuthToken, BaseUserMeta, BroadcastEventClientMsg, BroadcastOptions, BroadcastedEventServerMsg, Client, ClientMsg, ClientMsgCode, ConnectionStatus, CrdtType, CreateChildOp, CreateListOp, CreateMapOp, CreateObjectOp, CreateOp, CreateRegisterOp, CreateRootObjectOp, DeleteCrdtOp, DeleteObjectKeyOp, DevToolsTreeNode as DevTools, protocol as DevToolsMsg, EnsureJson, FetchStorageClientMsg, History, IWebSocket, IWebSocketCloseEvent, IWebSocketEvent, IWebSocketInstance, IWebSocketMessageEvent, IdTuple, Immutable, InitialDocumentStateServerMsg, Json, JsonArray, JsonObject, JsonScalar, LiveList, LiveMap, LiveNode, LiveObject, LiveStructure, Lson, LsonObject, NodeMap, Op, OpCode, Others, ParentToChildNodeMap, PlainLson, PlainLsonFields, PlainLsonList, PlainLsonMap, PlainLsonObject, RejectedStorageOpServerMsg, Resolve, Room, RoomAuthToken, RoomInitializers, RoomStateServerMsg, SerializedChild, SerializedCrdt, SerializedList, SerializedMap, SerializedObject, SerializedRegister, SerializedRootObject, ServerMsg, ServerMsgCode, SetParentKeyOp, StorageStatus, StorageUpdate, ToImmutable, ToJson, UpdateObjectOp, UpdatePresenceClientMsg, UpdatePresenceServerMsg, UpdateStorageClientMsg, UpdateStorageServerMsg, User, UserJoinServerMsg, UserLeftServerMsg, WebsocketCloseCodes, asArrayWithLegacyMethods, asPos, assert, assertNever, b64decode, createClient, deprecate, deprecateIf, errorIf, freeze, isAppOnlyAuthToken, isAuthToken, isChildCrdt, isJsonArray, isJsonObject, isJsonScalar, isPlainObject, isRoomAuthToken, isRootCrdt, legacy_patchImmutableObject, lsonToJson, makePosition, nn, patchLiveObjectKey, shallow, throwUsageError, tryParseJson };
+export { AckOp, AppOnlyAuthToken, AuthToken, BaseUserMeta, BroadcastEventClientMsg, BroadcastOptions, BroadcastedEventServerMsg, Client, ClientMsg, ClientMsgCode, ConnectionStatus, CrdtType, CreateChildOp, CreateListOp, CreateMapOp, CreateObjectOp, CreateOp, CreateRegisterOp, CreateRootObjectOp, DeleteCrdtOp, DeleteObjectKeyOp, DevToolsTreeNode as DevTools, protocol as DevToolsMsg, EnsureJson, FetchStorageClientMsg, History, IWebSocket, IWebSocketCloseEvent, IWebSocketEvent, IWebSocketInstance, IWebSocketMessageEvent, IdTuple, Immutable, InitialDocumentStateServerMsg, Json, JsonArray, JsonObject, JsonScalar, LiveList, LiveListUpdate, LiveMap, LiveMapUpdate, LiveNode, LiveObject, LiveObjectUpdate, LiveStructure, Lson, LsonObject, NodeMap, Op, OpCode, Others, ParentToChildNodeMap, PlainLson, PlainLsonFields, PlainLsonList, PlainLsonMap, PlainLsonObject, RejectedStorageOpServerMsg, Resolve, Room, RoomAuthToken, RoomInitializers, RoomStateServerMsg, SerializedChild, SerializedCrdt, SerializedList, SerializedMap, SerializedObject, SerializedRegister, SerializedRootObject, ServerMsg, ServerMsgCode, SetParentKeyOp, StorageStatus, StorageUpdate, ToImmutable, ToJson, UpdateObjectOp, UpdatePresenceClientMsg, UpdatePresenceServerMsg, UpdateStorageClientMsg, UpdateStorageServerMsg, User, UserJoinServerMsg, UserLeftServerMsg, WebsocketCloseCodes, asArrayWithLegacyMethods, asPos, assert, assertNever, b64decode, createClient, deprecate, deprecateIf, errorIf, freeze, isAppOnlyAuthToken, isAuthToken, isChildCrdt, isJsonArray, isJsonObject, isJsonScalar, isPlainObject, isRoomAuthToken, isRootCrdt, legacy_patchImmutableObject, lsonToJson, makePosition, nn, patchLiveObjectKey, shallow, throwUsageError, toPlainLson, tryParseJson };

package/dist/index.js

@@ -117,7 +117,7 @@ var onMessageFromPanel = eventSource.observable;
 // src/devtools/index.ts
 var VERSION = true ? (
   /* istanbul ignore next */
-  "1.0.8"
+  "1.0.10"
 ) : "dev";
 var _devtoolsSetupHasRun = false;
 function setupDevTools(getAllRooms) {
@@ -2955,7 +2955,8 @@ function hasJwtMeta(data) {
 }
 function isTokenExpired(token) {
   const now = Date.now() / 1e3;
-  return now > token.exp - 300 || now < token.iat + 300;
+  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");
@@ -2983,20 +2984,22 @@ function parseJwtToken(token) {
 }
 function parseRoomAuthToken(tokenString) {
   const data = parseJwtToken(tokenString);
-  if (data && isRoomAuthToken(data)) {
-    const _a = data, {
-      maxConnections: _legacyField
-    } = _a, token = __objRest(_a, [
-      // If this legacy field is found on the token, pretend it wasn't there,
-      // to make all internally used token payloads uniform
-      "maxConnections"
-    ]);
-    return token;
-  } else {
+  if (!(data && isRoomAuthToken(data))) {
     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"
     );
   }
+  const _a = data, {
+    maxConnections: _legacyField
+  } = _a, parsedToken = __objRest(_a, [
+    // If this legacy field is found on the token, pretend it wasn't there,
+    // to make all internally used token payloads uniform
+    "maxConnections"
+  ]);
+  return {
+    raw: tokenString,
+    parsed: parsedToken
+  };
 }
 
 // src/protocol/ClientMsg.ts
@@ -3255,6 +3258,7 @@ var BACKOFF_RETRY_DELAYS = [250, 500, 1e3, 2e3, 4e3, 8e3, 1e4];
 var BACKOFF_RETRY_DELAYS_SLOW = [2e3, 3e4, 6e4, 3e5];
 var HEARTBEAT_INTERVAL = 3e4;
 var PONG_TIMEOUT = 2e3;
+var MAX_MESSAGE_SIZE = 1024 * 1024 - 128;
 function makeIdFactory(connectionId) {
   let count = 0;
   return () => `${connectionId}:${count++}`;
@@ -3380,21 +3384,20 @@ function createRoom(options, config) {
     storageStatus: makeEventSource()
   };
   const effects = config.mockedEffects || {
-    authenticate(auth, createWebSocket) {
+    authenticateAndConnect(auth, createWebSocket) {
       const prevToken = context.token;
       if (prevToken !== null && !isTokenExpired(prevToken.parsed)) {
-        const socket = createWebSocket(prevToken.raw);
-        authenticationSuccess(prevToken.parsed, socket);
+        const socket = createWebSocket(prevToken);
+        handleAuthSuccess(prevToken.parsed, socket);
         return void 0;
       } else {
-        void auth(config.roomId).then(({ token }) => {
+        void auth().then((token) => {
           if (context.connection.current.status !== "authenticating") {
             return;
           }
-          const parsedToken = parseRoomAuthToken(token);
           const socket = createWebSocket(token);
-          authenticationSuccess(parsedToken, socket);
-          context.token = { raw: token, parsed: parsedToken };
+          handleAuthSuccess(token.parsed, socket);
+          context.token = token;
         }).catch(
           (er) => authenticationFailure(
             er instanceof Error ? er : new Error(String(er))
@@ -3404,15 +3407,34 @@ function createRoom(options, config) {
       }
     },
     send(messageOrMessages) {
+      var _a2, _b;
       if (context.socket === null) {
         throw new Error("Can't send message if socket is null");
       }
       if (context.socket.readyState === context.socket.OPEN) {
-        context.socket.send(JSON.stringify(messageOrMessages));
+        const message = JSON.stringify(messageOrMessages);
+        if (config.unstable_fallbackToHTTP) {
+          const size = new TextEncoder().encode(message).length;
+          if (size > MAX_MESSAGE_SIZE && ((_a2 = context.token) == null ? void 0 : _a2.raw) && config.httpSendEndpoint) {
+            if (isTokenExpired(context.token.parsed)) {
+              return reconnect();
+            }
+            void httpSend(
+              message,
+              context.token.raw,
+              config.httpSendEndpoint,
+              (_b = config.polyfills) == null ? void 0 : _b.fetch
+            );
+            warn(
+              "Message was too large for websockets and sent over HTTP instead"
+            );
+            return;
+          }
+        }
+        context.socket.send(message);
       }
     },
-    scheduleFlush: (delay) => setTimeout(tryFlushing, delay),
-    scheduleReconnect: (delay) => setTimeout(connect, delay),
+    scheduleReconnect: (delay) => setTimeout(handleConnect, delay),
     startHeartbeatInterval: () => setInterval(heartbeat, HEARTBEAT_INTERVAL),
     schedulePongTimeout: () => setTimeout(pongTimeout, PONG_TIMEOUT)
   };
@@ -3621,12 +3643,13 @@ function createRoom(options, config) {
       }
     }
   }
-  function connect() {
+  function handleConnect() {
     var _a2, _b;
     if (context.connection.current.status !== "closed" && context.connection.current.status !== "unavailable") {
       return;
     }
     const auth = prepareAuthEndpoint(
+      config.roomId,
       config.authentication,
       (_a2 = config.polyfills) == null ? void 0 : _a2.fetch
     );
@@ -3635,7 +3658,7 @@ function createRoom(options, config) {
       (_b = config.polyfills) == null ? void 0 : _b.WebSocket
     );
     updateConnection({ status: "authenticating" }, batchUpdates);
-    effects.authenticate(auth, createWebSocket);
+    effects.authenticateAndConnect(auth, createWebSocket);
   }
   function updatePresence(patch, options2) {
     const oldValues = {};
@@ -3678,11 +3701,11 @@ 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 authenticationSuccess(token, socket) {
-    socket.addEventListener("message", onMessage);
-    socket.addEventListener("open", onOpen);
-    socket.addEventListener("close", onClose);
-    socket.addEventListener("error", onError);
+  function handleAuthSuccess(token, socket) {
+    socket.addEventListener("message", handleRawSocketMessage);
+    socket.addEventListener("open", handleSocketOpen);
+    socket.addEventListener("close", handleExplicitClose);
+    socket.addEventListener("error", handleSocketError);
     updateConnection(
       {
         status: "connecting",
@@ -3706,8 +3729,8 @@ function createRoom(options, config) {
     clearTimeout(context.timers.reconnect);
     context.timers.reconnect = effects.scheduleReconnect(getRetryDelay());
   }
-  function onVisibilityChange(visibilityState) {
-    if (visibilityState === "visible" && context.connection.current.status === "open") {
+  function handleWindowGotFocus() {
+    if (context.connection.current.status === "open") {
       log("Heartbeat after visibility change");
       heartbeat();
     }
@@ -3761,7 +3784,7 @@ function createRoom(options, config) {
     }
     return { type: "reset" };
   }
-  function onNavigatorOnline() {
+  function handleNavigatorBackOnline() {
     if (context.connection.current.status === "unavailable") {
       log("Try to reconnect after connectivity change");
       reconnect();
@@ -3824,11 +3847,17 @@ function createRoom(options, config) {
     notify(result.updates, batchedUpdatesWrapper);
     effects.send(messages);
   }
-  function onMessage(event) {
+  function handleRawSocketMessage(event) {
     if (event.data === "pong") {
-      clearTimeout(context.timers.pongTimeout);
-      return;
+      transition({ type: "RECEIVE_PONG" });
+    } else {
+      handleServerMessage(event);
     }
+  }
+  function handlePong() {
+    clearTimeout(context.timers.pongTimeout);
+  }
+  function handleServerMessage(event) {
     if (typeof event.data !== "string") {
       return;
     }
@@ -3929,7 +3958,7 @@ ${Array.from(traces).join("\n\n")}`
       notify(updates, doNotBatchUpdates);
     });
   }
-  function onClose(event) {
+  function handleExplicitClose(event) {
     context.socket = null;
     clearTimeout(context.timers.flush);
     clearTimeout(context.timers.reconnect);
@@ -3980,9 +4009,9 @@ ${Array.from(traces).join("\n\n")}`
     }
     return BACKOFF_RETRY_DELAYS[context.numRetries < BACKOFF_RETRY_DELAYS.length ? context.numRetries : BACKOFF_RETRY_DELAYS.length - 1];
   }
-  function onError() {
+  function handleSocketError() {
   }
-  function onOpen() {
+  function handleSocketOpen() {
     clearInterval(context.timers.heartbeat);
     context.timers.heartbeat = effects.startHeartbeatInterval();
     if (context.connection.current.status === "connecting") {
@@ -4025,12 +4054,12 @@ ${Array.from(traces).join("\n\n")}`
     log("Pong timeout. Trying to reconnect.");
     reconnect();
   }
-  function disconnect() {
+  function handleDisconnect() {
     if (context.socket) {
-      context.socket.removeEventListener("open", onOpen);
-      context.socket.removeEventListener("message", onMessage);
-      context.socket.removeEventListener("close", onClose);
-      context.socket.removeEventListener("error", onError);
+      context.socket.removeEventListener("open", handleSocketOpen);
+      context.socket.removeEventListener("message", handleRawSocketMessage);
+      context.socket.removeEventListener("close", handleExplicitClose);
+      context.socket.removeEventListener("error", handleSocketError);
       context.socket.close();
       context.socket = null;
     }
@@ -4049,10 +4078,10 @@ ${Array.from(traces).join("\n\n")}`
   }
   function reconnect() {
     if (context.socket) {
-      context.socket.removeEventListener("open", onOpen);
-      context.socket.removeEventListener("message", onMessage);
-      context.socket.removeEventListener("close", onClose);
-      context.socket.removeEventListener("error", onError);
+      context.socket.removeEventListener("open", handleSocketOpen);
+      context.socket.removeEventListener("message", handleRawSocketMessage);
+      context.socket.removeEventListener("close", handleExplicitClose);
+      context.socket.removeEventListener("error", handleSocketError);
       context.socket.close();
       context.socket = null;
     }
@@ -4061,7 +4090,7 @@ ${Array.from(traces).join("\n\n")}`
     clearInterval(context.timers.heartbeat);
     clearTimeout(context.timers.pongTimeout);
     updateConnection({ status: "unavailable" }, batchUpdates);
-    connect();
+    handleConnect();
   }
   function tryFlushing() {
     const storageOps = context.buffer.storageOperations;
@@ -4091,7 +4120,8 @@ ${Array.from(traces).join("\n\n")}`
       };
     } else {
       clearTimeout(context.timers.flush);
-      context.timers.flush = effects.scheduleFlush(
+      context.timers.flush = setTimeout(
+        tryFlushing,
         config.throttleDelay - elapsedMillis
       );
     }
@@ -4264,14 +4294,11 @@ ${Array.from(traces).join("\n\n")}`
       _addToRealUndoStack(historyOps, batchUpdates);
     }
   }
-  function simulateCloseWebsocket() {
+  function handleImplicitClose() {
     if (context.socket) {
       context.socket = null;
     }
   }
-  function simulateSendCloseEvent(event) {
-    onClose(event);
-  }
   function getStorageStatus() {
     if (_getInitialStatePromise === null) {
       return "not-loaded";
@@ -4304,6 +4331,28 @@ ${Array.from(traces).join("\n\n")}`
     storageDidLoad: eventHub.storageDidLoad.observable,
     storageStatus: eventHub.storageStatus.observable
   };
+  function transition(event) {
+    switch (event.type) {
+      case "CONNECT":
+        return handleConnect();
+      case "DISCONNECT":
+        return handleDisconnect();
+      case "RECEIVE_PONG":
+        return handlePong();
+      case "AUTH_SUCCESS":
+        return handleAuthSuccess(event.token, event.socket);
+      case "WINDOW_GOT_FOCUS":
+        return handleWindowGotFocus();
+      case "NAVIGATOR_ONLINE":
+        return handleNavigatorBackOnline();
+      case "IMPLICIT_CLOSE":
+        return handleImplicitClose();
+      case "EXPLICIT_CLOSE":
+        return handleExplicitClose(event.closeEvent);
+      default:
+        return assertNever(event, "Invalid event");
+    }
+  }
   return {
     /* NOTE: Exposing __internal here only to allow testing implementation details in unit tests */
     __internal: {
@@ -4315,20 +4364,36 @@ ${Array.from(traces).join("\n\n")}`
         return context.numRetries;
       },
       // prettier-ignore
-      onClose,
-      onMessage,
-      authenticationSuccess,
-      onNavigatorOnline,
-      simulateCloseWebsocket,
-      simulateSendCloseEvent,
-      onVisibilityChange,
-      getUndoStack: () => context.undoStack,
-      getItemsCount: () => context.nodes.size,
-      connect,
-      disconnect,
+      get undoStack() {
+        return 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
+      getOthers_forDevTools: () => others_forDevTools.current,
+      // prettier-ignore
+      send: {
+        explicitClose: (closeEvent) => transition({ type: "EXPLICIT_CLOSE", closeEvent }),
+        implicitClose: () => transition({ type: "IMPLICIT_CLOSE" }),
+        authSuccess: (token, socket) => transition({ type: "AUTH_SUCCESS", token, socket }),
+        navigatorOnline: () => transition({ type: "NAVIGATOR_ONLINE" }),
+        windowGotFocus: () => transition({ type: "WINDOW_GOT_FOCUS" }),
+        pong: () => transition({ type: "RECEIVE_PONG" }),
+        connect: () => transition({ type: "CONNECT" }),
+        disconnect: () => transition({ type: "DISCONNECT" }),
+        /**
+         * This one looks differently from the rest, because receiving messages
+         * is handled orthorgonally from all other possible events above,
+         * because it does not matter what the connectivity state of the
+         * machine is, so there won't be an explicit state machine transition
+         * needed for this event.
+         */
+        incomingMessage: handleServerMessage
+      }
     },
     id: config.roomId,
     subscribe: makeClassicSubscribeFn(events),
@@ -4404,10 +4469,6 @@ function makeClassicSubscribeFn(events) {
           return events.connection.subscribe(
             callback
           );
-        case "storage":
-          return events.storage.subscribe(
-            callback
-          );
         case "history":
           return events.history.subscribe(callback);
         case "storage-status":
@@ -4456,34 +4517,49 @@ function prepareCreateWebSocket(liveblocksServer, WebSocketPolyfill) {
     );
   }
   const ws = WebSocketPolyfill || WebSocket;
-  return (token) => {
+  return (richToken) => {
+    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.0.8"
+        "1.0.10"
       ) : "dev"}`
     );
   };
 }
-function prepareAuthEndpoint(authentication, fetchPolyfill) {
+function httpSend(message, token, endpoint, fetchPolyfill) {
+  return __async(this, null, function* () {
+    const fetcher = fetchPolyfill || /* istanbul ignore next */
+    fetch;
+    return fetcher(endpoint, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${token}`
+      },
+      body: message
+    });
+  });
+}
+function prepareAuthEndpoint(roomId, authentication, fetchPolyfill) {
   if (authentication.type === "public") {
     if (typeof window === "undefined" && fetchPolyfill === void 0) {
       throw new Error(
         "To use Liveblocks client in a non-dom environment with a publicApiKey, you need to provide a fetch polyfill."
       );
     }
-    return (room) => fetchAuthEndpoint(
+    return () => fetchAuthEndpoint(
       fetchPolyfill || /* istanbul ignore next */
       fetch,
       authentication.url,
       {
-        room,
+        room: roomId,
         publicApiKey: authentication.publicApiKey
       }
-    );
+    ).then(({ token }) => parseRoomAuthToken(token));
   }
   if (authentication.type === "private") {
     if (typeof window === "undefined" && fetchPolyfill === void 0) {
@@ -4491,19 +4567,19 @@ function prepareAuthEndpoint(authentication, fetchPolyfill) {
         "To use Liveblocks client in a non-dom environment with a url as auth endpoint, you need to provide a fetch polyfill."
       );
     }
-    return (room) => fetchAuthEndpoint(fetchPolyfill || fetch, authentication.url, {
-      room
-    });
+    return () => fetchAuthEndpoint(fetchPolyfill || fetch, authentication.url, {
+      room: roomId
+    }).then(({ token }) => parseRoomAuthToken(token));
   }
   if (authentication.type === "custom") {
-    return (room) => __async(this, null, function* () {
-      const response = yield authentication.callback(room);
+    return () => __async(this, null, function* () {
+      const response = yield authentication.callback(roomId);
       if (!response || !response.token) {
         throw new Error(
           'Authentication error. We expect the authentication callback to return a token, but it does not. Hint: the return value should look like: { token: "..." }'
         );
       }
-      return response;
+      return parseRoomAuthToken(response.token);
     });
   }
   throw new Error("Internal error. Unexpected authentication type");
@@ -4588,7 +4664,12 @@ function createClient(options) {
         polyfills: clientOptions.polyfills,
         unstable_batchedUpdates: options2 == null ? void 0 : options2.unstable_batchedUpdates,
         liveblocksServer: getServerFromClientOptions(clientOptions),
-        authentication: prepareAuthentication(clientOptions, roomId)
+        authentication: prepareAuthentication(clientOptions, roomId),
+        httpSendEndpoint: buildLiveblocksHttpSendEndpoint(
+          clientOptions,
+          roomId
+        ),
+        unstable_fallbackToHTTP: !!clientOptions.unstable_fallbackToHTTP
       }
     );
     rooms.set(roomId, newRoom);
@@ -4604,7 +4685,7 @@ function createClient(options) {
         }
         global.atob = clientOptions.polyfills.atob;
       }
-      newRoom.__internal.connect();
+      newRoom.__internal.send.connect();
     }
     return newRoom;
   }
@@ -4612,7 +4693,7 @@ function createClient(options) {
     unlinkDevTools(roomId);
     const room = rooms.get(roomId);
     if (room !== void 0) {
-      room.__internal.disconnect();
+      room.__internal.send.disconnect();
       rooms.delete(roomId);
     }
   }
@@ -4620,14 +4701,16 @@ function createClient(options) {
   typeof window.addEventListener !== "undefined") {
     window.addEventListener("online", () => {
       for (const [, room] of rooms) {
-        room.__internal.onNavigatorOnline();
+        room.__internal.send.navigatorOnline();
       }
     });
   }
   if (typeof document !== "undefined") {
     document.addEventListener("visibilitychange", () => {
-      for (const [, room] of rooms) {
-        room.__internal.onVisibilityChange(document.visibilityState);
+      if (document.visibilityState === "visible") {
+        for (const [, room] of rooms) {
+          room.__internal.send.windowGotFocus();
+        }
       }
     });
   }
@@ -4690,6 +4773,14 @@ function prepareAuthentication(clientOptions, roomId) {
     "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);
+  }
+  return `https://api.liveblocks.io/v2/rooms/${encodeURIComponent(
+    roomId
+  )}/send-message`;
+}
 function buildLiveblocksPublicAuthorizeEndpoint(options, roomId) {
   if (options.publicAuthorizeEndpoint) {
     return options.publicAuthorizeEndpoint.replace("{roomId}", roomId);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@liveblocks/core",
-  "version": "1.0.8",
+  "version": "1.0.10",
   "description": "Shared code and foundational internals for Liveblocks",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",