@liveblocks/core 1.0.12 → 1.1.0-beta2

package/dist/index.js

@@ -54,6 +54,19 @@ var __async = (__this, __arguments, generator) => {
 function makeEventSource() {
   const _onetimeObservers = /* @__PURE__ */ new Set();
   const _observers = /* @__PURE__ */ new Set();
+  let _buffer = null;
+  function pause() {
+    _buffer = [];
+  }
+  function unpause() {
+    if (_buffer === null) {
+      return;
+    }
+    for (const event of _buffer) {
+      notify(event);
+    }
+    _buffer = null;
+  }
   function subscribe(callback) {
     _observers.add(callback);
     return () => _observers.delete(callback);
@@ -62,6 +75,25 @@ function makeEventSource() {
     _onetimeObservers.add(callback);
     return () => _onetimeObservers.delete(callback);
   }
+  function waitUntil(predicate) {
+    return __async(this, null, function* () {
+      let unsub;
+      return new Promise((res) => {
+        unsub = subscribe((event) => {
+          if (predicate === void 0 || predicate(event)) {
+            res(event);
+          }
+        });
+      }).finally(() => unsub == null ? void 0 : unsub());
+    });
+  }
+  function notifyOrBuffer(event) {
+    if (_buffer !== null) {
+      _buffer.push(event);
+    } else {
+      notify(event);
+    }
+  }
   function notify(event) {
     _onetimeObservers.forEach((callback) => callback(event));
     _onetimeObservers.clear();
@@ -71,16 +103,24 @@ function makeEventSource() {
     _onetimeObservers.clear();
     _observers.clear();
   }
+  function count() {
+    return _onetimeObservers.size + _observers.size;
+  }
   return {
     // Private/internal control over event emission
-    notify,
+    notify: notifyOrBuffer,
     subscribe,
     subscribeOnce,
     clear,
+    count,
+    waitUntil,
+    pause,
+    unpause,
     // Publicly exposable subscription API
     observable: {
       subscribe,
-      subscribeOnce
+      subscribeOnce,
+      waitUntil
     }
   };
 }
@@ -117,7 +157,7 @@ var onMessageFromPanel = eventSource.observable;
 // src/devtools/index.ts
 var VERSION = true ? (
   /* istanbul ignore next */
-  "1.0.12"
+  "1.1.0-beta2"
 ) : "dev";
 var _devtoolsSetupHasRun = false;
 function setupDevTools(getAllRooms) {
@@ -159,7 +199,7 @@ function startSyncStream(room) {
   fullSync(room);
   unsubsByRoomId.set(room.id, [
     // When the connection status changes
-    room.events.connection.subscribe(() => partialSyncConnection(room)),
+    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
@@ -173,7 +213,7 @@ function partialSyncConnection(room) {
   sendToPanel({
     msg: "room::sync::partial",
     roomId: room.id,
-    status: room.getConnectionState()
+    status: room.getStatus()
   });
 }
 function partialSyncStorage(room) {
@@ -214,7 +254,7 @@ function fullSync(room) {
   sendToPanel({
     msg: "room::sync::full",
     roomId: room.id,
-    status: room.getConnectionState(),
+    status: room.getStatus(),
     storage: (_a = root == null ? void 0 : root.toTreeNode("root").payload) != null ? _a : null,
     me,
     others
@@ -345,6 +385,989 @@ 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 SafeContext = class {
+  constructor(initialContext) {
+    this.curr = initialContext;
+  }
+  get current() {
+    return this.curr;
+  }
+  /**
+   * Call a callback function that allows patching of the context, by
+   * calling `context.patch()`. Patching is only allowed for the duration
+   * of this window.
+   */
+  allowPatching(callback) {
+    const self = this;
+    let allowed = true;
+    const patchableContext = __spreadProps(__spreadValues({}, this.curr), {
+      patch(patch) {
+        if (allowed) {
+          self.curr = Object.assign({}, self.curr, patch);
+          for (const pair of Object.entries(patch)) {
+            const [key, value] = pair;
+            if (key !== "patch") {
+              this[key] = value;
+            }
+          }
+        } else {
+          throw new Error("Can no longer patch stale context");
+        }
+      }
+    });
+    callback(patchableContext);
+    allowed = false;
+    return;
+  }
+};
+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 = new SafeContext(initialContext);
+    this.eventHub = {
+      didReceiveEvent: makeEventSource(),
+      willTransition: makeEventSource(),
+      didIgnoreEvent: makeEventSource(),
+      willExitState: makeEventSource(),
+      didEnterState: makeEventSource()
+    };
+    this.events = {
+      didReceiveEvent: this.eventHub.didReceiveEvent.observable,
+      willTransition: this.eventHub.willTransition.observable,
+      didIgnoreEvent: this.eventHub.didIgnoreEvent.observable,
+      willExitState: this.eventHub.willExitState.observable,
+      didEnterState: this.eventHub.didEnterState.observable
+    };
+  }
+  get context() {
+    return this.currentContext.current;
+  }
+  /**
+   * 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.current).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, target_] of Object.entries(mapping)) {
+        if (map.has(type)) {
+          throw new Error(
+            `Trying to set transition "${type}" on "${srcState}" (via "${nameOrPattern}"), but a transition already exists there.`
+          );
+        }
+        const target = target_;
+        this.knownEventTypes.add(type);
+        if (target !== void 0) {
+          const targetFn = typeof target === "function" ? target : () => target;
+          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.current) : 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) {
+    this.eventHub.willExitState.notify(this.currentState);
+    this.currentContext.allowPatching((patchableContext) => {
+      var _a;
+      levels = levels != null ? levels : this.cleanupStack.length;
+      for (let i = 0; i < levels; i++) {
+        (_a = this.cleanupStack.pop()) == null ? void 0 : _a(patchableContext);
+      }
+    });
+  }
+  /**
+   * 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
+    );
+    this.currentContext.allowPatching((patchableContext) => {
+      for (const pattern of enterPatterns) {
+        const enterFn = this.enterFns.get(pattern);
+        const cleanupFn = enterFn == null ? void 0 : enterFn(patchableContext);
+        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.current);
+    let nextState;
+    let effects = void 0;
+    if (nextTarget === null) {
+      this.eventHub.didIgnoreEvent.notify(event);
+      return;
+    }
+    if (typeof nextTarget === "string") {
+      nextState = nextTarget;
+    } else {
+      nextState = nextTarget.target;
+      effects = Array.isArray(nextTarget.effect) ? nextTarget.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 (effects !== void 0) {
+      const effectsToRun = effects;
+      this.currentContext.allowPatching((patchableContext) => {
+        for (const effect of effectsToRun) {
+          if (typeof effect === "function") {
+            effect(patchableContext, event);
+          } else {
+            patchableContext.patch(effect);
+          }
+        }
+      });
+    }
+    if (down > 0) {
+      this.enter(down);
+    }
+  }
+};
+
+// src/lib/utils.ts
+function isPlainObject(blob) {
+  return blob !== null && typeof blob === "object" && Object.prototype.toString.call(blob) === "[object Object]";
+}
+function fromEntries(iterable) {
+  const obj = {};
+  for (const [key, val] of iterable) {
+    obj[key] = val;
+  }
+  return obj;
+}
+function entries(obj) {
+  return Object.entries(obj);
+}
+function tryParseJson(rawMessage) {
+  try {
+    return JSON.parse(rawMessage);
+  } catch (e) {
+    return void 0;
+  }
+}
+function b64decode(b64value) {
+  try {
+    const formattedValue = b64value.replace(/-/g, "+").replace(/_/g, "/");
+    const decodedValue = decodeURIComponent(
+      atob(formattedValue).split("").map(function(c) {
+        return "%" + ("00" + c.charCodeAt(0).toString(16)).slice(-2);
+      }).join("")
+    );
+    return decodedValue;
+  } catch (err) {
+    return atob(b64value);
+  }
+}
+function compact(items) {
+  return items.filter(
+    (item) => item !== null && item !== void 0
+  );
+}
+function compactObject(obj) {
+  const newObj = __spreadValues({}, obj);
+  Object.keys(obj).forEach((k) => {
+    const key = k;
+    if (newObj[key] === void 0) {
+      delete newObj[key];
+    }
+  });
+  return newObj;
+}
+function withTimeout(promise, millis, errmsg = "Timed out") {
+  return __async(this, null, function* () {
+    let timerID;
+    const timer$ = new Promise((_, reject) => {
+      timerID = setTimeout(() => {
+        reject(new Error(errmsg));
+      }, millis);
+    });
+    return Promise.race([promise, timer$]).finally(() => clearTimeout(timerID));
+  });
+}
+
+// src/connection.ts
+function newToLegacyStatus(status) {
+  switch (status) {
+    case "connecting":
+      return "connecting";
+    case "connected":
+      return "open";
+    case "reconnecting":
+      return "unavailable";
+    case "disconnected":
+      return "failed";
+    case "initial":
+      return "closed";
+    default:
+      return "closed";
+  }
+}
+function toNewConnectionStatus(machine) {
+  const state = machine.currentState;
+  switch (state) {
+    case "@ok.connected":
+    case "@ok.awaiting-pong":
+      return "connected";
+    case "@idle.initial":
+      return "initial";
+    case "@auth.busy":
+    case "@auth.backoff":
+    case "@connecting.busy":
+    case "@connecting.backoff":
+      return machine.context.successCount > 0 ? "reconnecting" : "connecting";
+    case "@idle.failed":
+      return "disconnected";
+    default:
+      return assertNever(state, "Unknown state");
+  }
+}
+var BACKOFF_DELAYS = [250, 500, 1e3, 2e3, 4e3, 8e3, 1e4];
+var RESET_DELAY = BACKOFF_DELAYS[0] - 1;
+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 StopRetrying = class extends Error {
+  constructor(reason) {
+    super(reason);
+  }
+};
+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) {
+  context.patch({ backoffDelay: nextBackoffDelay(context.backoffDelay) });
+}
+function increaseBackoffDelayAggressively(context) {
+  context.patch({
+    backoffDelay: nextBackoffDelay(context.backoffDelay, BACKOFF_DELAYS_SLOW)
+  });
+}
+function resetSuccessCount(context) {
+  context.patch({ successCount: 0 });
+}
+function log(level, message) {
+  const logger = level === 2 /* ERROR */ ? error : level === 1 /* WARN */ ? warn : (
+    /* black hole */
+    () => {
+    }
+  );
+  return () => {
+    logger(message);
+  };
+}
+function logPrematureErrorOrCloseEvent(e) {
+  const conn = "Connection to Liveblocks websocket server";
+  return (ctx) => {
+    if (e instanceof Error) {
+      warn(`${conn} could not be established. ${String(e)}`);
+    } else {
+      warn(
+        isCloseEvent(e) ? `${conn} closed prematurely (code: ${e.code}). Retrying in ${ctx.backoffDelay}ms.` : `${conn} could not be established.`
+      );
+    }
+  };
+}
+function logCloseEvent(event) {
+  return (ctx) => {
+    warn(
+      `Connection to Liveblocks websocket server closed (code: ${event.code}). Retrying in ${ctx.backoffDelay}ms.`
+    );
+  };
+}
+var logPermanentClose = log(
+  1 /* WARN */,
+  "Connection to WebSocket closed permanently. Won't retry."
+);
+function sendHeartbeat(ctx) {
+  var _a;
+  (_a = ctx.socket) == null ? void 0 : _a.send("ping");
+}
+function isCloseEvent(error2) {
+  return !(error2 instanceof Error) && error2.type === "close";
+}
+function isCustomCloseEvent(error2) {
+  return isCloseEvent(error2) && error2.code >= 4e3 && error2.code < 4100;
+}
+function enableTracing(machine) {
+  const start = (/* @__PURE__ */ new Date()).getTime();
+  function log2(...args) {
+    warn(
+      `${(((/* @__PURE__ */ new Date()).getTime() - start) / 1e3).toFixed(2)} [FSM #${machine.id}]`,
+      ...args
+    );
+  }
+  const unsubs = [
+    machine.events.didReceiveEvent.subscribe((e) => log2(`Event ${e.type}`)),
+    machine.events.willTransition.subscribe(
+      ({ from, to }) => log2("Transitioning", from, "\u2192", to)
+    ),
+    machine.events.didIgnoreEvent.subscribe(
+      (e) => log2("Ignored event", e.type, e, "(current state won't handle it)")
+    )
+    // machine.events.willExitState.subscribe((s) => log("Exiting state", s)),
+    // machine.events.didEnterState.subscribe((s) => log("Entering state", s)),
+  ];
+  return () => {
+    for (const unsub of unsubs) {
+      unsub();
+    }
+  };
+}
+function defineConnectivityEvents(machine) {
+  const statusDidChange = makeEventSource();
+  const didConnect = makeEventSource();
+  const didDisconnect = makeEventSource();
+  let lastStatus = null;
+  const unsubscribe = machine.events.didEnterState.subscribe(() => {
+    const currStatus = toNewConnectionStatus(machine);
+    if (currStatus !== lastStatus) {
+      statusDidChange.notify(currStatus);
+    }
+    if (lastStatus === "connected" && currStatus !== "connected") {
+      didDisconnect.notify();
+    } else if (lastStatus !== "connected" && currStatus === "connected") {
+      didConnect.notify();
+    }
+    lastStatus = currStatus;
+  });
+  return {
+    statusDidChange: statusDidChange.observable,
+    didConnect: didConnect.observable,
+    didDisconnect: didDisconnect.observable,
+    unsubscribe
+  };
+}
+var assign = (patch) => (ctx) => ctx.patch(patch);
+function createConnectionStateMachine(delegates, enableDebugLogging) {
+  const onMessage = makeEventSource();
+  onMessage.pause();
+  const onLiveblocksError = makeEventSource();
+  const initialContext = {
+    successCount: 0,
+    token: null,
+    socket: null,
+    backoffDelay: RESET_DELAY
+  };
+  const machine = 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");
+  machine.addTransitions("*", {
+    RECONNECT: {
+      target: "@auth.backoff",
+      effect: [increaseBackoffDelay, resetSuccessCount]
+    },
+    DISCONNECT: "@idle.initial"
+  });
+  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"
+    )
+  });
+  machine.addTransitions("@auth.backoff", {
+    NAVIGATOR_ONLINE: {
+      target: "@auth.busy",
+      effect: assign({ backoffDelay: RESET_DELAY })
+    }
+  }).addTimedTransition(
+    "@auth.backoff",
+    (ctx) => ctx.backoffDelay,
+    "@auth.busy"
+  ).onEnterAsync(
+    "@auth.busy",
+    () => withTimeout(delegates.authenticate(), AUTH_TIMEOUT),
+    // On successful authentication
+    (okEvent) => ({
+      target: "@connecting.busy",
+      effect: assign({
+        token: okEvent.data,
+        backoffDelay: RESET_DELAY
+      })
+    }),
+    // Auth failed
+    (failedEvent) => {
+      if (failedEvent.reason instanceof StopRetrying) {
+        return {
+          target: "@idle.failed",
+          effect: log(2 /* ERROR */, failedEvent.reason.message)
+        };
+      }
+      return {
+        target: "@auth.backoff",
+        effect: [
+          increaseBackoffDelay,
+          log(
+            2 /* ERROR */,
+            `Authentication failed: ${failedEvent.reason instanceof Error ? failedEvent.reason.message : String(failedEvent.reason)}`
+          )
+        ]
+      };
+    }
+  );
+  const onSocketError = (event) => machine.send({ type: "EXPLICIT_SOCKET_ERROR", event });
+  const onSocketClose = (event) => machine.send({ type: "EXPLICIT_SOCKET_CLOSE", event });
+  const onSocketMessage = (event) => event.data === "pong" ? machine.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();
+    }
+  }
+  machine.addTransitions("@connecting.backoff", {
+    NAVIGATOR_ONLINE: {
+      target: "@connecting.busy",
+      effect: assign({ backoffDelay: RESET_DELAY })
+    }
+  }).addTimedTransition(
+    "@connecting.backoff",
+    (ctx) => ctx.backoffDelay,
+    "@connecting.busy"
+  ).onEnterAsync(
+    "@connecting.busy",
+    //
+    // Use the "createSocket" delegate function (provided to the
+    // ManagedSocket) to create the actual WebSocket connection instance.
+    // Then, set up all the necessary event listeners, and wait for the
+    // "open" event to occur.
+    //
+    // When the "open" event happens, we're ready to transition to the
+    // OK state. This is done by resolving the Promise.
+    //
+    (ctx) => __async(this, null, function* () {
+      let capturedPrematureEvent = null;
+      const connect$ = new Promise(
+        (resolve, rej) => {
+          if (ctx.token === null) {
+            throw new Error("No auth token");
+          }
+          const socket = delegates.createSocket(ctx.token);
+          function reject(event) {
+            capturedPrematureEvent = event;
+            socket.removeEventListener("message", onSocketMessage);
+            rej(event);
+          }
+          socket.addEventListener("message", onSocketMessage);
+          socket.addEventListener("error", reject);
+          socket.addEventListener("close", reject);
+          socket.addEventListener("open", () => {
+            socket.addEventListener("error", onSocketError);
+            socket.addEventListener("close", onSocketClose);
+            const unsub = () => {
+              socket.removeEventListener("error", reject);
+              socket.removeEventListener("close", reject);
+            };
+            resolve([socket, unsub]);
+          });
+        }
+      );
+      return withTimeout(connect$, SOCKET_CONNECT_TIMEOUT).then(
+        //
+        // Part 3:
+        // By now, our "open" event has fired, and the promise has been
+        // resolved. Two possible scenarios:
+        //
+        // 1. The happy path. Most likely.
+        // 2. Uh-oh. A premature close/error event has been observed. Let's
+        //    reject the promise after all.
+        //
+        // Any close/error event that will get scheduled after this point
+        // onwards, will be caught in the OK state, and dealt with
+        // accordingly.
+        //
+        ([socket, unsub]) => {
+          unsub();
+          if (capturedPrematureEvent) {
+            throw capturedPrematureEvent;
+          }
+          return socket;
+        }
+      );
+    }),
+    // Only transition to OK state after a successfully opened WebSocket connection
+    (okEvent) => ({
+      target: "@ok.connected",
+      effect: assign({
+        socket: okEvent.data,
+        backoffDelay: RESET_DELAY
+      })
+    }),
+    // If the WebSocket connection cannot be established
+    (failure) => {
+      const err = failure.reason;
+      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)
+          ]
+        };
+      }
+      return {
+        target: "@auth.backoff",
+        effect: [increaseBackoffDelay, logPrematureErrorOrCloseEvent(err)]
+      };
+    }
+  );
+  machine.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",
+    // Log implicit connection loss and drop the current open socket
+    effect: log(
+      1 /* WARN */,
+      "Received no pong from server, assume implicit connection loss."
+    )
+  };
+  machine.onEnter("@ok.*", (ctx) => {
+    ctx.patch({ successCount: ctx.successCount + 1 });
+    const timerID = setTimeout(
+      // On the next tick, start delivering all messages that have already
+      // been received, and continue synchronous delivery of all future
+      // incoming messages.
+      onMessage.unpause,
+      0
+    );
+    return (ctx2) => {
+      teardownSocket(ctx2.socket);
+      ctx2.patch({ socket: null });
+      clearTimeout(timerID);
+      onMessage.pause();
+    };
+  }).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) === 1) {
+        return null;
+      }
+      return {
+        target: "@connecting.backoff",
+        effect: increaseBackoffDelay
+      };
+    },
+    EXPLICIT_SOCKET_CLOSE: (e) => {
+      if (e.event.code === 4999) {
+        return {
+          target: "@idle.failed",
+          effect: logPermanentClose
+        };
+      }
+      if (e.event.code === 4001) {
+        return {
+          target: "@auth.backoff",
+          effect: [increaseBackoffDelay, logCloseEvent(e.event)]
+        };
+      }
+      if (isCustomCloseEvent(e.event)) {
+        return {
+          target: "@connecting.backoff",
+          effect: [
+            increaseBackoffDelayAggressively,
+            logCloseEvent(e.event),
+            () => {
+              const err = new LiveblocksError(e.event.reason, e.event.code);
+              onLiveblocksError.notify(err);
+            }
+          ]
+        };
+      }
+      return {
+        target: "@connecting.backoff",
+        effect: [increaseBackoffDelay, logCloseEvent(e.event)]
+      };
+    }
+  });
+  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;
+    machine.onEnter("*", (ctx) => {
+      function onBackOnline() {
+        machine.send({ type: "NAVIGATOR_ONLINE" });
+      }
+      function onVisibilityChange() {
+        if ((doc == null ? void 0 : doc.visibilityState) === "visible") {
+          machine.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 cleanups = [];
+  const { statusDidChange, didConnect, didDisconnect, unsubscribe } = defineConnectivityEvents(machine);
+  cleanups.push(unsubscribe);
+  if (enableDebugLogging) {
+    cleanups.push(enableTracing(machine));
+  }
+  machine.start();
+  return {
+    machine,
+    cleanups,
+    // Observable events that will be emitted by this machine
+    events: {
+      statusDidChange,
+      didConnect,
+      didDisconnect,
+      onMessage: onMessage.observable,
+      onLiveblocksError: onLiveblocksError.observable
+    }
+  };
+}
+var ManagedSocket = class {
+  constructor(delegates, enableDebugLogging = false) {
+    const { machine, events, cleanups } = createConnectionStateMachine(
+      delegates,
+      enableDebugLogging
+    );
+    this.machine = machine;
+    this.events = events;
+    this.cleanups = cleanups;
+  }
+  getLegacyStatus() {
+    return newToLegacyStatus(this.getStatus());
+  }
+  getStatus() {
+    try {
+      return toNewConnectionStatus(this.machine);
+    } catch (e) {
+      return "initial";
+    }
+  }
+  /**
+   * Returns the current auth token.
+   */
+  get token() {
+    return this.machine.context.token;
+  }
+  /**
+   * 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.machine.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.machine.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.machine.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.machine.stop();
+    let cleanup;
+    while (cleanup = this.cleanups.pop()) {
+      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.machine.context) == null ? void 0 : _a.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/lib/position.ts
 var MIN_CODE = 32;
 var MAX_CODE = 126;
@@ -625,86 +1648,36 @@ var AbstractCrdt = class {
    * mutation to the Live node.
    */
   invalidate() {
-    if (this._cachedImmutable !== void 0 || this._cachedTreeNode !== void 0) {
-      this._cachedImmutable = void 0;
-      this._cachedTreeNode = void 0;
-      if (this.parent.type === "HasParent") {
-        this.parent.node.invalidate();
-      }
-    }
-  }
-  /**
-   * @internal
-   *
-   * Return an snapshot of this Live tree for use in DevTools.
-   */
-  toTreeNode(key) {
-    if (this._cachedTreeNode === void 0 || this._cachedTreeNodeKey !== key) {
-      this._cachedTreeNodeKey = key;
-      this._cachedTreeNode = this._toTreeNode(key);
-    }
-    return this._cachedTreeNode;
-  }
-  /**
-   * Return an immutable snapshot of this Live node and its children.
-   */
-  toImmutable() {
-    if (this._cachedImmutable === void 0) {
-      this._cachedImmutable = this._toImmutable();
-    }
-    return this._cachedImmutable;
-  }
-};
-
-// src/lib/utils.ts
-function isPlainObject(blob) {
-  return blob !== null && typeof blob === "object" && Object.prototype.toString.call(blob) === "[object Object]";
-}
-function fromEntries(iterable) {
-  const obj = {};
-  for (const [key, val] of iterable) {
-    obj[key] = val;
-  }
-  return obj;
-}
-function entries(obj) {
-  return Object.entries(obj);
-}
-function tryParseJson(rawMessage) {
-  try {
-    return JSON.parse(rawMessage);
-  } catch (e) {
-    return void 0;
-  }
-}
-function b64decode(b64value) {
-  try {
-    const formattedValue = b64value.replace(/-/g, "+").replace(/_/g, "/");
-    const decodedValue = decodeURIComponent(
-      atob(formattedValue).split("").map(function(c) {
-        return "%" + ("00" + c.charCodeAt(0).toString(16)).slice(-2);
-      }).join("")
-    );
-    return decodedValue;
-  } catch (err) {
-    return atob(b64value);
+    if (this._cachedImmutable !== void 0 || this._cachedTreeNode !== void 0) {
+      this._cachedImmutable = void 0;
+      this._cachedTreeNode = void 0;
+      if (this.parent.type === "HasParent") {
+        this.parent.node.invalidate();
+      }
+    }
   }
-}
-function compact(items) {
-  return items.filter(
-    (item) => item !== null && item !== void 0
-  );
-}
-function compactObject(obj) {
-  const newObj = __spreadValues({}, obj);
-  Object.keys(obj).forEach((k) => {
-    const key = k;
-    if (newObj[key] === void 0) {
-      delete newObj[key];
+  /**
+   * @internal
+   *
+   * Return an snapshot of this Live tree for use in DevTools.
+   */
+  toTreeNode(key) {
+    if (this._cachedTreeNode === void 0 || this._cachedTreeNodeKey !== key) {
+      this._cachedTreeNodeKey = key;
+      this._cachedTreeNode = this._toTreeNode(key);
     }
-  });
-  return newObj;
-}
+    return this._cachedTreeNode;
+  }
+  /**
+   * Return an immutable snapshot of this Live node and its children.
+   */
+  toImmutable() {
+    if (this._cachedImmutable === void 0) {
+      this._cachedImmutable = this._toImmutable();
+    }
+    return this._cachedImmutable;
+  }
+};
 
 // src/protocol/SerializedCrdt.ts
 var CrdtType = /* @__PURE__ */ ((CrdtType2) => {
@@ -3239,35 +4212,12 @@ 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;
 var MAX_MESSAGE_SIZE = 1024 * 1024 - 128;
 function makeIdFactory(connectionId) {
   let count = 0;
   return () => `${connectionId}:${count++}`;
 }
-function log(..._params) {
-  return;
-}
-function isConnectionSelfAware(connection) {
-  return connection.status === "open" || connection.status === "connecting";
-}
 function userToTreeNode(key, user) {
   return {
     type: "User",
@@ -3277,21 +4227,27 @@ function userToTreeNode(key, user) {
   };
 }
 function createRoom(options, config) {
-  var _a;
+  var _a, _b, _c, _d;
   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 = (_c = config.delegates) != null ? _c : {
+    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,
+    config.enableDebugLogging
+  );
   const context = {
-    token: null,
-    lastConnectionId: null,
-    socket: null,
-    numRetries: 0,
-    timers: {
-      flush: void 0,
-      reconnect: void 0,
-      heartbeat: void 0,
-      pongTimeout: void 0
-    },
     buffer: {
+      flushTimerID: void 0,
       lastFlushedAt: 0,
       me: (
         // Queue up the initial presence message as a Full Presence™ update
@@ -3303,7 +4259,7 @@ function createRoom(options, config) {
       messages: [],
       storageOperations: []
     },
-    connection: new ValueRef({ status: "closed" }),
+    sessionInfo: new ValueRef(null),
     me: new MeRef(initialPresence),
     others: new OthersRef(),
     initialStorage,
@@ -3322,7 +4278,91 @@ 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 = (_d = config.unstable_batchedUpdates) != null ? _d : doNotBatchUpdates;
+  let lastToken;
+  function onStatusDidChange(newStatus) {
+    var _a2;
+    const token = (_a2 = managedSocket.token) == null ? void 0 : _a2.parsed;
+    if (token !== void 0 && token !== lastToken) {
+      context.sessionInfo.set({
+        id: token.actor,
+        userInfo: token.info,
+        userId: token.id,
+        isReadOnly: isStorageReadOnly(token.scopes)
+      });
+      lastToken = token;
+    }
+    batchUpdates(() => {
+      eventHub.status.notify(newStatus);
+      eventHub.connection.notify(newToLegacyStatus(newStatus));
+    });
+  }
+  let _connectionLossTimerId;
+  let _hasLostConnection = false;
+  function handleConnectionLossEvent(newStatus) {
+    if (newStatus === "reconnecting") {
+      _connectionLossTimerId = setTimeout(() => {
+        batchUpdates(() => {
+          eventHub.lostConnection.notify("lost");
+          _hasLostConnection = true;
+          context.others.clearOthers();
+          notify({ others: [{ type: "reset" }] }, doNotBatchUpdates);
+        });
+      }, config.lostConnectionTimeout);
+    } else {
+      clearTimeout(_connectionLossTimerId);
+      if (_hasLostConnection) {
+        if (newStatus === "disconnected") {
+          batchUpdates(() => {
+            eventHub.lostConnection.notify("failed");
+          });
+        } else {
+          batchUpdates(() => {
+            eventHub.lostConnection.notify("restored");
+          });
+        }
+        _hasLostConnection = false;
+      }
+    }
+  }
+  function onDidConnect() {
+    const sessionInfo = context.sessionInfo.current;
+    if (sessionInfo === null) {
+      throw new Error("Unexpected missing session info");
+    }
+    context.buffer.me = {
+      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.
+        __spreadValues({}, context.me.current)
+      )
+    };
+    context.idFactory = makeIdFactory(sessionInfo.id);
+    if (context.root) {
+      context.buffer.messages.push({ type: 200 /* FETCH_STORAGE */ });
+    }
+    tryFlushing();
+  }
+  function onDidDisconnect() {
+    clearTimeout(context.buffer.flushTimerID);
+  }
+  managedSocket.events.onMessage.subscribe(handleServerMessage);
+  managedSocket.events.statusDidChange.subscribe(onStatusDidChange);
+  managedSocket.events.statusDidChange.subscribe(handleConnectionLossEvent);
+  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),
@@ -3364,7 +4404,8 @@ function createRoom(options, config) {
       }
     },
     assertStorageIsWritable: () => {
-      if (isConnectionSelfAware(context.connection.current) && context.connection.current.isReadOnly) {
+      var _a2;
+      if ((_a2 = context.sessionInfo.current) == null ? void 0 : _a2.isReadOnly) {
         throw new Error(
           "Cannot write to storage with a read only user, please ensure the user has write permissions"
         );
@@ -3372,81 +4413,55 @@ function createRoom(options, config) {
     }
   };
   const eventHub = {
+    connection: makeEventSource(),
+    // Old/deprecated API
+    status: makeEventSource(),
+    // New/recommended API
+    lostConnection: makeEventSource(),
     customEvent: makeEventSource(),
     me: makeEventSource(),
     others: makeEventSource(),
     error: makeEventSource(),
-    connection: makeEventSource(),
     storage: makeEventSource(),
     history: makeEventSource(),
     storageDidLoad: makeEventSource(),
     storageStatus: makeEventSource()
   };
-  const effects = config.mockedEffects || {
-    authenticateAndConnect(auth, createWebSocket) {
-      const prevToken = context.token;
-      if (prevToken !== null && !isTokenExpired(prevToken.parsed)) {
-        const socket = createWebSocket(prevToken);
-        handleAuthSuccess(prevToken.parsed, socket);
-        return void 0;
-      } else {
-        void auth().then((token) => {
-          if (context.connection.current.status !== "authenticating") {
-            return;
-          }
-          const socket = createWebSocket(token);
-          handleAuthSuccess(token.parsed, socket);
-          context.token = token;
-        }).catch(
-          (er) => authenticationFailure(
-            er instanceof Error ? er : new Error(String(er))
-          )
-        );
-        return void 0;
-      }
-    },
-    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) {
-        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;
-          }
+  function sendMessages(messageOrMessages) {
+    var _a2, _b2;
+    const message = JSON.stringify(messageOrMessages);
+    if (config.unstable_fallbackToHTTP) {
+      const size = new TextEncoder().encode(message).length;
+      if (size > MAX_MESSAGE_SIZE && ((_a2 = managedSocket.token) == null ? void 0 : _a2.raw) && config.httpSendEndpoint) {
+        if (isTokenExpired(managedSocket.token.parsed)) {
+          return managedSocket.reconnect();
         }
-        context.socket.send(message);
+        void httpSend(
+          message,
+          managedSocket.token.raw,
+          config.httpSendEndpoint,
+          (_b2 = config.polyfills) == null ? void 0 : _b2.fetch
+        );
+        warn(
+          "Message was too large for websockets and sent over HTTP instead"
+        );
+        return;
       }
-    },
-    scheduleReconnect: (delay) => setTimeout(handleConnect, delay),
-    startHeartbeatInterval: () => setInterval(heartbeat, HEARTBEAT_INTERVAL),
-    schedulePongTimeout: () => setTimeout(pongTimeout, PONG_TIMEOUT)
-  };
+    }
+    managedSocket.send(message);
+  }
   const self = new DerivedRef(
-    context.connection,
+    context.sessionInfo,
     context.me,
-    (conn, me) => isConnectionSelfAware(conn) ? {
-      connectionId: conn.id,
-      id: conn.userId,
-      info: conn.userInfo,
-      presence: me,
-      isReadOnly: conn.isReadOnly
-    } : null
+    (info, me) => {
+      return info !== null ? {
+        connectionId: info.id,
+        id: info.userId,
+        info: info.userInfo,
+        presence: me,
+        isReadOnly: info.isReadOnly
+      } : null;
+    }
   );
   const selfAsTreeNode = new DerivedRef(
     self,
@@ -3515,11 +4530,9 @@ function createRoom(options, config) {
     });
   }
   function getConnectionId() {
-    const conn = context.connection.current;
-    if (isConnectionSelfAware(conn)) {
-      return conn.id;
-    } else if (context.lastConnectionId !== null) {
-      return context.lastConnectionId;
+    const info = context.sessionInfo.current;
+    if (info) {
+      return info.id;
     }
     throw new Error(
       "Internal. Tried to get connection id but connection was never open"
@@ -3642,23 +4655,6 @@ function createRoom(options, config) {
       }
     }
   }
-  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
-    );
-    const createWebSocket = prepareCreateWebSocket(
-      config.liveblocksServer,
-      (_b = config.polyfills) == null ? void 0 : _b.WebSocket
-    );
-    updateConnection({ status: "authenticating" }, batchUpdates);
-    effects.authenticateAndConnect(auth, createWebSocket);
-  }
   function updatePresence(patch, options2) {
     const oldValues = {};
     if (context.buffer.me === null) {
@@ -3700,40 +4696,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 handleAuthSuccess(token, socket) {
-    socket.addEventListener("message", handleRawSocketMessage);
-    socket.addEventListener("open", handleSocketOpen);
-    socket.addEventListener("close", handleExplicitClose);
-    socket.addEventListener("error", handleSocketError);
-    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 handleWindowGotFocus() {
-    if (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);
@@ -3783,12 +4745,6 @@ function createRoom(options, config) {
     }
     return { type: "reset" };
   }
-  function handleNavigatorBackOnline() {
-    if (context.connection.current.status === "unavailable") {
-      log("Try to reconnect after connectivity change");
-      reconnect();
-    }
-  }
   function canUndo() {
     return context.undoStack.length > 0;
   }
@@ -3844,17 +4800,7 @@ function createRoom(options, config) {
       ops: result.ops
     });
     notify(result.updates, batchedUpdatesWrapper);
-    effects.send(messages);
-  }
-  function handleRawSocketMessage(event) {
-    if (event.data === "pong") {
-      transition({ type: "RECEIVE_PONG" });
-    } else {
-      handleServerMessage(event);
-    }
-  }
-  function handlePong() {
-    clearTimeout(context.timers.pongTimeout);
+    sendMessages(messages);
   }
   function handleServerMessage(event) {
     if (typeof event.data !== "string") {
@@ -3908,8 +4854,8 @@ function createRoom(options, config) {
             const unacknowledgedOps = new Map(context.unacknowledgedOps);
             createOrUpdateRootFromMessage(message, doNotBatchUpdates);
             applyAndSendOps(unacknowledgedOps, doNotBatchUpdates);
-            if (_getInitialStateResolver !== null) {
-              _getInitialStateResolver();
+            if (_resolveInitialStatePromise !== null) {
+              _resolveInitialStatePromise();
             }
             notifyStorageStatus();
             eventHub.storageDidLoad.notify();
@@ -3957,140 +4903,6 @@ ${Array.from(traces).join("\n\n")}`
       notify(updates, doNotBatchUpdates);
     });
   }
-  function handleExplicitClose(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 handleSocketError() {
-  }
-  function handleSocketOpen() {
-    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 handleDisconnect() {
-    if (context.socket) {
-      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;
-    }
-    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", handleSocketOpen);
-      context.socket.removeEventListener("message", handleRawSocketMessage);
-      context.socket.removeEventListener("close", handleExplicitClose);
-      context.socket.removeEventListener("error", handleSocketError);
-      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);
-    handleConnect();
-  }
   function tryFlushing() {
     const storageOps = context.buffer.storageOperations;
     if (storageOps.length > 0) {
@@ -4099,7 +4911,7 @@ ${Array.from(traces).join("\n\n")}`
       }
       notifyStorageStatus();
     }
-    if (context.socket === null || context.socket.readyState !== context.socket.OPEN) {
+    if (managedSocket.getStatus() !== "connected") {
       context.buffer.storageOperations = [];
       return;
     }
@@ -4110,16 +4922,17 @@ ${Array.from(traces).join("\n\n")}`
       if (messagesToFlush.length === 0) {
         return;
       }
-      effects.send(messagesToFlush);
+      sendMessages(messagesToFlush);
       context.buffer = {
+        flushTimerID: void 0,
         lastFlushedAt: now,
         messages: [],
         storageOperations: [],
         me: null
       };
     } else {
-      clearTimeout(context.timers.flush);
-      context.timers.flush = setTimeout(
+      clearTimeout(context.buffer.flushTimerID);
+      context.buffer.flushTimerID = setTimeout(
         tryFlushing,
         config.throttleDelay - elapsedMillis
       );
@@ -4156,7 +4969,7 @@ ${Array.from(traces).join("\n\n")}`
   function broadcastEvent(event, options2 = {
     shouldQueueEventIfNotReady: false
   }) {
-    if (context.socket === null && !options2.shouldQueueEventIfNotReady) {
+    if (managedSocket.getStatus() !== "connected" && !options2.shouldQueueEventIfNotReady) {
       return;
     }
     context.buffer.messages.push({
@@ -4170,13 +4983,13 @@ ${Array.from(traces).join("\n\n")}`
     tryFlushing();
   }
   let _getInitialStatePromise = null;
-  let _getInitialStateResolver = null;
+  let _resolveInitialStatePromise = null;
   function startLoadingStorage() {
     if (_getInitialStatePromise === null) {
       context.buffer.messages.push({ type: 200 /* FETCH_STORAGE */ });
       tryFlushing();
       _getInitialStatePromise = new Promise(
-        (resolve) => _getInitialStateResolver = resolve
+        (resolve) => _resolveInitialStatePromise = resolve
       );
       notifyStorageStatus();
     }
@@ -4293,11 +5106,6 @@ ${Array.from(traces).join("\n\n")}`
       _addToRealUndoStack(historyOps, batchUpdates);
     }
   }
-  function handleImplicitClose() {
-    if (context.socket) {
-      context.socket = null;
-    }
-  }
   function getStorageStatus() {
     if (_getInitialStatePromise === null) {
       return "not-loaded";
@@ -4320,38 +5128,20 @@ ${Array.from(traces).join("\n\n")}`
     (others) => others.map((other, index) => userToTreeNode(`Other ${index}`, other))
   );
   const events = {
+    connection: eventHub.connection.observable,
+    // Old/deprecated API
+    status: eventHub.status.observable,
+    // New/recommended API
+    lostConnection: eventHub.lostConnection.observable,
     customEvent: eventHub.customEvent.observable,
     others: eventHub.others.observable,
     me: eventHub.me.observable,
     error: eventHub.error.observable,
-    connection: eventHub.connection.observable,
     storage: eventHub.storage.observable,
     history: eventHub.history.observable,
     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: {
@@ -4359,10 +5149,6 @@ ${Array.from(traces).join("\n\n")}`
         return context.buffer;
       },
       // prettier-ignore
-      get numRetries() {
-        return context.numRetries;
-      },
-      // prettier-ignore
       get undoStack() {
         return context.undoStack;
       },
@@ -4376,27 +5162,17 @@ ${Array.from(traces).join("\n\n")}`
       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
+        // These exist only for our E2E testing app
+        explicitClose: (event) => managedSocket._privateSendMachineEvent({ type: "EXPLICIT_SOCKET_CLOSE", event }),
+        implicitClose: () => managedSocket._privateSendMachineEvent({ type: "PONG_TIMEOUT" })
       }
     },
     id: config.roomId,
     subscribe: makeClassicSubscribeFn(events),
-    reconnect,
+    connect: () => managedSocket.connect(),
+    reconnect: () => managedSocket.reconnect(),
+    disconnect: () => managedSocket.disconnect(),
+    destroy: () => managedSocket.destroy(),
     // Presence
     updatePresence,
     broadcastEvent,
@@ -4415,8 +5191,9 @@ ${Array.from(traces).join("\n\n")}`
     getStorageStatus,
     events,
     // Core
-    getConnectionState: () => context.connection.current.status,
-    isSelfAware: () => isConnectionSelfAware(context.connection.current),
+    getStatus: () => managedSocket.getStatus(),
+    getConnectionState: () => managedSocket.getLegacyStatus(),
+    isSelfAware: () => context.sessionInfo.current !== null,
     getSelf: () => self.current,
     // Presence
     getPresence: () => context.me.current,
@@ -4468,6 +5245,12 @@ function makeClassicSubscribeFn(events) {
           return events.connection.subscribe(
             callback
           );
+        case "status":
+          return events.status.subscribe(callback);
+        case "lost-connection":
+          return events.lostConnection.subscribe(
+            callback
+          );
         case "history":
           return events.history.subscribe(callback);
         case "storage-status":
@@ -4503,20 +5286,14 @@ 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;
+function makeCreateSocketDelegateForRoom(liveblocksServer, WebSocketPolyfill) {
   return (richToken) => {
+    const ws = WebSocketPolyfill != null ? 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
@@ -4524,7 +5301,7 @@ function prepareCreateWebSocket(liveblocksServer, WebSocketPolyfill) {
       // @ts-ignore (__PACKAGE_VERSION__ will be injected by the build script)
       true ? (
         /* istanbul ignore next */
-        "1.0.12"
+        "1.1.0-beta2"
       ) : "dev"}`
     );
   };
@@ -4543,45 +5320,44 @@ function httpSend(message, token, endpoint, fetchPolyfill) {
     });
   });
 }
-function prepareAuthEndpoint(roomId, authentication, fetchPolyfill) {
+function makeAuthDelegateForRoom(roomId, authentication, fetchPolyfill) {
+  const fetcher = fetchPolyfill != null ? fetchPolyfill : typeof window === "undefined" ? void 0 : window.fetch;
   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 () => fetchAuthEndpoint(
-      fetchPolyfill || /* istanbul ignore next */
-      fetch,
-      authentication.url,
-      {
+    return () => __async(this, null, function* () {
+      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 }) => parseRoomAuthToken(token));
+    });
+  } else if (authentication.type === "private") {
+    return () => __async(this, null, function* () {
+      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."
+        );
       }
-    ).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 () => fetchAuthEndpoint(fetchPolyfill || fetch, authentication.url, {
-      room: roomId
-    }).then(({ token }) => parseRoomAuthToken(token));
-  }
-  if (authentication.type === "custom") {
+      return fetchAuthEndpoint(fetcher, authentication.url, {
+        room: roomId
+      }).then(({ token }) => parseRoomAuthToken(token));
+    });
+  } else if (authentication.type === "custom") {
     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: "..." }'
+          'We expect the authentication callback to return a token, but it does not. Hint: the return value should look like: { token: "..." }'
         );
       }
       return parseRoomAuthToken(response.token);
     });
+  } else {
+    throw new Error("Internal error. Unexpected authentication type");
   }
-  throw new Error("Internal error. Unexpected authentication type");
 }
 function fetchAuthEndpoint(fetch2, endpoint, body) {
   return __async(this, null, function* () {
@@ -4595,22 +5371,25 @@ 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}"`
-      );
+      const reason = `${(yield 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 = yield res.json();
     } catch (er) {
-      throw new AuthenticationError(
+      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 AuthenticationError(
+      throw new Error(
         `Expected a JSON response of the form \`{ token: "..." }\` when doing a POST request on "${endpoint}", but got ${JSON.stringify(
           data
         )}`
@@ -4620,11 +5399,6 @@ function fetchAuthEndpoint(fetch2, endpoint, body) {
     return { token };
   });
 }
-var AuthenticationError = class extends Error {
-  constructor(message) {
-    super(message);
-  }
-};
 
 // src/client.ts
 var MIN_THROTTLE = 16;
@@ -4643,7 +5417,7 @@ function createClient(options) {
     return room ? room : null;
   }
   function enter(roomId, options2) {
-    var _a, _b, _c;
+    var _a, _b, _c, _d;
     const existingRoom = rooms.get(roomId);
     if (existingRoom !== void 0) {
       return existingRoom;
@@ -4660,7 +5434,10 @@ function createClient(options) {
       {
         roomId,
         throttleDelay,
+        lostConnectionTimeout: (_b = clientOptions.lostConnectionTimeout) != null ? _b : 5e3,
         polyfills: clientOptions.polyfills,
+        delegates: clientOptions.mockedDelegates,
+        enableDebugLogging: clientOptions.enableDebugLogging,
         unstable_batchedUpdates: options2 == null ? void 0 : options2.unstable_batchedUpdates,
         liveblocksServer: getServerFromClientOptions(clientOptions),
         authentication: prepareAuthentication(clientOptions, roomId),
@@ -4674,17 +5451,17 @@ function createClient(options) {
     rooms.set(roomId, newRoom);
     setupDevTools(() => Array.from(rooms.keys()));
     linkDevTools(roomId, newRoom);
-    const shouldConnect = (_b = options2.shouldInitiallyConnect) != null ? _b : true;
+    const shouldConnect = (_c = options2.shouldInitiallyConnect) != null ? _c : true;
     if (shouldConnect) {
       if (typeof atob === "undefined") {
-        if (((_c = clientOptions.polyfills) == null ? void 0 : _c.atob) === void 0) {
+        if (((_d = clientOptions.polyfills) == null ? void 0 : _d.atob) === void 0) {
           throw new Error(
             "You need to polyfill atob to use the client in your environment. Please follow the instructions at https://liveblocks.io/docs/errors/liveblocks-client/atob-polyfill"
           );
         }
         global.atob = clientOptions.polyfills.atob;
       }
-      newRoom.__internal.send.connect();
+      newRoom.connect();
     }
     return newRoom;
   }
@@ -4692,27 +5469,10 @@ function createClient(options) {
     unlinkDevTools(roomId);
     const room = rooms.get(roomId);
     if (room !== void 0) {
-      room.__internal.send.disconnect();
+      room.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.send.navigatorOnline();
-      }
-    });
-  }
-  if (typeof document !== "undefined") {
-    document.addEventListener("visibilitychange", () => {
-      if (document.visibilityState === "visible") {
-        for (const [, room] of rooms) {
-          room.__internal.send.windowGotFocus();
-        }
-      }
-    });
-  }
   return {
     getRoom,
     enter,
@@ -5131,6 +5891,20 @@ 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 || {});
+
+
 
 
 
@@ -5166,4 +5940,4 @@ function shallow(a, b) {
 
 
 
-exports.ClientMsgCode = ClientMsgCode; exports.CrdtType = CrdtType; exports.LiveList = LiveList; exports.LiveMap = LiveMap; exports.LiveObject = LiveObject; exports.OpCode = OpCode; exports.ServerMsgCode = ServerMsgCode; exports.WebsocketCloseCodes = WebsocketCloseCodes; exports.asArrayWithLegacyMethods = asArrayWithLegacyMethods; exports.asPos = asPos; exports.assert = assert; exports.assertNever = assertNever; exports.b64decode = b64decode; exports.createClient = createClient; exports.deprecate = deprecate; exports.deprecateIf = deprecateIf; exports.errorIf = errorIf; exports.freeze = freeze; exports.isAppOnlyAuthToken = isAppOnlyAuthToken; exports.isAuthToken = isAuthToken; exports.isChildCrdt = isChildCrdt; exports.isJsonArray = isJsonArray; exports.isJsonObject = isJsonObject; exports.isJsonScalar = isJsonScalar; exports.isPlainObject = isPlainObject; exports.isRoomAuthToken = isRoomAuthToken; exports.isRootCrdt = isRootCrdt; exports.legacy_patchImmutableObject = legacy_patchImmutableObject; exports.lsonToJson = lsonToJson; exports.makePosition = makePosition; exports.nn = nn; exports.patchLiveObjectKey = patchLiveObjectKey; exports.shallow = shallow; exports.throwUsageError = throwUsageError; exports.tryParseJson = tryParseJson;
+exports.ClientMsgCode = ClientMsgCode; exports.CrdtType = CrdtType; exports.LiveList = LiveList; exports.LiveMap = LiveMap; exports.LiveObject = LiveObject; exports.OpCode = OpCode; exports.ServerMsgCode = ServerMsgCode; exports.WebsocketCloseCodes = WebsocketCloseCodes; exports.asArrayWithLegacyMethods = asArrayWithLegacyMethods; exports.asPos = asPos; exports.assert = assert; exports.assertNever = assertNever; exports.b64decode = b64decode; exports.createClient = createClient; exports.deprecate = deprecate; exports.deprecateIf = deprecateIf; exports.errorIf = errorIf; exports.freeze = freeze; exports.isAppOnlyAuthToken = isAppOnlyAuthToken; exports.isAuthToken = isAuthToken; exports.isChildCrdt = isChildCrdt; exports.isJsonArray = isJsonArray; exports.isJsonObject = isJsonObject; exports.isJsonScalar = isJsonScalar; exports.isPlainObject = isPlainObject; exports.isRoomAuthToken = isRoomAuthToken; exports.isRootCrdt = isRootCrdt; exports.legacy_patchImmutableObject = legacy_patchImmutableObject; exports.lsonToJson = lsonToJson; exports.makePosition = makePosition; exports.nn = nn; exports.patchLiveObjectKey = patchLiveObjectKey; exports.shallow = shallow; exports.throwUsageError = throwUsageError; exports.tryParseJson = tryParseJson; exports.withTimeout = withTimeout;