@liveblocks/core 1.0.8 → 1.1.0-fsm1

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.1.0-fsm1"
 ) : "dev";
 var _devtoolsSetupHasRun = false;
 function setupDevTools(getAllRooms) {
@@ -345,6 +345,773 @@ function nn(value, errmsg = "Expected value to be non-nullable") {
   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("*");
+  }
+  for (let i = parts.length - levels + 1; i < parts.length; i++) {
+    const slice = parts.slice(0, i);
+    if (slice.length > 0) {
+      result.push(slice.join(".") + ".*");
+    }
+  }
+  result.push(targetState);
+  return result;
+}
+var nextId = 1;
+var FSM = class {
+  /**
+   * Returns the initial state, which is defined by the first call made to
+   * .addState().
+   */
+  get initialState() {
+    const result = this.states.values()[Symbol.iterator]().next();
+    if (result.done) {
+      throw new Error("No states defined yet");
+    } else {
+      return result.value;
+    }
+  }
+  get currentState() {
+    if (this.currentStateOrNull === null) {
+      throw new Error("Not started yet");
+    }
+    return this.currentStateOrNull;
+  }
+  /**
+   * Starts the machine by entering the initial state.
+   */
+  start() {
+    if (this.runningState !== 0 /* NOT_STARTED_YET */) {
+      throw new Error("State machine has already started");
+    }
+    this.runningState = 1 /* STARTED */;
+    this.currentStateOrNull = this.initialState;
+    this.enter(null);
+    return this;
+  }
+  /**
+   * Stops the state machine. Stopping the state machine will call exit
+   * handlers for the current state, but not enter a new state.
+   */
+  stop() {
+    if (this.runningState !== 1 /* STARTED */) {
+      throw new Error("Cannot stop a state machine that isn't started yet");
+    }
+    this.runningState = 2 /* STOPPED */;
+    this.exit(null);
+    this.currentStateOrNull = null;
+  }
+  constructor(initialContext) {
+    this.id = nextId++;
+    this.runningState = 0 /* NOT_STARTED_YET */;
+    this.currentStateOrNull = null;
+    this.states = /* @__PURE__ */ new Set();
+    this.enterFns = /* @__PURE__ */ new Map();
+    this.cleanupStack = [];
+    this.knownEventTypes = /* @__PURE__ */ new Set();
+    this.allowedTransitions = /* @__PURE__ */ new Map();
+    this.currentContext = Object.assign({}, initialContext);
+    this.eventHub = {
+      didReceiveEvent: makeEventSource(),
+      willTransition: makeEventSource(),
+      didPatchContext: makeEventSource(),
+      didIgnoreEvent: makeEventSource(),
+      willExitState: makeEventSource(),
+      didEnterState: makeEventSource()
+    };
+    this.events = {
+      didReceiveEvent: this.eventHub.didReceiveEvent.observable,
+      willTransition: this.eventHub.willTransition.observable,
+      didPatchContext: this.eventHub.didPatchContext.observable,
+      didIgnoreEvent: this.eventHub.didIgnoreEvent.observable,
+      willExitState: this.eventHub.willExitState.observable,
+      didEnterState: this.eventHub.didEnterState.observable
+    };
+  }
+  get context() {
+    return this.currentContext;
+  }
+  /**
+   * Define an explicit finite state in the state machine.
+   */
+  addState(state) {
+    if (this.runningState !== 0 /* NOT_STARTED_YET */) {
+      throw new Error("Already started");
+    }
+    this.states.add(state);
+    return this;
+  }
+  onEnter(nameOrPattern, enterFn) {
+    if (this.runningState !== 0 /* NOT_STARTED_YET */) {
+      throw new Error("Already started");
+    } else if (this.enterFns.has(nameOrPattern)) {
+      throw new Error(
+        // TODO We _currently_ don't support multiple .onEnters() for the same
+        // state, but this is not a fundamental limitation. Just not
+        // implemented yet. If we wanted to, we could make this an array.
+        `enter/exit function for ${nameOrPattern} already exists`
+      );
+    }
+    this.enterFns.set(nameOrPattern, enterFn);
+    return this;
+  }
+  onEnterAsync(nameOrPattern, promiseFn, onOK, onError) {
+    return this.onEnter(nameOrPattern, () => {
+      let cancelled = false;
+      void promiseFn(this.currentContext).then(
+        // On OK
+        (data) => {
+          if (!cancelled) {
+            this.transition({ type: "ASYNC_OK", data }, onOK);
+          }
+        },
+        // On Error
+        (reason) => {
+          if (!cancelled) {
+            this.transition({ type: "ASYNC_ERROR", reason }, onError);
+          }
+        }
+      );
+      return () => {
+        cancelled = true;
+      };
+    });
+  }
+  getStatesMatching(nameOrPattern) {
+    const matches = [];
+    if (nameOrPattern === "*") {
+      for (const state of this.states) {
+        matches.push(state);
+      }
+    } else if (nameOrPattern.endsWith(".*")) {
+      const prefix = nameOrPattern.slice(0, -1);
+      for (const state of this.states) {
+        if (state.startsWith(prefix)) {
+          matches.push(state);
+        }
+      }
+    } else {
+      const name = nameOrPattern;
+      if (this.states.has(name)) {
+        matches.push(name);
+      }
+    }
+    if (matches.length === 0) {
+      throw new Error(`No states match ${JSON.stringify(nameOrPattern)}`);
+    }
+    return matches;
+  }
+  /**
+   * Define all allowed outgoing transitions for a state.
+   *
+   * The targets for each event can be defined as a function which returns the
+   * next state to transition to. These functions can look at the `event` or
+   * `context` params to conditionally decide which next state to transition
+   * to.
+   *
+   * If you set it to `null`, then the transition will be explicitly forbidden
+   * and throw an error. If you don't define a target for a transition, then
+   * such events will get ignored.
+   */
+  addTransitions(nameOrPattern, mapping) {
+    if (this.runningState !== 0 /* NOT_STARTED_YET */) {
+      throw new Error("Already started");
+    }
+    for (const srcState of this.getStatesMatching(nameOrPattern)) {
+      let map = this.allowedTransitions.get(srcState);
+      if (map === void 0) {
+        map = /* @__PURE__ */ new Map();
+        this.allowedTransitions.set(srcState, map);
+      }
+      for (const [type, targetConfig_] of Object.entries(mapping)) {
+        const targetConfig = targetConfig_;
+        this.knownEventTypes.add(type);
+        if (targetConfig !== void 0 && targetConfig !== null) {
+          const targetFn = typeof targetConfig === "function" ? targetConfig : () => targetConfig;
+          map.set(type, targetFn);
+        }
+      }
+    }
+    return this;
+  }
+  /**
+   * Like `.addTransition()`, but takes an (anonymous) transition whenever the
+   * timer fires.
+   *
+   * @param stateOrPattern The state name, or state group pattern name.
+   * @param after          Number of milliseconds after which to take the
+   *                       transition. If in the mean time, another transition
+   *                       is taken, the timer will get cancelled.
+   * @param target     The target state to go to.
+   */
+  addTimedTransition(stateOrPattern, after2, target) {
+    return this.onEnter(stateOrPattern, () => {
+      const ms = typeof after2 === "function" ? after2(this.currentContext) : after2;
+      const timeoutID = setTimeout(() => {
+        this.transition({ type: "TIMER" }, target);
+      }, ms);
+      return () => {
+        clearTimeout(timeoutID);
+      };
+    });
+  }
+  getTargetFn(eventName) {
+    var _a;
+    return (_a = this.allowedTransitions.get(this.currentState)) == null ? void 0 : _a.get(eventName);
+  }
+  /**
+   * Exits the current state, and executes any necessary cleanup functions.
+   * Call this before changing the current state to the next state.
+   *
+   * @param levels Defines how many "levels" of nesting will be exited. For
+   * example, if you transition from `foo.bar.qux` to `foo.bar.baz`, then
+   * the level is 1. But if you transition from `foo.bar.qux` to `bla.bla`,
+   * then the level is 3.
+   */
+  exit(levels) {
+    var _a;
+    this.eventHub.willExitState.notify(this.currentState);
+    levels = levels != null ? levels : this.cleanupStack.length;
+    for (let i = 0; i < levels; i++) {
+      (_a = this.cleanupStack.pop()) == null ? void 0 : _a();
+    }
+  }
+  /**
+   * Enters the current state, and executes any necessary onEnter handlers.
+   * Call this directly _after_ setting the current state to the next state.
+   */
+  enter(levels) {
+    const enterPatterns = patterns(
+      this.currentState,
+      levels != null ? levels : this.currentState.split(".").length + 1
+    );
+    for (const pattern of enterPatterns) {
+      const enterFn = this.enterFns.get(pattern);
+      const cleanupFn = enterFn == null ? void 0 : enterFn(this.currentContext);
+      if (typeof cleanupFn === "function") {
+        this.cleanupStack.push(cleanupFn);
+      } else {
+        this.cleanupStack.push(null);
+      }
+    }
+    this.eventHub.didEnterState.notify(this.currentState);
+  }
+  /**
+   * Sends an event to the machine, which may cause an internal state
+   * transition to happen. When that happens, will trigger side effects.
+   */
+  send(event) {
+    const targetFn = this.getTargetFn(event.type);
+    if (targetFn !== void 0) {
+      return this.transition(event, targetFn);
+    }
+    if (!this.knownEventTypes.has(event.type)) {
+      throw new Error(`Invalid event ${JSON.stringify(event.type)}`);
+    } else {
+      this.eventHub.didIgnoreEvent.notify(event);
+    }
+  }
+  transition(event, target) {
+    this.eventHub.didReceiveEvent.notify(event);
+    const oldState = this.currentState;
+    const targetFn = typeof target === "function" ? target : () => target;
+    const nextTarget = targetFn(event, this.currentContext);
+    let nextState;
+    let assign = void 0;
+    let effect = void 0;
+    if (nextTarget === null) {
+      this.eventHub.didIgnoreEvent.notify(event);
+      return;
+    }
+    if (typeof nextTarget === "string") {
+      nextState = nextTarget;
+    } else {
+      nextState = nextTarget.target;
+      assign = nextTarget.assign;
+      effect = nextTarget.effect;
+    }
+    if (!this.states.has(nextState)) {
+      throw new Error(`Invalid next state name: ${JSON.stringify(nextState)}`);
+    }
+    this.eventHub.willTransition.notify({ from: oldState, to: nextState });
+    const [up, down] = distance(this.currentState, nextState);
+    if (up > 0) {
+      this.exit(up);
+    }
+    this.currentStateOrNull = nextState;
+    if (assign !== void 0) {
+      const patch = typeof assign === "function" ? assign(this.context, event) : assign;
+      this.currentContext = Object.assign({}, this.currentContext, patch);
+      this.eventHub.didPatchContext.notify(patch);
+    }
+    if (effect !== void 0) {
+      effect(this.context, event);
+    }
+    if (down > 0) {
+      this.enter(down);
+    }
+  }
+};
+
+// src/connection.ts
+function toPublicConnectionStatus(state) {
+  switch (state) {
+    case "@ok.connected":
+    case "@ok.awaiting-pong":
+      return "open";
+    case "@idle.initial":
+      return "closed";
+    case "@auth.busy":
+    case "@auth.backoff":
+      return "authenticating";
+    case "@connecting.busy":
+      return "connecting";
+    case "@connecting.backoff":
+      return "unavailable";
+    case "@idle.failed":
+      return "failed";
+    default:
+      return assertNever(state, "Unknown state");
+  }
+}
+var BACKOFF_DELAYS = [250, 500, 1e3, 2e3, 4e3, 8e3, 1e4];
+var LOW_DELAY = BACKOFF_DELAYS[0];
+var BACKOFF_DELAYS_SLOW = [2e3, 3e4, 6e4, 3e5];
+var HEARTBEAT_INTERVAL = 3e4;
+var PONG_TIMEOUT = 2e3;
+var AUTH_TIMEOUT = 1e4;
+var SOCKET_CONNECT_TIMEOUT = 1e4;
+var UnauthorizedError = class extends Error {
+};
+var LiveblocksError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+  }
+};
+function nextBackoffDelay(currentDelay, delays = BACKOFF_DELAYS) {
+  var _a;
+  return (_a = delays.find((delay) => delay > currentDelay)) != null ? _a : delays[delays.length - 1];
+}
+function increaseBackoffDelay(context) {
+  return { backoffDelay: nextBackoffDelay(context.backoffDelay) };
+}
+function increaseBackoffDelayAggressively(context) {
+  return {
+    backoffDelay: nextBackoffDelay(context.backoffDelay, BACKOFF_DELAYS_SLOW)
+  };
+}
+function timeoutAfter(millis) {
+  return new Promise((_, reject) => {
+    setTimeout(() => {
+      reject(new Error("Timed out"));
+    }, millis);
+  });
+}
+function sendHeartbeat(ctx) {
+  var _a;
+  if (!ctx.socket) {
+    error("This should never happen");
+  }
+  (_a = ctx.socket) == null ? void 0 : _a.send("ping");
+}
+function enableTracing(fsm) {
+  const start = (/* @__PURE__ */ new Date()).getTime();
+  function log(...args) {
+    warn(
+      `${(((/* @__PURE__ */ new Date()).getTime() - start) / 1e3).toFixed(2)} [FSM #${fsm.id}]`,
+      ...args
+    );
+  }
+  const unsubs = [
+    fsm.events.didReceiveEvent.subscribe((e) => {
+      log(`Event ${e.type}`);
+    }),
+    fsm.events.willTransition.subscribe(({ from, to }) => {
+      log("Transitioning", from, "\u2192", to);
+    }),
+    fsm.events.didPatchContext.subscribe((patch) => {
+      log(`Patched: ${JSON.stringify(patch)}`);
+    }),
+    fsm.events.didIgnoreEvent.subscribe((e) => {
+      log("Ignored event", e, "(current state won't handle it)");
+    })
+    // fsm.events.willExitState.subscribe((s) => {
+    //   log("Exiting state", s);
+    // }),
+    // fsm.events.didEnterState.subscribe((s) => {
+    //   log("Entering state", s);
+    // }),
+  ];
+  return () => {
+    for (const unsub of unsubs) {
+      unsub();
+    }
+  };
+}
+function defineConnectivityEvents(fsm) {
+  const statusDidChange = makeEventSource();
+  const didConnect = makeEventSource();
+  const didDisconnect = makeEventSource();
+  let oldPublicStatus = null;
+  fsm.events.didEnterState.subscribe((newState) => {
+    const newPublicStatus = toPublicConnectionStatus(newState);
+    statusDidChange.notify(newPublicStatus);
+    if (oldPublicStatus === "open" && newPublicStatus !== "open") {
+      didDisconnect.notify();
+    } else if (oldPublicStatus !== "open" && newPublicStatus === "open") {
+      didConnect.notify();
+    }
+    oldPublicStatus = newPublicStatus;
+  });
+  return {
+    statusDidChange: statusDidChange.observable,
+    didConnect: didConnect.observable,
+    didDisconnect: didDisconnect.observable
+  };
+}
+function createStateMachine(delegates) {
+  const onMessage = makeEventSource();
+  const onLiveblocksError = makeEventSource();
+  const initialContext = {
+    token: null,
+    socket: null,
+    // Bumped to the next "tier" every time a connection attempt fails (no matter
+    // whether this is for the authentication server or the websocket server).
+    // Reset every time a connection succeeded.
+    backoffDelay: LOW_DELAY
+    // numRetries: 0,
+  };
+  const fsm = new FSM(initialContext).addState("@idle.initial").addState("@idle.failed").addState("@auth.busy").addState("@auth.backoff").addState("@connecting.busy").addState("@connecting.backoff").addState("@ok.connected").addState("@ok.awaiting-pong");
+  fsm.addTransitions("*", {
+    RECONNECT: {
+      target: "@auth.backoff",
+      assign: increaseBackoffDelay
+    },
+    DISCONNECT: "@idle.initial"
+  });
+  fsm.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"
+    )
+  });
+  fsm.addTransitions("@auth.backoff", {
+    NAVIGATOR_ONLINE: {
+      target: "@auth.busy",
+      assign: { backoffDelay: LOW_DELAY }
+    }
+  }).addTimedTransition(
+    "@auth.backoff",
+    (ctx) => ctx.backoffDelay,
+    "@auth.busy"
+  ).onEnterAsync(
+    "@auth.busy",
+    () => Promise.race([delegates.authenticate(), timeoutAfter(AUTH_TIMEOUT)]),
+    // On successful authentication
+    (okEvent) => ({
+      target: "@connecting.busy",
+      assign: {
+        token: okEvent.data,
+        backoffDelay: LOW_DELAY
+      }
+    }),
+    // Auth failed
+    (failedEvent) => failedEvent.reason instanceof UnauthorizedError ? {
+      target: "@idle.failed",
+      effect: () => error(
+        `Unauthorized, will stop retrying: ${failedEvent.reason.message}`
+      )
+    } : {
+      target: "@auth.backoff",
+      assign: increaseBackoffDelay
+      // effect: () => {
+      //   console.log(`Authentication failed: ${String(failedEvent.reason)}`);
+      // },
+    }
+  );
+  const onSocketError = (event) => fsm.send({ type: "EXPLICIT_SOCKET_ERROR", event });
+  const onSocketClose = (event) => fsm.send({ type: "EXPLICIT_SOCKET_CLOSE", event });
+  const onSocketMessage = (event) => event.data === "pong" ? fsm.send({ type: "PONG" }) : onMessage.notify(event);
+  function teardownSocket(socket) {
+    if (socket) {
+      socket.removeEventListener("error", onSocketError);
+      socket.removeEventListener("close", onSocketClose);
+      socket.removeEventListener("message", onSocketMessage);
+      socket.close();
+    }
+  }
+  fsm.addTransitions("@connecting.backoff", {
+    NAVIGATOR_ONLINE: {
+      target: "@connecting.busy",
+      assign: { backoffDelay: LOW_DELAY }
+    }
+  }).addTimedTransition(
+    "@connecting.backoff",
+    (ctx) => ctx.backoffDelay,
+    "@connecting.busy"
+  ).onEnterAsync(
+    "@connecting.busy",
+    (ctx) => {
+      if (ctx.socket) {
+        throw new Error(
+          "Oops! Old socket should already be cleaned up by the time this state is entered! You may have found an edge case. Please tell Vincent about this."
+        );
+      }
+      const promise = new Promise((resolve, reject) => {
+        if (ctx.token === null) {
+          throw new Error("No auth token");
+        }
+        const socket = delegates.createSocket(ctx.token);
+        socket.addEventListener("error", reject);
+        socket.addEventListener("close", reject);
+        socket.addEventListener("open", () => {
+          socket.removeEventListener("error", reject);
+          socket.removeEventListener("close", reject);
+          socket.addEventListener("error", onSocketError);
+          socket.addEventListener("close", onSocketClose);
+          socket.addEventListener("message", onSocketMessage);
+          resolve(socket);
+        });
+      });
+      return Promise.race([promise, timeoutAfter(SOCKET_CONNECT_TIMEOUT)]);
+    },
+    // On successful authentication
+    (okEvent) => ({
+      target: "@ok.connected",
+      assign: {
+        socket: okEvent.data,
+        backoffDelay: LOW_DELAY
+      }
+    }),
+    // On failure
+    (failedEvent) => (
+      // XXX TODO If _UNAUTHORIZED_, we should discard the token and jump back
+      // to @auth.busy to reattempt authentication
+      {
+        target: "@auth.backoff",
+        assign: (ctx) => {
+          if (ctx.socket) {
+            throw new Error(
+              "Oops! This is unexpected! You may have found an edge case. Please tell Vincent about this."
+            );
+          }
+          return {
+            // XXX If failed because of a "room full" or "rate limit", back off more aggressively here
+            backoffDelay: nextBackoffDelay(ctx.backoffDelay)
+          };
+        },
+        effect: () => {
+          error(
+            `Connection to WebSocket could not be established, reason: ${String(
+              failedEvent.reason
+            )}`
+          );
+        }
+      }
+    )
+  );
+  fsm.addTimedTransition("@ok.connected", HEARTBEAT_INTERVAL, {
+    target: "@ok.awaiting-pong",
+    effect: sendHeartbeat
+  }).addTransitions("@ok.connected", {
+    WINDOW_GOT_FOCUS: { target: "@ok.awaiting-pong", effect: sendHeartbeat }
+  });
+  const noPongAction = {
+    target: "@connecting.busy",
+    effect: () => {
+      warn(
+        "Received no pong from server, assume implicit connection loss."
+      );
+    }
+  };
+  fsm.onEnter("@ok.*", (ctx) => {
+    return () => {
+      teardownSocket(ctx.socket);
+      ctx.socket = null;
+    };
+  }).addTimedTransition("@ok.awaiting-pong", PONG_TIMEOUT, noPongAction).addTransitions("@ok.awaiting-pong", { PONG_TIMEOUT: noPongAction }).addTransitions("@ok.awaiting-pong", { PONG: "@ok.connected" }).addTransitions("@ok.*", {
+    // When a socket receives an error, this can cause the closing of the
+    // socket, or not. So always check to see if the socket is still OPEN or
+    // not. When still OPEN, don't transition.
+    EXPLICIT_SOCKET_ERROR: (_, context) => {
+      var _a;
+      if (((_a = context.socket) == null ? void 0 : _a.readyState) === WebSocket.OPEN) {
+        return null;
+      }
+      return {
+        target: "@connecting.busy",
+        assign: increaseBackoffDelay
+      };
+    },
+    EXPLICIT_SOCKET_CLOSE: (e) => {
+      if (e.event.code === 4999) {
+        return {
+          target: "@idle.failed",
+          effect: () => warn(
+            "Connection to WebSocket closed permanently. Won't retry."
+          )
+        };
+      }
+      if (e.event.code >= 4e3 && e.event.code <= 4100) {
+        return {
+          target: "@connecting.busy",
+          assign: increaseBackoffDelayAggressively,
+          effect: (_, { event }) => {
+            if (event.code >= 4e3 && event.code <= 4100) {
+              const err = new LiveblocksError(event.reason, event.code);
+              onLiveblocksError.notify(err);
+            }
+          }
+        };
+      }
+      return {
+        target: "@connecting.busy",
+        assign: increaseBackoffDelay
+      };
+    }
+  });
+  if (typeof document !== "undefined") {
+    const doc = typeof document !== "undefined" ? document : void 0;
+    const win = typeof window !== "undefined" ? window : void 0;
+    const root = win != null ? win : doc;
+    fsm.onEnter("*", (ctx) => {
+      function onBackOnline() {
+        fsm.send({ type: "NAVIGATOR_ONLINE" });
+      }
+      function onVisibilityChange() {
+        if ((doc == null ? void 0 : doc.visibilityState) === "visible") {
+          fsm.send({ type: "WINDOW_GOT_FOCUS" });
+        }
+      }
+      win == null ? void 0 : win.addEventListener("online", onBackOnline);
+      root == null ? void 0 : root.addEventListener("visibilitychange", onVisibilityChange);
+      return () => {
+        root == null ? void 0 : root.removeEventListener("visibilitychange", onVisibilityChange);
+        win == null ? void 0 : win.removeEventListener("online", onBackOnline);
+        teardownSocket(ctx.socket);
+      };
+    });
+  }
+  const { statusDidChange, didConnect, didDisconnect } = defineConnectivityEvents(fsm);
+  const cleanup = enableTracing(fsm);
+  fsm.start();
+  return {
+    fsm,
+    cleanup,
+    // Observable events that will be emitted by this machine
+    events: {
+      statusDidChange,
+      didConnect,
+      didDisconnect,
+      onMessage: onMessage.observable,
+      onLiveblocksError: onLiveblocksError.observable
+    }
+  };
+}
+var ManagedSocket = class {
+  constructor(delegates) {
+    const { fsm, events, cleanup } = createStateMachine(delegates);
+    this.fsm = fsm;
+    this.events = events;
+    this.cleanup = cleanup;
+  }
+  get status() {
+    try {
+      return toPublicConnectionStatus(this.fsm.currentState);
+    } catch (e) {
+      return "closed";
+    }
+  }
+  /**
+   * Returns the current auth token.
+   */
+  get token() {
+    const tok = this.fsm.context.token;
+    if (tok === null) {
+      throw new Error("Unexpected null token here");
+    }
+    return tok;
+  }
+  /**
+   * Call this method to try to connect to a WebSocket. This only has an effect
+   * if the machine is idle at the moment, otherwise this is a no-op.
+   */
+  connect() {
+    this.fsm.send({ type: "CONNECT" });
+  }
+  /**
+   * If idle, will try to connect. Otherwise, it will attempt to reconnect to
+   * the socket, potentially obtaining a new token first, if needed.
+   */
+  reconnect() {
+    this.fsm.send({ type: "RECONNECT" });
+  }
+  /**
+   * Call this method to disconnect from the current WebSocket. Is going to be
+   * a no-op if there is no active connection.
+   */
+  disconnect() {
+    this.fsm.send({ type: "DISCONNECT" });
+  }
+  /**
+   * Call this to stop the machine and run necessary cleanup functions. After
+   * calling destroy(), you can no longer use this instance. Call this before
+   * letting the instance get garbage collected.
+   */
+  destroy() {
+    this.fsm.stop();
+    this.cleanup();
+  }
+  /**
+   * Safely send a message to the current WebSocket connection. Will emit a log
+   * message if this is somehow impossible.
+   */
+  send(data) {
+    var _a;
+    const socket = (_a = this.fsm.context) == null ? void 0 : _a.socket;
+    if (socket === null) {
+      warn("Cannot send: not connected yet", data);
+    } else if (socket.readyState !== WebSocket.OPEN) {
+      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 :(
+   */
+  _privateSend(event) {
+    return this.fsm.send(event);
+  }
+};
+
 // src/lib/position.ts
 var MIN_CODE = 32;
 var MAX_CODE = 126;
@@ -2953,10 +3720,6 @@ function hasJwtMeta(data) {
   const { iat, exp } = data;
   return typeof iat === "number" && typeof exp === "number";
 }
-function isTokenExpired(token) {
-  const now = Date.now() / 1e3;
-  return now > token.exp - 300 || now < token.iat + 300;
-}
 function isStringList(value) {
   return Array.isArray(value) && value.every((i) => typeof i === "string");
 }
@@ -2983,20 +3746,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
@@ -3237,31 +4002,11 @@ var DerivedRef = class extends ImmutableRef {
   }
 };
 
-// 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/room.ts
-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;
 function makeIdFactory(connectionId) {
   let count = 0;
   return () => `${connectionId}:${count++}`;
 }
-function log(..._params) {
-  return;
-}
 function isConnectionSelfAware(connection) {
   return connection.status === "open" || connection.status === "connecting";
 }
@@ -3274,19 +4019,25 @@ function userToTreeNode(key, user) {
   };
 }
 function createRoom(options, config) {
-  var _a;
+  var _a, _b, _c;
   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 = {
+    authenticate: makeAuthDelegateForRoom(
+      config.roomId,
+      config.authentication,
+      (_a = config.polyfills) == null ? void 0 : _a.fetch
+    ),
+    createSocket: makeCreateSocketDelegateForRoom(
+      config.liveblocksServer,
+      (_b = config.polyfills) == null ? void 0 : _b.WebSocket
+    )
+  };
+  const managedSocket = new ManagedSocket(delegates);
   const context = {
-    token: null,
     lastConnectionId: null,
-    socket: null,
-    numRetries: 0,
     timers: {
-      flush: void 0,
-      reconnect: void 0,
-      heartbeat: void 0,
-      pongTimeout: void 0
+      flush: void 0
     },
     buffer: {
       lastFlushedAt: 0,
@@ -3319,7 +4070,68 @@ function createRoom(options, config) {
     opStackTraces: process.env.NODE_ENV !== "production" ? /* @__PURE__ */ new Map() : void 0
   };
   const doNotBatchUpdates = (cb) => cb();
-  const batchUpdates = (_a = config.unstable_batchedUpdates) != null ? _a : doNotBatchUpdates;
+  const batchUpdates = (_c = config.unstable_batchedUpdates) != null ? _c : doNotBatchUpdates;
+  function onStatusDidChange(newStatus) {
+    if (newStatus !== "open" && newStatus !== "connecting") {
+      context.connection.set({ status: newStatus });
+    } else {
+      context.connection.set({
+        status: newStatus,
+        id: managedSocket.token.parsed.actor,
+        userInfo: managedSocket.token.parsed.info,
+        userId: managedSocket.token.parsed.id,
+        isReadOnly: isStorageReadOnly(managedSocket.token.parsed.scopes)
+      });
+    }
+    batchUpdates(() => {
+      eventHub.connection.notify(newStatus);
+    });
+  }
+  function onDidConnect() {
+    const conn = context.connection.current;
+    if (conn.status !== "open") {
+      throw new Error("Unexpected non-open state here");
+    }
+    if (context.lastConnectionId !== void 0) {
+      context.buffer.me = {
+        type: "full",
+        data: (
+          // Because state.me.current is a readonly object, we'll have to
+          // make a copy here. Otherwise, type errors happen later when
+          // "patching" my presence.
+          __spreadValues({}, context.me.current)
+        )
+      };
+      tryFlushing();
+    }
+    context.lastConnectionId = conn.id;
+    context.idFactory = makeIdFactory(conn.id);
+    if (context.root) {
+      context.buffer.messages.push({ type: 200 /* FETCH_STORAGE */ });
+    }
+    tryFlushing();
+  }
+  function onDidDisconnect() {
+    clearTimeout(context.timers.flush);
+    batchUpdates(() => {
+      context.others.clearOthers();
+      notify({ others: [{ type: "reset" }] }, doNotBatchUpdates);
+    });
+  }
+  managedSocket.events.onMessage.subscribe(handleServerMessage);
+  managedSocket.events.statusDidChange.subscribe(onStatusDidChange);
+  managedSocket.events.didConnect.subscribe(onDidConnect);
+  managedSocket.events.didDisconnect.subscribe(onDidDisconnect);
+  managedSocket.events.onLiveblocksError.subscribe((err) => {
+    batchUpdates(() => {
+      if (process.env.NODE_ENV !== "production") {
+        error(
+          `Connection to websocket server closed. Reason: ${err.message} (code: ${err.code}).`
+        );
+      }
+      eventHub.error.notify(err);
+    });
+  });
   const pool = {
     roomId: config.roomId,
     getNode: (id) => context.nodes.get(id),
@@ -3380,41 +4192,9 @@ function createRoom(options, config) {
     storageStatus: makeEventSource()
   };
   const effects = config.mockedEffects || {
-    authenticate(auth, createWebSocket) {
-      const prevToken = context.token;
-      if (prevToken !== null && !isTokenExpired(prevToken.parsed)) {
-        const socket = createWebSocket(prevToken.raw);
-        authenticationSuccess(prevToken.parsed, socket);
-        return void 0;
-      } else {
-        void auth(config.roomId).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 };
-        }).catch(
-          (er) => authenticationFailure(
-            er instanceof Error ? er : new Error(String(er))
-          )
-        );
-        return void 0;
-      }
-    },
     send(messageOrMessages) {
-      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));
-      }
-    },
-    scheduleFlush: (delay) => setTimeout(tryFlushing, delay),
-    scheduleReconnect: (delay) => setTimeout(connect, delay),
-    startHeartbeatInterval: () => setInterval(heartbeat, HEARTBEAT_INTERVAL),
-    schedulePongTimeout: () => setTimeout(pongTimeout, PONG_TIMEOUT)
+      managedSocket.send(JSON.stringify(messageOrMessages));
+    }
   };
   const self = new DerivedRef(
     context.connection,
@@ -3621,22 +4401,6 @@ function createRoom(options, config) {
       }
     }
   }
-  function connect() {
-    var _a2, _b;
-    if (context.connection.current.status !== "closed" && context.connection.current.status !== "unavailable") {
-      return;
-    }
-    const auth = prepareAuthEndpoint(
-      config.authentication,
-      (_a2 = config.polyfills) == null ? void 0 : _a2.fetch
-    );
-    const createWebSocket = prepareCreateWebSocket(
-      config.liveblocksServer,
-      (_b = config.polyfills) == null ? void 0 : _b.WebSocket
-    );
-    updateConnection({ status: "authenticating" }, batchUpdates);
-    effects.authenticate(auth, createWebSocket);
-  }
   function updatePresence(patch, options2) {
     const oldValues = {};
     if (context.buffer.me === null) {
@@ -3678,40 +4442,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 authenticationSuccess(token, socket) {
-    socket.addEventListener("message", onMessage);
-    socket.addEventListener("open", onOpen);
-    socket.addEventListener("close", onClose);
-    socket.addEventListener("error", onError);
-    updateConnection(
-      {
-        status: "connecting",
-        id: token.actor,
-        userInfo: token.info,
-        userId: token.id,
-        isReadOnly: isStorageReadOnly(token.scopes)
-      },
-      batchUpdates
-    );
-    context.idFactory = makeIdFactory(token.actor);
-    context.socket = socket;
-  }
-  function authenticationFailure(error2) {
-    if (process.env.NODE_ENV !== "production") {
-      error("Call to authentication endpoint failed", error2);
-    }
-    context.token = null;
-    updateConnection({ status: "unavailable" }, batchUpdates);
-    context.numRetries++;
-    clearTimeout(context.timers.reconnect);
-    context.timers.reconnect = effects.scheduleReconnect(getRetryDelay());
-  }
-  function onVisibilityChange(visibilityState) {
-    if (visibilityState === "visible" && context.connection.current.status === "open") {
-      log("Heartbeat after visibility change");
-      heartbeat();
-    }
-  }
   function onUpdatePresenceMessage(message) {
     if (message.targetActor !== void 0) {
       const oldUser = context.others.getUser(message.actor);
@@ -3761,12 +4491,6 @@ function createRoom(options, config) {
     }
     return { type: "reset" };
   }
-  function onNavigatorOnline() {
-    if (context.connection.current.status === "unavailable") {
-      log("Try to reconnect after connectivity change");
-      reconnect();
-    }
-  }
   function canUndo() {
     return context.undoStack.length > 0;
   }
@@ -3824,11 +4548,7 @@ function createRoom(options, config) {
     notify(result.updates, batchedUpdatesWrapper);
     effects.send(messages);
   }
-  function onMessage(event) {
-    if (event.data === "pong") {
-      clearTimeout(context.timers.pongTimeout);
-      return;
-    }
+  function handleServerMessage(event) {
     if (typeof event.data !== "string") {
       return;
     }
@@ -3929,140 +4649,6 @@ ${Array.from(traces).join("\n\n")}`
       notify(updates, doNotBatchUpdates);
     });
   }
-  function onClose(event) {
-    context.socket = null;
-    clearTimeout(context.timers.flush);
-    clearTimeout(context.timers.reconnect);
-    clearInterval(context.timers.heartbeat);
-    clearTimeout(context.timers.pongTimeout);
-    context.others.clearOthers();
-    batchUpdates(() => {
-      notify({ others: [{ type: "reset" }] }, doNotBatchUpdates);
-      if (event.code >= 4e3 && event.code <= 4100) {
-        updateConnection({ status: "failed" }, doNotBatchUpdates);
-        const error2 = new LiveblocksError(event.reason, event.code);
-        eventHub.error.notify(error2);
-        const delay = getRetryDelay(true);
-        context.numRetries++;
-        if (process.env.NODE_ENV !== "production") {
-          error(
-            `Connection to websocket server closed. Reason: ${error2.message} (code: ${error2.code}). Retrying in ${delay}ms.`
-          );
-        }
-        updateConnection({ status: "unavailable" }, doNotBatchUpdates);
-        clearTimeout(context.timers.reconnect);
-        context.timers.reconnect = effects.scheduleReconnect(delay);
-      } else if (event.code === 4999 /* CLOSE_WITHOUT_RETRY */) {
-        updateConnection({ status: "closed" }, doNotBatchUpdates);
-      } else {
-        const delay = getRetryDelay();
-        context.numRetries++;
-        if (process.env.NODE_ENV !== "production") {
-          warn(
-            `Connection to Liveblocks websocket server closed (code: ${event.code}). Retrying in ${delay}ms.`
-          );
-        }
-        updateConnection({ status: "unavailable" }, doNotBatchUpdates);
-        clearTimeout(context.timers.reconnect);
-        context.timers.reconnect = effects.scheduleReconnect(delay);
-      }
-    });
-  }
-  function updateConnection(connection, batchedUpdatesWrapper) {
-    context.connection.set(connection);
-    batchedUpdatesWrapper(() => {
-      eventHub.connection.notify(connection.status);
-    });
-  }
-  function getRetryDelay(slow = false) {
-    if (slow) {
-      return BACKOFF_RETRY_DELAYS_SLOW[context.numRetries < BACKOFF_RETRY_DELAYS_SLOW.length ? context.numRetries : BACKOFF_RETRY_DELAYS_SLOW.length - 1];
-    }
-    return BACKOFF_RETRY_DELAYS[context.numRetries < BACKOFF_RETRY_DELAYS.length ? context.numRetries : BACKOFF_RETRY_DELAYS.length - 1];
-  }
-  function onError() {
-  }
-  function onOpen() {
-    clearInterval(context.timers.heartbeat);
-    context.timers.heartbeat = effects.startHeartbeatInterval();
-    if (context.connection.current.status === "connecting") {
-      updateConnection(
-        __spreadProps(__spreadValues({}, context.connection.current), { status: "open" }),
-        batchUpdates
-      );
-      context.numRetries = 0;
-      if (context.lastConnectionId !== void 0) {
-        context.buffer.me = {
-          type: "full",
-          data: (
-            // Because state.me.current is a readonly object, we'll have to
-            // make a copy here. Otherwise, type errors happen later when
-            // "patching" my presence.
-            __spreadValues({}, context.me.current)
-          )
-        };
-        tryFlushing();
-      }
-      context.lastConnectionId = context.connection.current.id;
-      if (context.root) {
-        context.buffer.messages.push({ type: 200 /* FETCH_STORAGE */ });
-      }
-      tryFlushing();
-    } else {
-    }
-  }
-  function heartbeat() {
-    if (context.socket === null) {
-      return;
-    }
-    clearTimeout(context.timers.pongTimeout);
-    context.timers.pongTimeout = effects.schedulePongTimeout();
-    if (context.socket.readyState === context.socket.OPEN) {
-      context.socket.send("ping");
-    }
-  }
-  function pongTimeout() {
-    log("Pong timeout. Trying to reconnect.");
-    reconnect();
-  }
-  function disconnect() {
-    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.close();
-      context.socket = null;
-    }
-    clearTimeout(context.timers.flush);
-    clearTimeout(context.timers.reconnect);
-    clearInterval(context.timers.heartbeat);
-    clearTimeout(context.timers.pongTimeout);
-    batchUpdates(() => {
-      updateConnection({ status: "closed" }, doNotBatchUpdates);
-      context.others.clearOthers();
-      notify({ others: [{ type: "reset" }] }, doNotBatchUpdates);
-    });
-    for (const eventSource2 of Object.values(eventHub)) {
-      eventSource2.clear();
-    }
-  }
-  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.close();
-      context.socket = null;
-    }
-    clearTimeout(context.timers.flush);
-    clearTimeout(context.timers.reconnect);
-    clearInterval(context.timers.heartbeat);
-    clearTimeout(context.timers.pongTimeout);
-    updateConnection({ status: "unavailable" }, batchUpdates);
-    connect();
-  }
   function tryFlushing() {
     const storageOps = context.buffer.storageOperations;
     if (storageOps.length > 0) {
@@ -4071,7 +4657,7 @@ ${Array.from(traces).join("\n\n")}`
       }
       notifyStorageStatus();
     }
-    if (context.socket === null || context.socket.readyState !== context.socket.OPEN) {
+    if (managedSocket.status !== "open") {
       context.buffer.storageOperations = [];
       return;
     }
@@ -4091,7 +4677,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
       );
     }
@@ -4127,7 +4714,7 @@ ${Array.from(traces).join("\n\n")}`
   function broadcastEvent(event, options2 = {
     shouldQueueEventIfNotReady: false
   }) {
-    if (context.socket === null && !options2.shouldQueueEventIfNotReady) {
+    if (managedSocket.status !== "open" && !options2.shouldQueueEventIfNotReady) {
       return;
     }
     context.buffer.messages.push({
@@ -4264,14 +4851,6 @@ ${Array.from(traces).join("\n\n")}`
       _addToRealUndoStack(historyOps, batchUpdates);
     }
   }
-  function simulateCloseWebsocket() {
-    if (context.socket) {
-      context.socket = null;
-    }
-  }
-  function simulateSendCloseEvent(event) {
-    onClose(event);
-  }
   function getStorageStatus() {
     if (_getInitialStatePromise === null) {
       return "not-loaded";
@@ -4311,28 +4890,39 @@ ${Array.from(traces).join("\n\n")}`
         return context.buffer;
       },
       // prettier-ignore
-      get numRetries() {
-        return context.numRetries;
+      get undoStack() {
+        return context.undoStack;
+      },
+      // prettier-ignore
+      get nodeCount() {
+        return context.nodes.size;
       },
       // prettier-ignore
-      onClose,
-      onMessage,
-      authenticationSuccess,
-      onNavigatorOnline,
-      simulateCloseWebsocket,
-      simulateSendCloseEvent,
-      onVisibilityChange,
-      getUndoStack: () => context.undoStack,
-      getItemsCount: () => context.nodes.size,
-      connect,
-      disconnect,
       // Support for the Liveblocks browser extension
       getSelf_forDevTools: () => selfAsTreeNode.current,
-      getOthers_forDevTools: () => others_forDevTools.current
+      getOthers_forDevTools: () => others_forDevTools.current,
+      // prettier-ignore
+      send: {
+        // These exist only for our E2E testing app
+        explicitClose: (event) => managedSocket._privateSend({ type: "EXPLICIT_SOCKET_CLOSE", event }),
+        implicitClose: () => managedSocket._privateSend({ type: "PONG_TIMEOUT" }),
+        connect: () => managedSocket.connect(),
+        disconnect: () => managedSocket.disconnect(),
+        // XXX Do we really need disconnect() now that we have destroy()? Seems still useful to reset the machine, but also... YAGNI?
+        destroy: () => managedSocket.destroy(),
+        /**
+         * 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),
-    reconnect,
+    reconnect: () => managedSocket.reconnect(),
     // Presence
     updatePresence,
     broadcastEvent,
@@ -4404,10 +4994,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":
@@ -4443,67 +5029,66 @@ function makeClassicSubscribeFn(events) {
 function isRoomEventName(value) {
   return value === "my-presence" || value === "others" || value === "event" || value === "error" || value === "connection" || value === "history" || value === "storage-status";
 }
-var LiveblocksError = class extends Error {
-  constructor(message, code) {
-    super(message);
-    this.code = code;
-  }
-};
-function prepareCreateWebSocket(liveblocksServer, WebSocketPolyfill) {
-  if (typeof window === "undefined" && WebSocketPolyfill === void 0) {
-    throw new Error(
-      "To use Liveblocks client in a non-dom environment, you need to provide a WebSocket polyfill."
-    );
-  }
-  const ws = WebSocketPolyfill || WebSocket;
-  return (token) => {
+function makeCreateSocketDelegateForRoom(liveblocksServer, WebSocketPolyfill) {
+  return (richToken) => {
+    const ws = WebSocketPolyfill || WebSocket;
+    if (typeof WebSocket === "undefined" && WebSocketPolyfill === void 0) {
+      throw new Error(
+        "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.0.8"
+        "1.1.0-fsm1"
       ) : "dev"}`
     );
   };
 }
-function prepareAuthEndpoint(authentication, fetchPolyfill) {
+function makeAuthDelegateForRoom(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(
-      fetchPolyfill || /* istanbul ignore next */
-      fetch,
-      authentication.url,
-      {
-        room,
-        publicApiKey: authentication.publicApiKey
+    return () => __async(this, null, function* () {
+      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 fetchAuthEndpoint(
+        fetchPolyfill || /* istanbul ignore next */
+        fetch,
+        authentication.url,
+        {
+          room: roomId,
+          publicApiKey: authentication.publicApiKey
+        }
+      ).then(({ token }) => parseRoomAuthToken(token));
+    });
   }
   if (authentication.type === "private") {
-    if (typeof window === "undefined" && fetchPolyfill === void 0) {
-      throw new Error(
-        "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 () => __async(this, null, function* () {
+      if (typeof window === "undefined" && fetchPolyfill === void 0) {
+        throw new Error(
+          "To use Liveblocks client in a non-dom environment with a url as auth endpoint, you need to provide a fetch polyfill."
+        );
+      }
+      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");
@@ -4520,9 +5105,13 @@ function fetchAuthEndpoint(fetch2, endpoint, body) {
       body: JSON.stringify(body)
     });
     if (!res.ok) {
-      throw new AuthenticationError(
-        `Expected a status 200 but got ${res.status} when doing a POST request on "${endpoint}"`
-      );
+      if (res.status === 401 || res.status === 403) {
+        throw new UnauthorizedError(yield res.text());
+      } else {
+        throw new AuthenticationError(
+          `Expected a status 200 but got ${res.status} when doing a POST request on "${endpoint}"`
+        );
+      }
     }
     let data;
     try {
@@ -4604,7 +5193,7 @@ function createClient(options) {
         }
         global.atob = clientOptions.polyfills.atob;
       }
-      newRoom.__internal.connect();
+      newRoom.__internal.send.connect();
     }
     return newRoom;
   }
@@ -4612,25 +5201,10 @@ function createClient(options) {
     unlinkDevTools(roomId);
     const room = rooms.get(roomId);
     if (room !== void 0) {
-      room.__internal.disconnect();
+      room.__internal.send.destroy();
       rooms.delete(roomId);
     }
   }
-  if (typeof window !== "undefined" && // istanbul ignore next: React Native environment doesn't implement window.addEventListener
-  typeof window.addEventListener !== "undefined") {
-    window.addEventListener("online", () => {
-      for (const [, room] of rooms) {
-        room.__internal.onNavigatorOnline();
-      }
-    });
-  }
-  if (typeof document !== "undefined") {
-    document.addEventListener("visibilitychange", () => {
-      for (const [, room] of rooms) {
-        room.__internal.onVisibilityChange(document.visibilityState);
-      }
-    });
-  }
   return {
     getRoom,
     enter,
@@ -5041,6 +5615,19 @@ 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 || {});
+