@pluv/client 0.0.0-experimental-20250527040415

package/dist/index.mjs

@@ -0,0 +1,1917 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/index.ts
+import { ConnectionState as ConnectionState3 } from "@pluv/types";
+
+// src/AbstractStorageStore.ts
+var AbstractStorageStore = class {
+  constructor(room) {
+    this.room = room;
+  }
+};
+
+// src/constants.ts
+var MAX_PRESENCE_SIZE_BYTES = 512;
+var PLUV_PRESENCE_META_KEY = "__pluv";
+
+// src/PluvProcedure.ts
+var PluvProcedure = class _PluvProcedure {
+  constructor(config = {}) {
+    this._broadcast = null;
+    this._input = null;
+    const { broadcast, input } = config;
+    this._broadcast = broadcast != null ? broadcast : null;
+    this._input = input != null ? input : null;
+  }
+  get config() {
+    var _a, _b, _c;
+    return {
+      broadcast: (_b = (_a = this._broadcast) == null ? void 0 : _a.bind(this)) != null ? _b : null,
+      input: (_c = this._input) != null ? _c : null,
+      resolver: this._resolver()
+    };
+  }
+  broadcast(resolver) {
+    const { broadcast } = this.config;
+    if (!!broadcast) throw new Error("Broadcast was already defined for this procedure");
+    return new _PluvProcedure(__spreadProps(__spreadValues({}, this.config), {
+      broadcast: resolver
+    }));
+  }
+  input(input) {
+    return new _PluvProcedure({ input });
+  }
+  _resolver() {
+    return (data, context) => {
+      var _a;
+      return (_a = this._broadcast) == null ? void 0 : _a.call(this, data, context);
+    };
+  }
+};
+
+// src/PluvRoom.ts
+import { ConnectionState, StorageState } from "@pluv/types";
+
+// src/CrdtManager.ts
+import { noop } from "@pluv/crdt";
+var CrdtManager = class {
+  constructor(options) {
+    this.initialized = false;
+    const { initialStorage = noop.doc({}) } = options;
+    this._docFactory = initialStorage;
+    this.doc = this._docFactory.getEmpty();
+  }
+  /**
+   * !HACK
+   * @description If this is called before the doc is initialized. Omit the
+   * update. This unfortunately means updates can be dropped entirely
+   * @date June 13, 2023
+   */
+  applyUpdate(params) {
+    const { origin, update } = params;
+    if (!this.initialized) return this;
+    const updates = typeof update === "string" ? [update] : update;
+    this._applyDocUpdates(this.doc, updates, origin);
+    return this;
+  }
+  destroy() {
+    this.initialized = false;
+    this.doc.destroy();
+    this.doc = this._docFactory.getEmpty();
+  }
+  get(key) {
+    return this.doc.get(key);
+  }
+  getInitialState() {
+    return this._docFactory.getInitialized().getEncodedState();
+  }
+  initialize(params) {
+    const { origin, update } = params;
+    if (this.initialized) {
+      console.warn("Attempted to initialize storage multiple times");
+      return this;
+    }
+    if (!this.doc.isEmpty()) {
+      console.warn("Attempted to initialize over a non-empty storage");
+      return this;
+    }
+    const updates = typeof update === "string" ? [update] : update;
+    if (!updates.length) return this;
+    const initialized = this._docFactory.getInitialized();
+    const reference = initialized.get();
+    this.doc = this._applyDocUpdates(this.doc, updates, origin).rebuildStorage(reference);
+    this.initialized = true;
+    initialized.destroy();
+    return this;
+  }
+  resolveEncodedState(updates) {
+    return this._docFactory.resolveEncodedState(updates);
+  }
+  _applyDocUpdates(doc, updates, origin) {
+    doc.transact(() => {
+      doc.batchApplyEncodedState({ origin, updates });
+    }, origin);
+    return doc;
+  }
+};
+
+// src/CrdtNotifier.ts
+import { makeSubject, subscribe } from "wonka";
+var CrdtNotifier = class {
+  constructor() {
+    this.rootSubject = makeSubject();
+    this.subjects = /* @__PURE__ */ new Map();
+  }
+  subject(key) {
+    const subject = this.subjects.get(key);
+    if (subject) {
+      return subject;
+    }
+    const newSubject = makeSubject();
+    this.subjects.set(key, newSubject);
+    return newSubject;
+  }
+  subcribeRoot(callback) {
+    return subscribe(callback)(this.rootSubject.source).unsubscribe;
+  }
+  subscribe(key, callback) {
+    const subject = this.subject(key);
+    return subscribe(callback)(subject.source).unsubscribe;
+  }
+};
+
+// src/EventNotifier.ts
+import { makeSubject as makeSubject2, subscribe as subscribe2 } from "wonka";
+var EventNotifier = class {
+  constructor() {
+    this.subjects = /* @__PURE__ */ new Map();
+  }
+  subject(name) {
+    const subject = this.subjects.get(name);
+    if (subject) return subject;
+    const newSubject = makeSubject2();
+    this.subjects.set(name, newSubject);
+    return newSubject;
+  }
+  subscribe(name, callback) {
+    const subject = this.subject(name);
+    return subscribe2(callback)(subject.source).unsubscribe;
+  }
+};
+
+// src/ListenerManager.ts
+import { makeSubject as makeSubject3, subscribe as subscribe3 } from "wonka";
+var ListenerManager = class {
+  constructor() {
+    this.subjects = {
+      close: makeSubject3(),
+      error: makeSubject3(),
+      message: makeSubject3(),
+      open: makeSubject3()
+    };
+  }
+  subscribe(kind, callback) {
+    var _a;
+    const source = (_a = this.subjects[kind]) == null ? void 0 : _a.source;
+    if (!source) return () => void 0;
+    return subscribe3(callback)(source).unsubscribe;
+  }
+};
+
+// src/PluvRouter.ts
+var PluvRouter = class _PluvRouter {
+  constructor(events) {
+    this._defs = { events: {} };
+    const invalidName = Object.keys(events).find((name) => !this._isValidEventName(name));
+    if (typeof invalidName === "string") {
+      throw new Error(
+        `Invalid event name. Event names must be formatted as valid JavaScript variable names: "${invalidName}"`
+      );
+    }
+    this._defs = { events };
+  }
+  static merge(...routers) {
+    const events = Object.assign(
+      /* @__PURE__ */ Object.create(null),
+      ...routers.map((router) => router._defs.events)
+    );
+    if (Object.keys(events).some((key) => key.startsWith("$"))) {
+      throw new Error('Procedures may not start with "$"');
+    }
+    return new _PluvRouter(events);
+  }
+  _isValidEventName(name) {
+    return /^[a-z_$][a-z0-9_$]*$/gi.test(name);
+  }
+};
+
+// src/StateNotifier.ts
+import { makeSubject as makeSubject4, subscribe as subscribe4 } from "wonka";
+var StateNotifier = class {
+  constructor() {
+    this.subjects = {
+      connection: makeSubject4(),
+      "my-presence": makeSubject4(),
+      myself: makeSubject4(),
+      others: makeSubject4(),
+      "storage-loaded": makeSubject4()
+    };
+  }
+  subscribe(name, callback) {
+    var _a;
+    const source = (_a = this.subjects[name]) == null ? void 0 : _a.source;
+    if (!source) throw new Error(`Could not subscribe to source: ${name}`);
+    return subscribe4(callback)(source).unsubscribe;
+  }
+};
+
+// src/StorageStore.ts
+var StorageStore = class extends AbstractStorageStore {
+  addUpdate() {
+    return Promise.resolve();
+  }
+  applyUpdates() {
+    return Promise.resolve();
+  }
+  destroy() {
+    return Promise.resolve();
+  }
+  flatten() {
+    return Promise.resolve();
+  }
+  getShouldFlatten() {
+    return Promise.resolve(false);
+  }
+  getUpdates() {
+    return Promise.resolve([]);
+  }
+  initialize() {
+    return Promise.resolve();
+  }
+};
+
+// src/utils/debounce.ts
+var debounce = (fn, options) => {
+  const { wait, immediate = false } = options != null ? options : {};
+  let prevResult;
+  let timeout = null;
+  return (...args) => {
+    if (typeof timeout === "number") clearTimeout(timeout);
+    timeout = setTimeout(() => {
+      timeout = null;
+      if (!immediate) prevResult = fn(args);
+    }, wait);
+    if (immediate && !timeout) {
+      fn(args);
+      return;
+    }
+    return prevResult;
+  };
+};
+
+// src/utils/pickBy.ts
+var pickBy = (obj, by) => {
+  const result = {};
+  const keys = Object.keys(obj);
+  for (let i = 0; i < keys.length; ++i) {
+    const key = keys[i];
+    const value = obj[key];
+    if (by(value)) result[key] = value;
+  }
+  return result;
+};
+
+// src/UsersManager.ts
+var UsersManager = class {
+  constructor(config) {
+    this._idMap = {
+      fromConnectionId: /* @__PURE__ */ new Map(),
+      fromClientId: /* @__PURE__ */ new Map()
+    };
+    /**
+     * @description This is only set when the user is connected.
+     */
+    this._myself = null;
+    this._others = /* @__PURE__ */ new Map();
+    this._presence = null;
+    const { initialPresence, limits, presence = null } = config;
+    this.initialPresence = initialPresence;
+    this._limits = limits;
+    this._myPresence = initialPresence;
+    this._presence = presence;
+  }
+  get myPresence() {
+    return this._myPresence;
+  }
+  get myself() {
+    return this._myself;
+  }
+  addConnection(userInfo) {
+    var _a;
+    const cleaned = pickBy((_a = userInfo.presence) != null ? _a : {}, (value) => typeof value !== "undefined");
+    const presence = __spreadValues(__spreadValues({}, this.initialPresence), cleaned);
+    const data = __spreadProps(__spreadValues({}, userInfo), { presence });
+    const myClientId = !!this._myself ? this.getClientId(this._myself) : null;
+    const clientId = this.getClientId(data);
+    const remaining = this._setConnectionId(userInfo.connectionId, clientId).size;
+    if (myClientId === clientId) {
+      const result2 = {
+        clientId,
+        data,
+        isMyself: true,
+        remaining
+      };
+      return result2;
+    }
+    const other = this._others.get(clientId);
+    if (!other) this._others.set(clientId, data);
+    const result = {
+      clientId,
+      data,
+      isMyself: false,
+      remaining
+    };
+    return result;
+  }
+  clearConnections() {
+    this.removeMyself();
+    this._others.clear();
+    this._idMap.fromClientId.clear();
+    this._idMap.fromConnectionId.clear();
+  }
+  deleteConnection(connectionId) {
+    var _a, _b, _c;
+    const clientId = this.getClientId(connectionId);
+    this._deleteConnectionId(connectionId);
+    if (!clientId) return null;
+    const userInfo = (_a = this._others.get(clientId)) != null ? _a : null;
+    if (!userInfo) return null;
+    const remaining = (_c = (_b = this._getConnectionIds(clientId)) == null ? void 0 : _b.size) != null ? _c : 0;
+    const result = {
+      clientId,
+      remaining,
+      data: userInfo
+    };
+    if (!remaining) this._others.delete(clientId);
+    return result;
+  }
+  getClientId(input) {
+    var _a, _b, _c, _d;
+    if (typeof input !== "string") {
+      const userInfo = input;
+      const connectionId2 = userInfo.connectionId;
+      const userId = (_b = (_a = userInfo.user) == null ? void 0 : _a.id) != null ? _b : null;
+      return userId != null ? userId : connectionId2;
+    }
+    const connectionId = input;
+    if (((_c = this._myself) == null ? void 0 : _c.connectionId) === connectionId) {
+      return this.getClientId(this._myself);
+    }
+    const clientId = (_d = this._idMap.fromConnectionId.get(connectionId)) != null ? _d : null;
+    return clientId;
+  }
+  getOther(connectionId) {
+    var _a;
+    const clientId = this.getClientId(connectionId);
+    if (!clientId) return null;
+    return (_a = this._others.get(clientId)) != null ? _a : null;
+  }
+  getOthers() {
+    return Array.from(this._others.values());
+  }
+  patchPresence(connectionId, patch) {
+    var _a;
+    const clientId = this.getClientId(connectionId);
+    const myClientId = !!this._myself ? this.getClientId(this._myself) : null;
+    if (!clientId) return null;
+    if (myClientId === clientId) return this.updateMyPresence(patch);
+    const other = this._others.get(clientId);
+    if (!other) return null;
+    const cleanedPatch = pickBy(patch != null ? patch : {}, (value) => typeof value !== "undefined");
+    const cleanedPresence = pickBy(
+      (_a = other.presence) != null ? _a : {},
+      (value) => typeof value !== "undefined"
+    );
+    const presence = __spreadValues(__spreadValues(__spreadValues({}, this.initialPresence), cleanedPresence), cleanedPatch);
+    const validated = this._presence ? this._presence.parse(presence) : presence;
+    if (!!presence[PLUV_PRESENCE_META_KEY]) {
+      validated[PLUV_PRESENCE_META_KEY] = presence[PLUV_PRESENCE_META_KEY];
+    }
+    this._others.set(clientId, __spreadProps(__spreadValues({}, other), { presence: validated }));
+    return validated;
+  }
+  removeMyself() {
+    if (!this._myself) return;
+    const connectionId = this._myself.connectionId;
+    this._deleteConnectionId(connectionId);
+    this._myself = null;
+  }
+  setMyself(userInfo) {
+    var _a;
+    const connectionId = userInfo.connectionId;
+    const presence = (_a = userInfo.presence) != null ? _a : this.initialPresence;
+    this._myself = __spreadProps(__spreadValues({}, userInfo), { presence });
+    this._myPresence = presence;
+    const clientId = this.getClientId(this._myself);
+    this._setConnectionId(connectionId, clientId);
+  }
+  setPresence(connectionId, presence) {
+    const clientId = this.getClientId(connectionId);
+    const myClientId = !!this._myself ? this.getClientId(this._myself) : null;
+    if (!clientId) return;
+    if (myClientId === clientId) {
+      if (!this._myself) return;
+      this._myself.presence = presence;
+      this._myPresence = presence;
+      return;
+    }
+    const other = this._others.get(clientId);
+    if (!other) return;
+    this._others.set(clientId, __spreadProps(__spreadValues({}, other), { presence }));
+  }
+  /**
+   * @description This method need not care about being connected. This is because a user should
+   * be able to view and update their own presence without being online
+   * @date April 20, 2025
+   */
+  updateMyPresence(patch) {
+    const cleanedPatch = pickBy(patch, (value) => typeof value !== "undefined");
+    const cleanedPresence = pickBy(this._myPresence, (value) => typeof value !== "undefined");
+    const updated = __spreadValues(__spreadValues(__spreadValues({}, this.initialPresence), cleanedPresence), cleanedPatch);
+    const bytes = new TextEncoder().encode(JSON.stringify(updated)).length;
+    if (!!this._limits.presenceMaxSize && bytes > this._limits.presenceMaxSize) {
+      throw new Error(
+        `Large presence. Presence must be at most 512 bytes. Current size: ${bytes.toLocaleString()}`
+      );
+    }
+    this._myPresence = updated;
+    if (!this._myself) return updated;
+    this._myself.presence = updated;
+    return updated;
+  }
+  _deleteConnectionId(connectionId) {
+    var _a;
+    const clientId = this.getClientId(connectionId);
+    this._idMap.fromConnectionId.delete(connectionId);
+    if (!clientId) return;
+    const set = (_a = this._idMap.fromClientId.get(clientId)) != null ? _a : null;
+    if (!set) return;
+    set.delete(connectionId);
+    if (!!set.size) return;
+    this._idMap.fromClientId.delete(clientId);
+  }
+  _getConnectionIds(clientId) {
+    const set = this._idMap.fromClientId.get(clientId);
+    return set != null ? set : null;
+  }
+  _setConnectionId(connectionId, clientId) {
+    var _a;
+    const set = (_a = this._idMap.fromClientId.get(clientId)) != null ? _a : /* @__PURE__ */ new Set();
+    const updated = set.add(connectionId);
+    this._idMap.fromConnectionId.set(connectionId, clientId);
+    this._idMap.fromClientId.set(clientId, updated);
+    return updated;
+  }
+};
+
+// src/UsersNotifier.ts
+import { makeSubject as makeSubject5, subscribe as subscribe5 } from "wonka";
+var UsersNotifier = class {
+  constructor() {
+    this.others = makeSubject5();
+    this._otherSubjects = /* @__PURE__ */ new Map();
+  }
+  clear() {
+    this._otherSubjects.forEach((subject) => {
+      subject.next(null);
+    });
+    this._otherSubjects.clear();
+  }
+  delete(clientId) {
+    this.other(clientId).next(null);
+    this._otherSubjects.delete(clientId);
+  }
+  other(clientId) {
+    const subject = this._otherSubjects.get(clientId);
+    if (subject) return subject;
+    const newSubject = makeSubject5();
+    this._otherSubjects.set(clientId, newSubject);
+    return newSubject;
+  }
+  subscribeOther(clientId, callback) {
+    const source = this.other(clientId).source;
+    const subscription = subscribe5(callback)(source);
+    return subscription.unsubscribe;
+  }
+  subscribeOthers(callback) {
+    const subscription = subscribe5(
+      ({ others, event }) => callback(others, event)
+    )(this.others.source);
+    return subscription.unsubscribe;
+  }
+};
+
+// src/PluvRoom.ts
+var ADD_TO_STORAGE_STATE_DEBOUNCE_MS = 1e3;
+var HEARTBEAT_INTERVAL_MS = 1e4;
+var PONG_TIMEOUT_MS = 2e3;
+var RECONNECT_TIMEOUT_MS = 5e3;
+var MIN_RECONNECT_TIMEOUT_MS = 1e3;
+var MAX_RECONNECT_TIMEOUT_MS = 6e4;
+var ORIGIN_INITIALIZED = "$initialized";
+var ORIGIN_STORAGE_UPDATED = "$storageUpdated";
+var DEFAULT_PLUV_CLIENT_ADDON = (input) => ({
+  storage: new StorageStore(input.room.id)
+});
+var PluvRoom = class {
+  constructor(room, options) {
+    this._crdtNotifier = new CrdtNotifier();
+    this._eventNotifier = new EventNotifier();
+    this._intervals = {
+      heartbeat: null
+    };
+    this._listenerManager = new ListenerManager();
+    this._publicKey = null;
+    this._stateNotifier = new StateNotifier();
+    this._subscriptions = {
+      observeCrdt: null
+    };
+    this._timeouts = {
+      pong: null,
+      reconnect: null
+    };
+    this._usersNotifier = new UsersNotifier();
+    this._lastMetadata = null;
+    this._state = {
+      authorization: {
+        token: null,
+        user: null
+      },
+      connection: {
+        attempts: 0,
+        id: null,
+        state: ConnectionState.Untouched
+      },
+      storage: {
+        state: StorageState.Unavailable
+      },
+      webSocket: null
+    };
+    this._windowListeners = null;
+    this._wsListeners = null;
+    this.broadcast = new Proxy(
+      (event, data) => __async(this, null, function* () {
+        if (!this._state.webSocket) return;
+        if (this._state.connection.state !== ConnectionState.Open) return;
+        const type = event.toString();
+        const procedure = this._router._defs.events[type];
+        if (!(procedure == null ? void 0 : procedure.config.broadcast)) {
+          this._sendMessage({ data, type });
+          return;
+        }
+        const myself = this._usersManager.myself;
+        if (!myself) return;
+        const parsed = procedure.config.input ? procedure.config.input.parse(data) : data;
+        const context = {
+          doc: this._crdtManager.doc,
+          others: this._usersManager.getOthers(),
+          room: this.id,
+          user: myself
+        };
+        const output = yield procedure.config.broadcast(parsed, context);
+        Object.entries(output).forEach(([_type, _data]) => {
+          this._sendMessage({ data: _data, type: _type });
+        });
+      }),
+      {
+        get(fn, prop) {
+          return (data) => __async(null, null, function* () {
+            return yield fn(prop, data);
+          });
+        }
+      }
+    );
+    this.canRedo = () => {
+      return !!this._crdtManager.doc.canRedo();
+    };
+    this.canUndo = () => {
+      return !!this._crdtManager.doc.canUndo();
+    };
+    /**
+     * @deprecated To be removed in v3. Use PluvRoom.subscribe.event instead
+     */
+    this.event = new Proxy(
+      (event, callback) => this._eventNotifier.subscribe(event, callback),
+      {
+        get(fn, prop) {
+          return (callback) => fn(prop, callback);
+        }
+      }
+    );
+    this.getConnection = () => {
+      return Object.freeze(JSON.parse(JSON.stringify(this._state.connection)));
+    };
+    this.getDoc = () => {
+      return this._crdtManager.doc;
+    };
+    this.getMyPresence = () => {
+      return this._usersManager.myPresence;
+    };
+    this.getMyself = () => {
+      return this._usersManager.myself;
+    };
+    this.getOther = (connectionId) => {
+      return this._usersManager.getOther(connectionId);
+    };
+    this.getOthers = () => {
+      return this._usersManager.getOthers();
+    };
+    this.getStorage = (type) => {
+      const sharedType = this._crdtManager.get(type);
+      if (typeof sharedType === "undefined") return null;
+      return sharedType;
+    };
+    this.getStorageLoaded = () => {
+      return this._state.storage.state === StorageState.Offline || this._state.storage.state === StorageState.Synced;
+    };
+    /**
+     * @deprecated To be removed in v3. Use PluvRoom.subscribe.other instead
+     */
+    this.other = (connectionId, callback) => {
+      const clientId = this._usersManager.getClientId(connectionId);
+      if (!clientId) return () => void 0;
+      return this._usersNotifier.subscribeOther(clientId, callback);
+    };
+    this.redo = () => {
+      this._crdtManager.doc.redo();
+    };
+    /**
+     * @deprecated To be removed in v3. Use PluvRoom.subscribe.storage instead
+     */
+    this.storage = new Proxy(
+      (key, callback) => this._crdtNotifier.subscribe(key, callback),
+      {
+        get: (fn, prop) => {
+          if (!!prop) {
+            return (callback) => {
+              return this._crdtNotifier.subcribeRoot(callback);
+            };
+          }
+          return (callback) => {
+            return fn(prop, callback);
+          };
+        }
+      }
+    );
+    /**
+     * @deprecated To be removed in v3. Use PluvRoom.subscribe.storage instead
+     * @description Subscribes to the root storage object (serialized)
+     */
+    this.storageRoot = (callback) => {
+      return this._crdtNotifier.subcribeRoot(callback);
+    };
+    this.subscribe = new Proxy(
+      (name, callback) => this._stateNotifier.subscribe(name, callback),
+      {
+        get: (fn, prop) => {
+          if (prop === "connection") {
+            return (callback) => {
+              return fn("connection", callback);
+            };
+          }
+          if (prop === "myPresence") {
+            return (callback) => {
+              return fn("my-presence", callback);
+            };
+          }
+          if (prop === "myself") {
+            return (callback) => {
+              return fn("myself", callback);
+            };
+          }
+          if (prop === "others") {
+            return (callback) => {
+              return this._usersNotifier.subscribeOthers(callback);
+            };
+          }
+          if (prop === "storageLoaded") {
+            return (callback) => {
+              return fn("storage-loaded", callback);
+            };
+          }
+          if (prop === "event") return this.event;
+          if (prop === "other") return this.other;
+          if (prop === "storage") return this.storage;
+        }
+      }
+    );
+    this.transact = (fn, origin) => {
+      const _origin = origin != null ? origin : this._state.connection.id;
+      if (typeof _origin !== "string") return;
+      this._crdtManager.doc.transact(() => {
+        const storage = this._crdtManager.doc.get();
+        fn(storage);
+      }, _origin);
+    };
+    this.undo = () => {
+      this._crdtManager.doc.undo();
+    };
+    this.updateMyPresence = (presence) => {
+      var _a;
+      const newPresence = typeof presence === "function" ? presence(this.getMyPresence()) : presence;
+      this._usersManager.updateMyPresence(newPresence);
+      const myPresence = this._usersManager.myPresence;
+      const myself = (_a = this._usersManager.myself) != null ? _a : null;
+      this._stateNotifier.subjects["my-presence"].next(myPresence);
+      if (!!myself) this._stateNotifier.subjects.myself.next(myself);
+      this.broadcast(
+        "$updatePresence",
+        { presence: newPresence }
+      );
+    };
+    this._flattenStorageStore = debounce(
+      () => __async(this, null, function* () {
+        const shouldFlatten = yield this._storageStore.getShouldFlatten();
+        if (!shouldFlatten) return;
+        const updates = yield this._storageStore.getUpdates();
+        this._crdtManager.applyUpdate({ update: updates, origin: this });
+        const encodedState = this._crdtManager.doc.getEncodedState();
+        yield this._storageStore.flatten(encodedState);
+      }),
+      { wait: ADD_TO_STORAGE_STATE_DEBOUNCE_MS }
+    );
+    this._getAddon = (addons) => {
+      return addons.reduce(
+        (acc, addon) => () => __spreadValues(__spreadValues({}, acc({ room: this })), addon({ room: this })),
+        DEFAULT_PLUV_CLIENT_ADDON
+      );
+    };
+    const {
+      addons = [],
+      authEndpoint,
+      debug = false,
+      initialPresence,
+      initialStorage,
+      limits,
+      metadata,
+      onAuthorizationFail,
+      presence,
+      publicKey,
+      reconnectTimeoutMs = RECONNECT_TIMEOUT_MS,
+      router,
+      wsEndpoint
+    } = options;
+    this.id = room;
+    this.metadata = metadata;
+    const addon = this._getAddon(addons);
+    const { storage } = __spreadValues(__spreadValues({}, DEFAULT_PLUV_CLIENT_ADDON({ room: this })), addon({ room: this }));
+    this._storageStore = storage;
+    this._debug = debug;
+    this._endpoints = { authEndpoint, wsEndpoint };
+    this._limits = limits;
+    this._reconnectTimeoutMs = reconnectTimeoutMs;
+    if (!!publicKey) this._publicKey = publicKey;
+    this._listeners = {
+      onAuthorizationFail: (error) => {
+        onAuthorizationFail == null ? void 0 : onAuthorizationFail(error);
+      }
+    };
+    this._router = router != null ? router : new PluvRouter({});
+    this._usersManager = new UsersManager({
+      initialPresence,
+      limits: this._limits,
+      presence
+    });
+    this._crdtManager = new CrdtManager({ initialStorage });
+  }
+  /**
+   * @deprecated To be removed in v3. Use `getStorageLoaded` instead.
+   */
+  get storageLoaded() {
+    return this.getStorageLoaded();
+  }
+  get webSocket() {
+    return this._state.webSocket;
+  }
+  addEventListener(kind, handler) {
+    return this._listenerManager.subscribe(kind, handler);
+  }
+  connect(...args) {
+    return __async(this, null, function* () {
+      var _a;
+      const params = (_a = args[0]) != null ? _a : {};
+      const metadata = params.metadata;
+      this._setMetadata(metadata);
+      const canConnect = [
+        ConnectionState.Closed,
+        ConnectionState.Unavailable,
+        ConnectionState.Untouched
+      ].some((state) => this._state.connection.state === state);
+      if (!canConnect) return;
+      this._clearTimeout(this._timeouts.reconnect);
+      this._updateState((oldState) => {
+        oldState.connection.state = ConnectionState.Connecting;
+        return oldState;
+      });
+      yield this._storageStore.initialize();
+      const wsEndpoint = this._getWsEndpoint(this.id, params);
+      const url = new URL(wsEndpoint);
+      let authToken = null;
+      let webSocket;
+      try {
+        const publicKey = this._getPublicKey(params);
+        authToken = yield this._getAuthorization(this.id, params);
+        if (authToken) url.searchParams.set("token", encodeURIComponent(authToken));
+        if (publicKey) url.searchParams.set("public_key", encodeURIComponent(publicKey));
+        webSocket = new WebSocket(url.toString());
+      } catch (err) {
+        this._updateState((oldState) => {
+          oldState.connection.attempts += 1;
+          return oldState;
+        });
+        yield this._storageStore.destroy();
+        this._pollReconnect();
+        yield Promise.resolve(this._onAuthorizationFail(err));
+        return;
+      }
+      this._updateState((oldState) => {
+        oldState.connection.attempts = 0;
+        oldState.authorization.token = authToken;
+        oldState.storage.state = StorageState.Loading;
+        oldState.webSocket = webSocket;
+        return oldState;
+      });
+      this._attachWindowListeners();
+      this._attachWsListeners();
+    });
+  }
+  disconnect() {
+    return __async(this, null, function* () {
+      if (!this._state.webSocket) return;
+      const canDisconnect = [ConnectionState.Connecting, ConnectionState.Open].some(
+        (state) => this._state.connection.state === state
+      );
+      if (!canDisconnect) return;
+      this._closeWs();
+      this._clearInterval(this._intervals.heartbeat);
+      this._clearTimeout(this._timeouts.reconnect);
+      this._updateState((oldState) => {
+        oldState.authorization.token = null;
+        oldState.connection.state = ConnectionState.Closed;
+        oldState.storage.state = oldState.storage.state === StorageState.Synced ? StorageState.Offline : StorageState.Unavailable;
+        oldState.webSocket = null;
+        return oldState;
+      });
+      yield this._storageStore.destroy();
+      this._crdtManager.destroy();
+      this._stateNotifier.subjects["my-presence"].next(null);
+    });
+  }
+  getStorageJson(type) {
+    if (this._state.connection.id === null) return null;
+    if (typeof type === "undefined") return this._crdtManager.doc.toJson();
+    const sharedType = this._crdtManager.get(type);
+    if (typeof sharedType === "undefined") return null;
+    return this._crdtManager.doc.toJson(type);
+  }
+  _addToStorageStore(update) {
+    return __async(this, null, function* () {
+      yield this._storageStore.addUpdate(update);
+      this._flattenStorageStore();
+    });
+  }
+  _attachWindowListeners() {
+    if (typeof window === "undefined") return;
+    if (typeof document === "undefined") return;
+    this._windowListeners = this._windowListeners || {
+      onNavigatorOffline: this._onNavigatorOffline.bind(this),
+      onNavigatorOnline: this._onNavigatorOnline.bind(this),
+      onVisibilityChange: this._onVisibilityChange.bind(this),
+      onWindowFocus: this._onWindowFocus.bind(this)
+    };
+    window.addEventListener("offline", this._windowListeners.onNavigatorOffline);
+    window.addEventListener("online", this._windowListeners.onNavigatorOnline);
+    document.addEventListener("visibilitychange", this._windowListeners.onVisibilityChange);
+    window.addEventListener("focus", this._windowListeners.onWindowFocus);
+  }
+  _attachWsListeners() {
+    if (!this._state.webSocket) return;
+    this._wsListeners = this._wsListeners || {
+      onClose: this._onClose.bind(this),
+      onError: this._onError.bind(this),
+      onMessage: this._onMessage.bind(this),
+      onOpen: this._onOpen.bind(this)
+    };
+    this._state.webSocket.addEventListener("close", this._wsListeners.onClose);
+    this._state.webSocket.addEventListener("error", this._wsListeners.onError);
+    this._state.webSocket.addEventListener("message", this._wsListeners.onMessage);
+    this._state.webSocket.addEventListener("open", this._wsListeners.onOpen);
+  }
+  _clearInterval(interval) {
+    if (Number.isNaN(interval)) return;
+    clearInterval(interval);
+  }
+  _clearTimeout(timeout) {
+    if (Number.isNaN(timeout)) return;
+    clearTimeout(timeout);
+  }
+  _closeWs() {
+    var _a, _b, _c;
+    (_b = (_a = this._subscriptions).observeCrdt) == null ? void 0 : _b.call(_a);
+    this._clearInterval(this._intervals.heartbeat);
+    this._clearTimeout(this._timeouts.pong);
+    this._detachWindowListeners();
+    this._usersManager.removeMyself();
+    this._usersManager.clearConnections();
+    this._usersNotifier.clear();
+    this._stateNotifier.subjects.myself.next(null);
+    this._stateNotifier.subjects.others.next([]);
+    this._usersNotifier.others.next({ others: [], event: { kind: "clear" } });
+    (_c = this._state.webSocket) == null ? void 0 : _c.close();
+    this._detachWsListeners();
+  }
+  _detachWindowListeners() {
+    if (!this._windowListeners) return;
+    if (typeof window === "undefined") return;
+    if (typeof document === "undefined") return;
+    window.removeEventListener("offline", this._windowListeners.onNavigatorOffline);
+    window.removeEventListener("online", this._windowListeners.onNavigatorOnline);
+    document.removeEventListener("visibilitychange", this._windowListeners.onVisibilityChange);
+    window.removeEventListener("focus", this._windowListeners.onWindowFocus);
+    this._windowListeners = null;
+  }
+  _detachWsListeners() {
+    if (!this._state.webSocket || !this._wsListeners) return;
+    this._state.webSocket.removeEventListener("close", this._wsListeners.onClose);
+    this._state.webSocket.removeEventListener("error", this._wsListeners.onError);
+    this._state.webSocket.removeEventListener("message", this._wsListeners.onMessage);
+    this._state.webSocket.removeEventListener("open", this._wsListeners.onOpen);
+    this._wsListeners = null;
+  }
+  _emitSharedTypes() {
+    const sharedTypes = this._crdtManager.doc.get();
+    const storageRoot = Object.keys(sharedTypes).reduce(
+      (acc, prop) => {
+        const serialized = this._crdtManager.doc.toJson(prop);
+        this._crdtNotifier.subject(prop).next(serialized);
+        return __spreadProps(__spreadValues({}, acc), { [prop]: serialized });
+      },
+      {}
+    );
+    this._crdtNotifier.rootSubject.next(storageRoot);
+  }
+  _getAuthFetchOptions(room, params) {
+    const metadata = params.metadata;
+    if (typeof this._endpoints.authEndpoint === "undefined") return null;
+    if (this._endpoints.authEndpoint === true) {
+      return {
+        url: `/api/pluv/authorize?room=${room}`,
+        options: {}
+      };
+    }
+    if (typeof this._endpoints.authEndpoint === "string") {
+      return {
+        url: this._endpoints.authEndpoint,
+        options: {}
+      };
+    }
+    const result = this._endpoints.authEndpoint({ metadata, room });
+    return typeof result === "string" ? { url: result, options: {} } : result;
+  }
+  _getAuthorization(room, params) {
+    return __async(this, null, function* () {
+      const fetchOptions = this._getAuthFetchOptions(room, params);
+      if (!fetchOptions) return null;
+      const { url, options } = fetchOptions;
+      const res = yield fetch(url, options);
+      if (!res.ok || res.status !== 200) throw new Error("Room is unauthorized");
+      try {
+        return yield res.text().then((text) => text.trim());
+      } catch (err) {
+        throw new Error(err instanceof Error ? err.message : "Room is unauthorized");
+      }
+    });
+  }
+  _getPublicKey(params) {
+    const metadata = params.metadata;
+    if (!this._publicKey) return null;
+    if (typeof this._publicKey === "string") return this._publicKey;
+    return this._publicKey({ metadata });
+  }
+  _getWsEndpoint(room, params) {
+    const metadata = params.metadata;
+    switch (typeof this._endpoints.wsEndpoint) {
+      case "undefined":
+        return !!this._getPublicKey(params) ? `wss://rooms.pluv.io/api/room/${room}` : `/api/pluv/room/${room}`;
+      case "string":
+        return this._endpoints.wsEndpoint;
+      default:
+        return this._endpoints.wsEndpoint({ metadata, room });
+    }
+  }
+  _handleExit(message) {
+    const { connectionId } = message;
+    if (!connectionId) return;
+    if (!this._state.webSocket) throw new Error("Could not find WebSocket");
+    const clientId = this._usersManager.getClientId(connectionId);
+    const deleted = this._usersManager.deleteConnection(connectionId);
+    const others = this._usersManager.getOthers();
+    this._stateNotifier.subjects.others.next(others);
+    if (!deleted) {
+      console.warn("Could not identify exited connection");
+      return;
+    }
+    const { data: user, remaining } = deleted;
+    this._usersNotifier.others.next({
+      others,
+      event: { kind: "leave", user }
+    });
+    if (!remaining && !!clientId) this._usersNotifier.delete(clientId);
+  }
+  _handlePresenceUpdatedMessage(message) {
+    var _a;
+    const { connectionId } = message;
+    if (!connectionId) return;
+    if (!this._state.webSocket) throw new Error("Could not find WebSocket");
+    const data = message.data;
+    const myself = (_a = this._usersManager.myself) != null ? _a : null;
+    if ((myself == null ? void 0 : myself.connectionId) === connectionId) return;
+    const updated = this._usersManager.patchPresence(connectionId, data.presence);
+    const myClientId = !!myself ? this._usersManager.getClientId(myself) : null;
+    const clientId = this._usersManager.getClientId(connectionId);
+    if (!!clientId && myClientId === clientId) {
+      this._stateNotifier.subjects["my-presence"].next(updated);
+      this._stateNotifier.subjects.myself.next(this._usersManager.myself);
+      return;
+    }
+    if (!!clientId) {
+      const other2 = this._usersManager.getOther(connectionId);
+      const others2 = this._usersManager.getOthers();
+      this._usersNotifier.other(clientId).next(other2);
+      this._stateNotifier.subjects.others.next(others2);
+      if (!!other2) {
+        this._usersNotifier.others.next({
+          others: others2,
+          event: { kind: "update", user: other2 }
+        });
+      }
+      return;
+    }
+    const added = this._usersManager.addConnection({
+      connectionId,
+      presence: data.presence,
+      user: message.user
+    });
+    const other = this._usersManager.getOther(connectionId);
+    const others = this._usersManager.getOthers();
+    this._usersNotifier.other(added.clientId).next(other);
+    this._stateNotifier.subjects.others.next(others);
+    this._usersNotifier.others.next({
+      others,
+      event: { kind: "update", user: added.data }
+    });
+  }
+  _handleReceiveOthers(message) {
+    if (!message.connectionId) return;
+    if (!this._state.webSocket) throw new Error("Could not find WebSocket");
+    const data = message.data;
+    Object.keys(data.others).forEach((connectionId) => {
+      const { presence, user } = data.others[connectionId];
+      const result = this._usersManager.addConnection({
+        connectionId,
+        presence,
+        user
+      });
+      if (!!presence) this._usersManager.patchPresence(connectionId, presence);
+      if (result.isMyself) return;
+      const clientId = result.clientId;
+      const other = this._usersManager.getOther(connectionId);
+      this._usersNotifier.other(clientId).next(other);
+    });
+    const others = this._usersManager.getOthers();
+    this._stateNotifier.subjects.others.next(others);
+    this._usersNotifier.others.next({
+      others,
+      event: { kind: "sync", users: others }
+    });
+  }
+  _handleRegisteredMessage(message) {
+    return __async(this, null, function* () {
+      var _a, _b, _c;
+      const { connectionId } = message;
+      const user = message.user;
+      if (!connectionId) return;
+      if (!this._state.webSocket) throw new Error("Could not find WebSocket");
+      const data = message.data;
+      const state = data.state;
+      this._updateState((oldState) => {
+        oldState.connection.id = connectionId;
+        oldState.authorization.user = user != null ? user : null;
+        return oldState;
+      });
+      const userInfo = {
+        connectionId,
+        presence: (_a = data.presence) != null ? _a : void 0,
+        user
+      };
+      this._usersManager.setMyself(userInfo);
+      const presence = this._usersManager.myPresence;
+      const myself = (_b = this._usersManager.myself) != null ? _b : null;
+      this._stateNotifier.subjects["my-presence"].next(presence);
+      this._stateNotifier.subjects.myself.next(myself);
+      const update = !state ? (_c = this._crdtManager.resolveEncodedState(yield this._storageStore.getUpdates())) != null ? _c : this._crdtManager.getInitialState() : this._crdtManager.getInitialState();
+      this._sendMessage({
+        type: "$initializeSession",
+        data: { presence, update }
+      });
+    });
+  }
+  _handleStorageReceivedMessage(message) {
+    return __async(this, null, function* () {
+      const { connectionId } = message;
+      if (!connectionId) return;
+      if (!this._state.webSocket) throw new Error("Could not find WebSocket");
+      const data = message.data;
+      const changeKind = data.changeKind;
+      const state = data.state;
+      const updates = yield this._storageStore.getUpdates();
+      const origin = ORIGIN_INITIALIZED;
+      const updateStorage = (update) => {
+        return this._crdtManager.initialized ? this._crdtManager.applyUpdate({ update, origin }) : this._crdtManager.initialize({ update, origin });
+      };
+      if (changeKind === "empty") {
+        this._crdtManager.destroy();
+        this._crdtManager.initialize({ origin, update: updates });
+      } else if (changeKind === "initialized") {
+        if (!!updates.length) updateStorage(updates);
+        else {
+          const encodedState2 = updateStorage(state).doc.getEncodedState();
+          this._addToStorageStore(encodedState2);
+        }
+      } else {
+        const encodedState2 = updateStorage(state).doc.getEncodedState();
+        if (!!updates.length) this._crdtManager.applyUpdate({ update: updates, origin });
+        yield this._addToStorageStore(encodedState2);
+      }
+      const encodedState = this._crdtManager.doc.getEncodedState();
+      this._emitSharedTypes();
+      this._observeCrdt();
+      this._updateState((oldState) => {
+        oldState.storage.state = StorageState.Synced;
+        return oldState;
+      });
+      this._stateNotifier.subjects["storage-loaded"].next(true);
+      this._sendMessage({
+        type: "$updateStorage",
+        data: { origin, update: encodedState }
+      });
+    });
+  }
+  _handleStorageUpdatedMessage(message) {
+    const { connectionId } = message;
+    if (!connectionId) return;
+    if (!this._state.webSocket) throw new Error("Could not find WebSocket");
+    const data = message.data;
+    this._crdtManager.doc.applyEncodedState({
+      origin: ORIGIN_STORAGE_UPDATED,
+      update: data.state
+    });
+    const sharedTypes = this._crdtManager.doc.get();
+    const storageRoot = Object.keys(sharedTypes).reduce(
+      (acc, prop) => {
+        const serialized = this._crdtManager.doc.toJson(prop);
+        this._crdtNotifier.subject(prop).next(serialized);
+        return __spreadProps(__spreadValues({}, acc), { [prop]: serialized });
+      },
+      {}
+    );
+    this._crdtNotifier.rootSubject.next(storageRoot);
+  }
+  _handleSyncStateReceived(message) {
+    var _a;
+    const { connectionId } = message;
+    if (!connectionId) return;
+    if (!this._state.webSocket) throw new Error("Could not find WebSocket");
+    if (!this._usersManager.myself) return;
+    const data = message.data;
+    const active = new Set((_a = data == null ? void 0 : data.connectionIds) != null ? _a : []);
+    const quitters = this._usersManager.getOthers().filter((other) => !active.has(other.connectionId));
+    quitters.forEach((quitter) => {
+      this._usersManager.deleteConnection(quitter.connectionId);
+      const remaining2 = this._usersManager.getOthers();
+      this._usersNotifier.others.next({
+        others: remaining2,
+        event: { kind: "leave", user: quitter }
+      });
+    });
+    const remaining = this._usersManager.getOthers();
+    this._stateNotifier.subjects.others.next(remaining);
+  }
+  _handleUserJoinedMessage(message) {
+    const { connectionId } = message;
+    if (!connectionId) return;
+    if (!this._state.webSocket) throw new Error("Could not find WebSocket");
+    if (!this._usersManager.myself) return;
+    const data = message.data;
+    const myself = this._usersManager.myself;
+    if (myself.connectionId === connectionId) {
+      this._sendMessage({ type: "$getOthers", data: {} });
+      return;
+    }
+    const added = this._usersManager.addConnection({
+      connectionId,
+      presence: data.presence,
+      user: data.user
+    });
+    const other = this._usersManager.getOther(connectionId);
+    const others = this._usersManager.getOthers();
+    this._usersNotifier.other(added.clientId).next(other);
+    this._stateNotifier.subjects.others.next(others);
+    this._usersNotifier.others.next({
+      others,
+      event: { kind: "enter", user: added.data }
+    });
+  }
+  _heartbeat() {
+    this._clearTimeout(this._timeouts.pong);
+    this._timeouts.pong = setTimeout(
+      this._reconnect.bind(this),
+      PONG_TIMEOUT_MS
+    );
+    this._sendMessage('{"type":"$ping","data":{}}');
+  }
+  _logDebug(...data) {
+    var _a;
+    if (typeof process === "undefined") return;
+    if (((_a = process.env) == null ? void 0 : _a.NODE_ENV) === "production") return;
+    if (this._debug) console.log(...data);
+  }
+  _observeCrdt() {
+    var _a, _b;
+    (_b = (_a = this._subscriptions).observeCrdt) == null ? void 0 : _b.call(_a);
+    const unsubscribe = this._crdtManager.doc.subscribe((event) => {
+      var _a2;
+      const origin = (_a2 = event.origin) != null ? _a2 : null;
+      this._emitSharedTypes();
+      if (origin === ORIGIN_INITIALIZED || origin === ORIGIN_STORAGE_UPDATED) {
+        return;
+      }
+      this._addToStorageStore(event.update);
+      if (!this._state.webSocket) return;
+      if (!this._state.connection.id) return;
+      if (this._state.webSocket.readyState !== WebSocket.OPEN) return;
+      this._sendMessage({
+        type: "$updateStorage",
+        data: { origin, update: event.update }
+      });
+    });
+    this._subscriptions.observeCrdt = unsubscribe;
+  }
+  _onAuthorizationFail(error) {
+    const authError = error instanceof Error ? error : new Error("Authorization failed");
+    this._listeners.onAuthorizationFail(authError);
+    this._updateState((oldState) => {
+      oldState.connection.state = ConnectionState.Unavailable;
+      oldState.storage.state = StorageState.Unavailable;
+      return oldState;
+    });
+  }
+  _onClose(event) {
+    return __async(this, null, function* () {
+      this._listenerManager.subjects.close.next(event);
+      this._logDebug("WebSocket closed");
+      if (!!event.reason) this._logDebug(event.reason);
+      const shouldRetry = [
+        // Going away: Client/server is shutting down or navigating
+        1001,
+        // Abnormal closure: Usually network error
+        1006,
+        // Internal error: may be a larger problem, but try reconnecting for now
+        1011,
+        // Service restart: Server restarted
+        1012,
+        // Try again later: server overloaded
+        1013,
+        // Bad gateway
+        1014
+      ].some((okToRetryCode) => event.code === okToRetryCode);
+      this._updateState((oldState) => {
+        oldState.authorization.token = null;
+        oldState.connection.state = shouldRetry ? ConnectionState.Unavailable : (
+          /**
+           * !HACK
+           * @description Assume these are not recoverable. We're just going to mark this
+           * as Closed to avoid reconnect attempts.
+           * @date April 28, 2025
+           */
+          ConnectionState.Closed
+        );
+        oldState.storage.state = oldState.storage.state === StorageState.Synced ? StorageState.Offline : StorageState.Unavailable;
+        oldState.webSocket = null;
+        return oldState;
+      });
+      if (shouldRetry) {
+        yield this._reconnect();
+        return;
+      }
+      this._closeWs();
+      this._clearTimeout(this._timeouts.reconnect);
+    });
+  }
+  /**
+   * TODO
+   * @description Handle websocket errors in a meaningful way, should they occur
+   * @date August 19, 2022
+   */
+  _onError(event) {
+    this._listenerManager.subjects.error.next(event);
+  }
+  _onMessage(event) {
+    this._listenerManager.subjects.message.next(event);
+    const message = this._parseMessage(event);
+    if (!message) return;
+    const shouldLog = typeof this._debug === "boolean" ? this._debug : this._debug.output.find((value) => value === message.type);
+    if (shouldLog) {
+      this._logDebug("WebSocket event received: ", message.type, message);
+    }
+    this._eventNotifier.subject(message.type).next(message);
+    switch (message.type) {
+      case "$exit": {
+        this._handleExit(message);
+        return;
+      }
+      case "$othersReceived": {
+        this._handleReceiveOthers(message);
+        return;
+      }
+      case "$pong": {
+        this._clearTimeout(this._timeouts.pong);
+        return;
+      }
+      case "$presenceUpdated": {
+        this._handlePresenceUpdatedMessage(message);
+        return;
+      }
+      case "$registered": {
+        this._handleRegisteredMessage(message);
+        return;
+      }
+      case "$storageReceived": {
+        this._handleStorageReceivedMessage(message);
+        return;
+      }
+      case "$storageUpdated": {
+        this._handleStorageUpdatedMessage(message);
+        return;
+      }
+      case "$syncStateReceived": {
+        this._handleSyncStateReceived(message);
+        return;
+      }
+      case "$userJoined": {
+        this._handleUserJoinedMessage(message);
+        return;
+      }
+      default:
+    }
+  }
+  _onOpen(event) {
+    this._listenerManager.subjects.open.next(event);
+    if (this._state.connection.state !== ConnectionState.Connecting) return;
+    this._logDebug("WebSocket connected");
+    this._updateState((oldState) => {
+      oldState.connection.state = ConnectionState.Open;
+      return oldState;
+    });
+    this._clearInterval(this._intervals.heartbeat);
+    this._intervals.heartbeat = setInterval(
+      this._heartbeat.bind(this),
+      HEARTBEAT_INTERVAL_MS
+    );
+  }
+  _onNavigatorOffline() {
+    return __async(this, null, function* () {
+      if (this._state.connection.state === ConnectionState.Closed) return;
+      this._updateState((oldState) => {
+        oldState.connection.state = ConnectionState.Unavailable;
+        oldState.storage.state = oldState.storage.state === StorageState.Synced ? StorageState.Offline : StorageState.Unavailable;
+        return oldState;
+      });
+    });
+  }
+  _onNavigatorOnline() {
+    return __async(this, null, function* () {
+      if (this._state.connection.state !== ConnectionState.Unavailable) return;
+      yield this._reconnect();
+    });
+  }
+  _onVisibilityChange() {
+    return __async(this, null, function* () {
+      if (typeof document === "undefined") return;
+      if (document.visibilityState !== "visible") return;
+      switch (this._state.connection.state) {
+        case ConnectionState.Open: {
+          this._clearInterval(this._intervals.heartbeat);
+          setInterval(this._heartbeat.bind(this), HEARTBEAT_INTERVAL_MS);
+          return;
+        }
+        case ConnectionState.Unavailable: {
+          yield this._reconnect();
+          return;
+        }
+        default:
+      }
+    });
+  }
+  _onWindowFocus() {
+    return __async(this, null, function* () {
+      return yield this._onVisibilityChange();
+    });
+  }
+  _parseMessage(message) {
+    if (typeof message.data !== "string") return null;
+    try {
+      const config = JSON.parse(message.data);
+      if (typeof config !== "object") return null;
+      if (typeof config.type !== "string") return null;
+      if (typeof config.data !== "object") return null;
+      return config;
+    } catch (e) {
+      return null;
+    }
+  }
+  _pollReconnect() {
+    this._clearTimeout(this._timeouts.reconnect);
+    const timeoutMs = typeof this._reconnectTimeoutMs === "number" ? this._reconnectTimeoutMs : this._reconnectTimeoutMs({ attempts: this._state.connection.attempts });
+    const clampedMs = Math.max(
+      Math.min(MIN_RECONNECT_TIMEOUT_MS, timeoutMs),
+      MAX_RECONNECT_TIMEOUT_MS
+    );
+    this._timeouts.reconnect = setTimeout(
+      this._reconnect.bind(this),
+      clampedMs
+    );
+  }
+  _reconnect() {
+    return __async(this, null, function* () {
+      this._closeWs();
+      if (this._state.connection.state === ConnectionState.Closed) return;
+      const metadata = this._lastMetadata;
+      const params = typeof metadata === "undefined" ? [] : [{ metadata }];
+      yield this.connect(...params);
+    });
+  }
+  _sendMessage(data) {
+    const webSocket = this._state.webSocket;
+    if ((webSocket == null ? void 0 : webSocket.readyState) !== WebSocket.OPEN) return;
+    const dataType = (() => {
+      var _a, _b, _c;
+      if (typeof data === "object") return (_a = data.type) != null ? _a : null;
+      if (typeof data !== "string") return null;
+      try {
+        return (_c = (_b = JSON.parse(data)) == null ? void 0 : _b.type) != null ? _c : null;
+      } catch (e) {
+        return null;
+      }
+    })();
+    const shouldLog = typeof this._debug === "boolean" ? this._debug : !dataType ? false : this._debug.input.some((value) => value === data.type);
+    if (shouldLog) this._logDebug("WebSocket event sent: ", data.type, data);
+    const message = typeof data === "string" ? data : JSON.stringify(data);
+    webSocket.send(message);
+  }
+  _setMetadata(metadata) {
+    const parsed = this.metadata ? this.metadata.parse(metadata) : metadata;
+    this._lastMetadata = parsed;
+    return parsed;
+  }
+  _updateState(updater) {
+    let authorization;
+    try {
+      authorization = JSON.parse(JSON.stringify(this._state.authorization));
+    } catch (e) {
+      throw new Error("User is not JSON serializable");
+    }
+    const oldState = __spreadProps(__spreadValues({}, this._state), {
+      authorization,
+      connection: JSON.parse(JSON.stringify(this._state.connection)),
+      storage: JSON.parse(JSON.stringify(this._state.storage)),
+      webSocket: this._state.webSocket
+    });
+    const newState = updater(oldState);
+    this._state = newState;
+    this._logDebug("WebSocket new state: ", newState);
+    this._stateNotifier.subjects.connection.next(newState);
+    return newState;
+  }
+};
+
+// src/PluvClient.ts
+var PluvClient = class {
+  constructor(options) {
+    this._publicKey = null;
+    this._rooms = /* @__PURE__ */ new Map();
+    this.createRoom = (room, options = {}) => {
+      var _a, _b;
+      const oldRoom = this.getRoom(room);
+      if (oldRoom) return oldRoom;
+      const newRoom = new PluvRoom(room, {
+        addons: options.addons,
+        authEndpoint: this._authEndpoint,
+        debug: options.debug,
+        initialPresence: options.initialPresence,
+        initialStorage: (_a = options.initialStorage) != null ? _a : this._initialStorage,
+        limits: this._limits,
+        metadata: this.metadata,
+        onAuthorizationFail: options.onAuthorizationFail,
+        presence: this._presence,
+        publicKey: (_b = this._publicKey) != null ? _b : void 0,
+        reconnectTimeoutMs: options.reconnectTimeoutMs,
+        router: options.router,
+        wsEndpoint: this._wsEndpoint
+      });
+      this._rooms.set(room, newRoom);
+      this._logDebug(`New room was created: ${room}`);
+      return newRoom;
+    };
+    this.enter = (room, ...args) => __async(this, null, function* () {
+      const toEnter = typeof room === "string" ? this.getRoom(room) : room;
+      if (!toEnter) throw new Error(`Could not find room: ${room}.`);
+      this._rooms.set(toEnter.id, toEnter);
+      yield toEnter.connect(...args);
+      this._logDebug(`Entered room: ${room}`);
+      return toEnter;
+    });
+    this.getRoom = (room) => {
+      const found = this._rooms.get(room);
+      return found != null ? found : null;
+    };
+    this.getRooms = () => {
+      return Array.from(this._rooms.values());
+    };
+    this.leave = (room) => __async(this, null, function* () {
+      const toLeave = typeof room === "string" ? this.getRoom(room) : room;
+      if (!toLeave) return;
+      yield toLeave.disconnect();
+      this._rooms.delete(toLeave.id);
+      this._logDebug(`Left and deleted room: ${room}`);
+    });
+    const {
+      authEndpoint,
+      debug = false,
+      initialStorage,
+      limits,
+      metadata,
+      presence,
+      publicKey,
+      wsEndpoint
+    } = options;
+    this.metadata = metadata;
+    this._authEndpoint = authEndpoint;
+    this._debug = debug;
+    this._initialStorage = initialStorage;
+    this._limits = __spreadValues({
+      presenceMaxSize: MAX_PRESENCE_SIZE_BYTES
+    }, limits);
+    this._presence = presence;
+    this._wsEndpoint = wsEndpoint;
+    if (!!publicKey) this._publicKey = publicKey;
+  }
+  get _defs() {
+    return {
+      initialStorage: this._initialStorage
+    };
+  }
+  get procedure() {
+    return new PluvProcedure();
+  }
+  router(events) {
+    const invalidName = Object.keys(events).find((name) => name.includes("$"));
+    if (typeof invalidName === "string") {
+      throw new Error(`Invalid event name. Event names must not contain $: "${invalidName}"`);
+    }
+    return new PluvRouter(events);
+  }
+  _logDebug(...data) {
+    var _a;
+    if (typeof process === "undefined") return;
+    if (((_a = process.env) == null ? void 0 : _a.NODE_ENV) === "production") return;
+    if (this._debug) console.log(...data);
+  }
+};
+
+// src/createClient.ts
+var createClient = (options) => {
+  return new PluvClient(options);
+};
+
+// src/infer.ts
+var infer = (callback) => callback;
+
+// src/MockedRoom.ts
+import { ConnectionState as ConnectionState2, StorageState as StorageState2 } from "@pluv/types";
+var MockedRoom = class {
+  constructor(room, options) {
+    /**
+     * @deprecated To be removed in v3. Use `getStorageLoaded` instead.
+     */
+    this.storageLoaded = true;
+    this._crdtNotifier = new CrdtNotifier();
+    this._eventNotifier = new EventNotifier();
+    this._usersNotifier = new UsersNotifier();
+    this._state = {
+      authorization: {
+        token: null,
+        user: null
+      },
+      connection: {
+        attempts: 0,
+        id: null,
+        state: ConnectionState2.Untouched
+      },
+      storage: {
+        state: StorageState2.Unavailable
+      },
+      webSocket: null
+    };
+    this._stateNotifier = new StateNotifier();
+    this._subscriptions = {
+      observeCrdt: null
+    };
+    this.broadcast = new Proxy(
+      (event, data) => __async(this, null, function* () {
+        if (!this._state.webSocket) return;
+        if (this._state.connection.state !== ConnectionState2.Open) return;
+        const type = event.toString();
+        const procedure = this._router._defs.events[type];
+        if (!(procedure == null ? void 0 : procedure.config.broadcast)) {
+          this._simulateEvent(type, data);
+          return;
+        }
+        const myself = this._usersManager.myself;
+        if (!myself) return;
+        const parsed = procedure.config.input ? procedure.config.input.parse(data) : data;
+        const context = {
+          doc: this._crdtManager.doc,
+          others: this._usersManager.getOthers(),
+          room: this.id,
+          user: myself
+        };
+        const output = yield procedure.config.broadcast(parsed, context);
+        Object.entries(output).forEach(([_type, _data]) => {
+          this._simulateEvent(_type, _data);
+        });
+      }),
+      {
+        get(fn, prop) {
+          return (data) => __async(null, null, function* () {
+            return yield fn(prop, data);
+          });
+        }
+      }
+    );
+    this.canRedo = () => {
+      return !!this._crdtManager.doc.canRedo();
+    };
+    this.canUndo = () => {
+      return !!this._crdtManager.doc.canUndo();
+    };
+    this.event = new Proxy(
+      (event, callback) => this._eventNotifier.subscribe(event, callback),
+      {
+        get(fn, prop) {
+          return (callback) => fn(prop, callback);
+        }
+      }
+    );
+    this.getConnection = () => {
+      return Object.freeze(JSON.parse(JSON.stringify(this._state.connection)));
+    };
+    this.getMyPresence = () => {
+      return this._usersManager.myPresence;
+    };
+    this.getMyself = () => {
+      return this._usersManager.myself;
+    };
+    this.getOther = (connectionId) => {
+      return this._usersManager.getOther(connectionId);
+    };
+    this.getOthers = () => {
+      return this._usersManager.getOthers();
+    };
+    this.getStorage = (type) => {
+      const sharedType = this._crdtManager.get(type);
+      if (typeof sharedType === "undefined") return null;
+      return sharedType;
+    };
+    this.other = (connectionId, callback) => {
+      const clientId = this._usersManager.getClientId(connectionId);
+      if (!clientId) return () => void 0;
+      return this._usersNotifier.subscribeOther(clientId, callback);
+    };
+    this.redo = () => {
+      this._crdtManager.doc.redo();
+    };
+    this.storage = new Proxy(
+      (key, callback) => this._crdtNotifier.subscribe(key, callback),
+      {
+        get: (fn, prop) => {
+          if (!!prop) {
+            return (callback) => {
+              return this._crdtNotifier.subcribeRoot(callback);
+            };
+          }
+          return (callback) => {
+            return fn(prop, callback);
+          };
+        }
+      }
+    );
+    this.storageRoot = (fn) => {
+      return this._crdtNotifier.subcribeRoot(fn);
+    };
+    this.subscribe = new Proxy(
+      (name, callback) => {
+        return this._stateNotifier.subscribe(name, callback);
+      },
+      {
+        get: (fn, prop) => {
+          if (prop === "connection") {
+            return (callback) => {
+              return fn("connection", callback);
+            };
+          }
+          if (prop === "myPresence") {
+            return (callback) => {
+              return fn("my-presence", callback);
+            };
+          }
+          if (prop === "myself") {
+            return (callback) => {
+              return fn("myself", callback);
+            };
+          }
+          if (prop === "others") {
+            return (callback) => {
+              return this._usersNotifier.subscribeOthers(callback);
+            };
+          }
+          if (prop === "storageLoaded") {
+            return (callback) => {
+              return fn("storage-loaded", callback);
+            };
+          }
+          if (prop === "event") return this.event;
+          if (prop === "other") return this.other;
+          if (prop === "storage") return this.storage;
+        }
+      }
+    );
+    this.transact = (fn, origin) => {
+      const _origin = origin != null ? origin : this._state.connection.id;
+      const crdtManager = this._crdtManager;
+      if (typeof _origin !== "string") return;
+      if (!crdtManager) return;
+      crdtManager.doc.transact(() => {
+        const storage = crdtManager.doc.get();
+        fn(storage);
+      }, _origin);
+    };
+    this.undo = () => {
+      this._crdtManager.doc.undo();
+    };
+    this.updateMyPresence = (presence) => {
+      var _a;
+      const newPresence = typeof presence === "function" ? presence(this.getMyPresence()) : presence;
+      this._usersManager.updateMyPresence(newPresence);
+      const myPresence = this._usersManager.myPresence;
+      const myself = (_a = this._usersManager.myself) != null ? _a : null;
+      this._stateNotifier.subjects["my-presence"].next(myPresence);
+      if (!!myself) this._stateNotifier.subjects["myself"].next(myself);
+    };
+    const { events, initialPresence, initialStorage, limits, presence, router } = options;
+    this.id = room;
+    this._events = events;
+    this._limits = __spreadValues({
+      presenceMaxSize: MAX_PRESENCE_SIZE_BYTES
+    }, limits);
+    this._router = router != null ? router : new PluvRouter({});
+    this._usersManager = new UsersManager({
+      initialPresence,
+      limits: this._limits,
+      presence
+    });
+    this._crdtManager = new CrdtManager({
+      initialStorage
+    });
+    this._observeCrdt();
+  }
+  addEventListener(kind, handler) {
+    return () => void 0;
+  }
+  getDoc() {
+    return this._crdtManager.doc;
+  }
+  getStorageJson(type) {
+    if (this._state.connection.id === null) return null;
+    if (typeof type === "undefined") return this._crdtManager.doc.toJson();
+    return this._crdtManager.doc.toJson(type);
+  }
+  getStorageLoaded() {
+    return true;
+  }
+  _observeCrdt() {
+    var _a, _b;
+    (_b = (_a = this._subscriptions).observeCrdt) == null ? void 0 : _b.call(_a);
+    if (!this._crdtManager) return;
+    const unsubscribe = this._crdtManager.doc.subscribe((event) => {
+      var _a2;
+      const origin = (_a2 = event.origin) != null ? _a2 : null;
+      if (!this._crdtManager) return;
+      if (origin === "$storageUpdated") return;
+      const sharedTypes = this._crdtManager.doc.get();
+      const storageRoot = Object.keys(sharedTypes).reduce(
+        (acc, prop) => {
+          if (!this._crdtManager) return acc;
+          const serialized = this._crdtManager.doc.toJson(prop);
+          this._crdtNotifier.subject(prop).next(serialized);
+          return __spreadProps(__spreadValues({}, acc), { [prop]: serialized });
+        },
+        {}
+      );
+      this._crdtNotifier.rootSubject.next(storageRoot);
+    });
+    this._subscriptions.observeCrdt = unsubscribe;
+  }
+  _simulateEvent(event, data) {
+    if (!this._events) return;
+    const type = event.toString();
+    const resolver = this._events[type];
+    if (!resolver) return;
+    const result = resolver(data);
+    Object.keys(result).forEach((type2) => {
+      const _type = type2.toString();
+      const data2 = result[_type];
+      if (!data2) return;
+      this._eventNotifier.subject(_type).next(data2);
+    });
+  }
+};
+
+// src/register.ts
+var register = (params) => {
+  const { authEndpoint, publicKey } = params;
+  const wsEndpoint = ({ room }) => `wss://connect.pluv.io/api/room?room=${room}`;
+  return {
+    authEndpoint,
+    publicKey,
+    wsEndpoint
+  };
+};
+export {
+  AbstractStorageStore,
+  ConnectionState3 as ConnectionState,
+  MockedRoom,
+  PluvClient,
+  PluvRoom,
+  createClient,
+  infer,
+  register
+};