@pluv/client 3.2.2 → 4.0.0

package/dist/index.mjs

@@ -1,1917 +1,1790 @@
-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 __typeError = (msg) => {
-  throw TypeError(msg);
-};
-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 __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
-var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
-var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-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";
+import { ConnectionState, ConnectionState as ConnectionState$1, StorageState } from "@pluv/types";
+import { noop } from "@pluv/crdt";
+import { makeSubject, subscribe } from "wonka";
 
-// src/AbstractStorageStore.ts
+//#region src/AbstractStorageStore.ts
 var AbstractStorageStore = class {
-  constructor(room) {
-    this.room = room;
-  }
+	constructor(room) {
+		this.room = room;
+	}
 };
 
-// src/constants.ts
-var MAX_PRESENCE_SIZE_BYTES = 512;
-var PLUV_PRESENCE_META_KEY = "__pluv";
+//#endregion
+//#region src/constants.ts
+const MAX_PRESENCE_SIZE_BYTES = 512;
+const 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);
-    };
-  }
+//#endregion
+//#region src/PluvProcedure.ts
+var PluvProcedure = class PluvProcedure {
+	get config() {
+		return {
+			broadcast: this._broadcast?.bind(this) ?? null,
+			input: this._input ?? null,
+			resolver: this._resolver()
+		};
+	}
+	constructor(config = {}) {
+		this._broadcast = null;
+		this._input = null;
+		const { broadcast, input } = config;
+		this._broadcast = broadcast ?? null;
+		this._input = input ?? null;
+	}
+	broadcast(resolver) {
+		const { broadcast } = this.config;
+		if (!!broadcast) throw new Error("Broadcast was already defined for this procedure");
+		return new PluvProcedure({
+			...this.config,
+			broadcast: resolver
+		});
+	}
+	input(input) {
+		return new PluvProcedure({ input });
+	}
+	_resolver() {
+		return (data, context) => this._broadcast?.(data, context);
+	}
 };
 
-// src/PluvRoom.ts
-import { ConnectionState, StorageState } from "@pluv/types";
-
-// src/CrdtManager.ts
-import { noop } from "@pluv/crdt";
+//#endregion
+//#region src/CrdtManager.ts
 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;
-  }
+	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;
+		/**
+		* !HACK
+		* @description If the doc was already initialized, we don't want to re-initialize
+		* the doc and overwrite what's already there. Skip the initialization and log a
+		* warning.
+		* @date May 7, 2025
+		*/
+		if (this.initialized) {
+			console.warn("Attempted to initialize storage multiple times");
+			return this;
+		}
+		/**
+		* !HACK
+		* @description If the doc is already populated, somehow we're attempting to overwrite
+		* a doc that was presumably initialized but not identified as initialized. Skip the
+		* initialization and log a warning.
+		* @date May 7, 2025
+		*/
+		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";
+//#endregion
+//#region src/CrdtNotifier.ts
 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;
-  }
+	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";
+//#endregion
+//#region src/EventNotifier.ts
 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;
-  }
+	constructor() {
+		this.subjects = /* @__PURE__ */ new Map();
+	}
+	subject(name) {
+		const subject = this.subjects.get(name);
+		if (subject) return subject;
+		const newSubject = makeSubject();
+		this.subjects.set(name, newSubject);
+		return newSubject;
+	}
+	subscribe(name, callback) {
+		const subject = this.subject(name);
+		return subscribe(callback)(subject.source).unsubscribe;
+	}
 };
 
-// src/ListenerManager.ts
-import { makeSubject as makeSubject3, subscribe as subscribe3 } from "wonka";
+//#endregion
+//#region src/ListenerManager.ts
 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;
-  }
+	constructor() {
+		this.subjects = {
+			close: makeSubject(),
+			error: makeSubject(),
+			message: makeSubject(),
+			open: makeSubject()
+		};
+	}
+	subscribe(kind, callback) {
+		const source = this.subjects[kind]?.source;
+		if (!source) return () => void 0;
+		return subscribe(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);
-  }
+//#endregion
+//#region 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(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";
+//#endregion
+//#region src/StateNotifier.ts
 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;
-  }
+	constructor() {
+		this.subjects = {
+			connection: makeSubject(),
+			"my-presence": makeSubject(),
+			myself: makeSubject(),
+			others: makeSubject(),
+			"storage-loaded": makeSubject()
+		};
+	}
+	subscribe(name, callback) {
+		const source = this.subjects[name]?.source;
+		if (!source) throw new Error(`Could not subscribe to source: ${name}`);
+		return subscribe(callback)(source).unsubscribe;
+	}
 };
 
-// src/StorageStore.ts
+//#endregion
+//#region 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();
-  }
+	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;
-  };
+//#endregion
+//#region src/utils/debounce.ts
+const debounce = (fn, options) => {
+	const { wait, immediate = false } = 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;
+//#endregion
+//#region src/utils/pickBy.ts
+const 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
+//#endregion
+//#region 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;
-  }
+	constructor(config) {
+		this._idMap = {
+			fromConnectionId: /* @__PURE__ */ new Map(),
+			fromClientId: /* @__PURE__ */ new Map()
+		};
+		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) {
+		/**
+		* @description Ensure that the presence is complete, so that it does not fail schema
+		* validation
+		* @date April 20, 2025
+		*/
+		const cleaned = pickBy(userInfo.presence ?? {}, (value) => typeof value !== "undefined");
+		const presence = {
+			...this.initialPresence,
+			...cleaned
+		};
+		const data = {
+			...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) return {
+			clientId,
+			data,
+			isMyself: true,
+			remaining
+		};
+		/**
+		* !HACK
+		* @description Don't override the other user, so that we ensure the user's presence isn't
+		* overwritten by whatever incoming connection.
+		* @date April 16, 2025
+		*/
+		if (!this._others.get(clientId)) this._others.set(clientId, data);
+		return {
+			clientId,
+			data,
+			isMyself: false,
+			remaining
+		};
+	}
+	clearConnections() {
+		this.removeMyself();
+		this._others.clear();
+		this._idMap.fromClientId.clear();
+		this._idMap.fromConnectionId.clear();
+	}
+	deleteConnection(connectionId) {
+		const clientId = this.getClientId(connectionId);
+		this._deleteConnectionId(connectionId);
+		if (!clientId) return null;
+		const userInfo = this._others.get(clientId) ?? null;
+		if (!userInfo) return null;
+		const remaining = this._getConnectionIds(clientId)?.size ?? 0;
+		const result = {
+			clientId,
+			remaining,
+			data: userInfo
+		};
+		/**
+		* @description A user may have multiple websocket connections open. If one connection is
+		* dropped, the user may still be connected via another websocket (e.g. on anther browser
+		* tab). In this case, we just want to remove the connection mapping for the connection
+		* that is dropped, but keep the remaining connections and the user.
+		* @date April 16, 2025
+		*/
+		if (!remaining) this._others.delete(clientId);
+		return result;
+	}
+	getClientId(input) {
+		if (typeof input !== "string") {
+			const userInfo = input;
+			const connectionId$1 = userInfo.connectionId;
+			return userInfo.user?.id ?? null ?? connectionId$1;
+		}
+		const connectionId = input;
+		if (this._myself?.connectionId === connectionId) return this.getClientId(this._myself);
+		return this._idMap.fromConnectionId.get(connectionId) ?? null;
+	}
+	getOther(connectionId) {
+		const clientId = this.getClientId(connectionId);
+		if (!clientId) return null;
+		return this._others.get(clientId) ?? null;
+	}
+	getOthers() {
+		return Array.from(this._others.values());
+	}
+	patchPresence(connectionId, patch) {
+		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 ?? {}, (value) => typeof value !== "undefined");
+		const cleanedPresence = pickBy(other.presence ?? {}, (value) => typeof value !== "undefined");
+		const presence = {
+			...this.initialPresence,
+			...cleanedPresence,
+			...cleanedPatch
+		};
+		const validated = this._presence ? this._presence.parse(presence) : presence;
+		/**
+		* !HACK
+		* @description We're patching internal metadata back into the presence field so it doesn't
+		* get stripped from validation
+		* @date May 13, 2025
+		*/
+		if (!!presence[PLUV_PRESENCE_META_KEY]) validated[PLUV_PRESENCE_META_KEY] = presence[PLUV_PRESENCE_META_KEY];
+		this._others.set(clientId, {
+			...other,
+			presence: validated
+		});
+		return validated;
+	}
+	removeMyself() {
+		if (!this._myself) return;
+		const connectionId = this._myself.connectionId;
+		this._deleteConnectionId(connectionId);
+		this._myself = null;
+	}
+	setMyself(userInfo) {
+		const connectionId = userInfo.connectionId;
+		const presence = userInfo.presence ?? this.initialPresence;
+		this._myself = {
+			...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, {
+			...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 = {
+			...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) {
+		const clientId = this.getClientId(connectionId);
+		this._idMap.fromConnectionId.delete(connectionId);
+		if (!clientId) return;
+		const set = this._idMap.fromClientId.get(clientId) ?? null;
+		if (!set) return;
+		set.delete(connectionId);
+		if (!!set.size) return;
+		this._idMap.fromClientId.delete(clientId);
+	}
+	_getConnectionIds(clientId) {
+		return this._idMap.fromClientId.get(clientId) ?? null;
+	}
+	_setConnectionId(connectionId, clientId) {
+		const updated = (this._idMap.fromClientId.get(clientId) ?? /* @__PURE__ */ new 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";
+//#endregion
+//#region src/UsersNotifier.ts
 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;
-  }
+	constructor() {
+		this.others = makeSubject();
+		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 = makeSubject();
+		this._otherSubjects.set(clientId, newSubject);
+		return newSubject;
+	}
+	subscribeOther(clientId, callback) {
+		const source = this.other(clientId).source;
+		return subscribe(callback)(source).unsubscribe;
+	}
+	subscribeOthers(callback) {
+		return subscribe(({ others, event }) => callback(others, event))(this.others.source).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 __storage;
+//#endregion
+//#region src/PluvRoom.ts
+const ADD_TO_STORAGE_STATE_DEBOUNCE_MS = 1e3;
+const HEARTBEAT_INTERVAL_MS = 1e4;
+const PONG_TIMEOUT_MS = 2e3;
+const RECONNECT_TIMEOUT_MS = 5e3;
+const MIN_RECONNECT_TIMEOUT_MS = 1e3;
+const MAX_RECONNECT_TIMEOUT_MS = 6e4;
+const ORIGIN_INITIALIZED = "$initialized";
+const ORIGIN_STORAGE_UPDATED = "$storageUpdated";
+const 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();
-    };
-    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;
-    };
-    this.redo = () => {
-      this._crdtManager.doc.redo();
-    };
-    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 __privateGet(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._event = new Proxy(
-      (event, callback) => this._eventNotifier.subscribe(event, callback),
-      {
-        get(fn, prop) {
-          return (callback) => fn(prop, callback);
-        }
-      }
-    );
-    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
-      );
-    };
-    this._other = (connectionId, callback) => {
-      const clientId = this._usersManager.getClientId(connectionId);
-      if (!clientId) return () => void 0;
-      return this._usersNotifier.subscribeOther(clientId, callback);
-    };
-    __privateAdd(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);
-          };
-        }
-      }
-    ));
-    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 });
-  }
-  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;
-      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 = yield (() => __async(this, null, function* () {
-        if (!!state) {
-          this._logDebug("Retrieving initial state");
-          return this._crdtManager.getInitialState();
-        }
-        const resolved = this._crdtManager.resolveEncodedState(
-          yield this._storageStore.getUpdates()
-        );
-        if (!!resolved) {
-          this._logDebug("Retrieving storage store state");
-          return resolved;
-        }
-        this._logDebug("Retrieving initial state");
-        return 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;
-  }
+	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$1.Untouched
+			},
+			storage: { state: StorageState.Unavailable },
+			webSocket: null
+		};
+		this._windowListeners = null;
+		this._wsListeners = null;
+		this.broadcast = new Proxy(async (event, data) => {
+			if (!this._state.webSocket) return;
+			if (this._state.connection.state !== ConnectionState$1.Open) return;
+			const type = event.toString();
+			const procedure = this._router._defs.events[type];
+			if (!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 = await procedure.config.broadcast(parsed, context);
+			Object.entries(output).forEach(([_type, _data]) => {
+				this._sendMessage({
+					data: _data,
+					type: _type
+				});
+			});
+		}, { get(fn, prop) {
+			return async (data) => {
+				return await fn(prop, data);
+			};
+		} });
+		this.canRedo = () => {
+			return !!this._crdtManager.doc.canRedo();
+		};
+		this.canUndo = () => {
+			return !!this._crdtManager.doc.canUndo();
+		};
+		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;
+		};
+		this.redo = () => {
+			this._crdtManager.doc.redo();
+		};
+		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 ?? this._state.connection.id;
+			/**
+			* !HACK
+			* @description Don't transact anything if there is no origin, because
+			* that means the user isn't connected yet. This will mean events are
+			* lost unfortunately.
+			* @date September 23, 2023
+			*/
+			if (typeof _origin !== "string") return;
+			this._crdtManager.doc.transact(() => {
+				fn(this._crdtManager.doc.get());
+			}, _origin);
+		};
+		this.undo = () => {
+			this._crdtManager.doc.undo();
+		};
+		this.updateMyPresence = (presence$1) => {
+			const newPresence = typeof presence$1 === "function" ? presence$1(this.getMyPresence()) : presence$1;
+			this._usersManager.updateMyPresence(newPresence);
+			const myPresence = this._usersManager.myPresence;
+			const myself = this._usersManager.myself ?? null;
+			this._stateNotifier.subjects["my-presence"].next(myPresence);
+			if (!!myself) this._stateNotifier.subjects.myself.next(myself);
+			this.broadcast("$updatePresence", { presence: newPresence });
+		};
+		this._event = new Proxy((event, callback) => this._eventNotifier.subscribe(event, callback), { get(fn, prop) {
+			return (callback) => fn(prop, callback);
+		} });
+		this._flattenStorageStore = debounce(async () => {
+			if (!await this._storageStore.getShouldFlatten()) return;
+			const updates = await this._storageStore.getUpdates();
+			this._crdtManager.applyUpdate({
+				update: updates,
+				origin: this
+			});
+			const encodedState = this._crdtManager.doc.getEncodedState();
+			await this._storageStore.flatten(encodedState);
+		}, { wait: ADD_TO_STORAGE_STATE_DEBOUNCE_MS });
+		this._getAddon = (addons$1) => {
+			return addons$1.reduce((acc, addon$1) => () => ({
+				...acc({ room: this }),
+				...addon$1({ room: this })
+			}), DEFAULT_PLUV_CLIENT_ADDON);
+		};
+		this._other = (connectionId, callback) => {
+			const clientId = this._usersManager.getClientId(connectionId);
+			if (!clientId) return () => void 0;
+			return this._usersNotifier.subscribeOther(clientId, callback);
+		};
+		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 } = {
+			...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?.(error);
+		} };
+		this._router = router ?? new PluvRouter({});
+		this._usersManager = new UsersManager({
+			initialPresence,
+			limits: this._limits,
+			presence
+		});
+		this._crdtManager = new CrdtManager({ initialStorage });
+	}
+	get webSocket() {
+		return this._state.webSocket;
+	}
+	addEventListener(kind, handler) {
+		return this._listenerManager.subscribe(kind, handler);
+	}
+	async connect(...args) {
+		const params = args[0] ?? {};
+		const metadata = params.metadata;
+		this._setMetadata(metadata);
+		if (![
+			ConnectionState$1.Closed,
+			ConnectionState$1.Unavailable,
+			ConnectionState$1.Untouched
+		].some((state) => this._state.connection.state === state)) return;
+		this._clearTimeout(this._timeouts.reconnect);
+		this._updateState((oldState) => {
+			oldState.connection.state = ConnectionState$1.Connecting;
+			return oldState;
+		});
+		await 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 = await 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;
+			});
+			await this._storageStore.destroy();
+			this._pollReconnect();
+			await 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();
+	}
+	async disconnect() {
+		if (!this._state.webSocket) return;
+		if (![ConnectionState$1.Connecting, ConnectionState$1.Open].some((state) => this._state.connection.state === state)) return;
+		this._closeWs();
+		this._clearInterval(this._intervals.heartbeat);
+		this._clearTimeout(this._timeouts.reconnect);
+		this._updateState((oldState) => {
+			oldState.authorization.token = null;
+			oldState.connection.state = ConnectionState$1.Closed;
+			oldState.storage.state = oldState.storage.state === StorageState.Synced ? StorageState.Offline : StorageState.Unavailable;
+			oldState.webSocket = null;
+			return oldState;
+		});
+		await 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();
+		if (typeof this._crdtManager.get(type) === "undefined") return null;
+		return this._crdtManager.doc.toJson(type);
+	}
+	async _addToStorageStore(update) {
+		await 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() {
+		this._subscriptions.observeCrdt?.();
+		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" }
+		});
+		this._state.webSocket?.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 {
+				...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;
+	}
+	async _getAuthorization(room, params) {
+		const fetchOptions = this._getAuthFetchOptions(room, params);
+		if (!fetchOptions) return null;
+		const { url, options } = fetchOptions;
+		const res = await fetch(url, options);
+		if (!res.ok || res.status !== 200) throw new Error("Room is unauthorized");
+		try {
+			return await 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
+			}
+		});
+		/**
+		* @description A single user can have multiple connections. So we're checking that
+		* there isn't a remaining connection before choosing to delete that user for other
+		* connected participants.
+		* @date April 16, 2025
+		*/
+		if (!remaining && !!clientId) this._usersNotifier.delete(clientId);
+	}
+	_handlePresenceUpdatedMessage(message) {
+		const { connectionId } = message;
+		if (!connectionId) return;
+		if (!this._state.webSocket) throw new Error("Could not find WebSocket");
+		const data = message.data;
+		const myself = this._usersManager.myself ?? null;
+		/**
+		* !HACK
+		* @description We're going to have the user's own presence be patched only via local calls
+		* to this.updateMyPresence. So we'll not update the user's presence in this handler to
+		* avoid weird update delays to the user's own presence.
+		*
+		* However, we will patch the user's own presence if the user has updated their own
+		* presence via another connection that is not this one (e.g. if the user has opened
+		* another connection in another browser tab/window somewhere).
+		* @date April 2, 2025
+		*/
+		if (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 other$1 = this._usersManager.getOther(connectionId);
+			const others$1 = this._usersManager.getOthers();
+			this._usersNotifier.other(clientId).next(other$1);
+			this._stateNotifier.subjects.others.next(others$1);
+			if (!!other$1) this._usersNotifier.others.next({
+				others: others$1,
+				event: {
+					kind: "update",
+					user: other$1
+				}
+			});
+			return;
+		}
+		/**
+		* !HACK
+		* @description User could not be found. Add the connection to keep others up-to-date
+		* @date April 19, 2025
+		*/
+		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
+			}
+		});
+	}
+	async _handleRegisteredMessage(message) {
+		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;
+			return oldState;
+		});
+		const userInfo = {
+			connectionId,
+			presence: data.presence ?? void 0,
+			user
+		};
+		this._usersManager.setMyself(userInfo);
+		const presence = this._usersManager.myPresence;
+		const myself = this._usersManager.myself ?? null;
+		this._stateNotifier.subjects["my-presence"].next(presence);
+		this._stateNotifier.subjects.myself.next(myself);
+		const update = await (async () => {
+			if (!!state) {
+				this._logDebug("Retrieving initial state");
+				return this._crdtManager.getInitialState();
+			}
+			const resolved = this._crdtManager.resolveEncodedState(await this._storageStore.getUpdates());
+			if (!!resolved) {
+				this._logDebug("Retrieving storage store state");
+				return resolved;
+			}
+			this._logDebug("Retrieving initial state");
+			return this._crdtManager.getInitialState();
+		})();
+		this._sendMessage({
+			type: "$initializeSession",
+			data: {
+				presence,
+				update
+			}
+		});
+	}
+	async _handleStorageReceivedMessage(message) {
+		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 = await 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 encodedState$1 = updateStorage(state).doc.getEncodedState();
+			this._addToStorageStore(encodedState$1);
+		}
+		else {
+			const encodedState$1 = updateStorage(state).doc.getEncodedState();
+			if (!!updates.length) this._crdtManager.applyUpdate({
+				update: updates,
+				origin
+			});
+			await this._addToStorageStore(encodedState$1);
+		}
+		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 {
+				...acc,
+				[prop]: serialized
+			};
+		}, {});
+		this._crdtNotifier.rootSubject.next(storageRoot);
+	}
+	_handleSyncStateReceived(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 active = new Set(data?.connectionIds ?? []);
+		this._usersManager.getOthers().filter((other) => !active.has(other.connectionId)).forEach((quitter) => {
+			this._usersManager.deleteConnection(quitter.connectionId);
+			const remaining$1 = this._usersManager.getOthers();
+			this._usersNotifier.others.next({
+				others: remaining$1,
+				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;
+		if (this._usersManager.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);
+		/**
+		* !HACK
+		* @description Send data as a stable string so that the server can react to this in a
+		* consistent way.
+		* @date July 8, 2024
+		*/
+		this._sendMessage("{\"type\":\"$ping\",\"data\":{}}");
+	}
+	_logDebug(...data) {
+		if (typeof process === "undefined") return;
+		if (process.env?.NODE_ENV === "production") return;
+		if (this._debug) console.log(...data);
+	}
+	_observeCrdt() {
+		this._subscriptions.observeCrdt?.();
+		const unsubscribe = this._crdtManager.doc.subscribe((event) => {
+			const origin = event.origin ?? 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 : /* @__PURE__ */ new Error("Authorization failed");
+		this._listeners.onAuthorizationFail(authError);
+		this._updateState((oldState) => {
+			oldState.connection.state = ConnectionState$1.Unavailable;
+			oldState.storage.state = StorageState.Unavailable;
+			return oldState;
+		});
+	}
+	async _onClose(event) {
+		this._listenerManager.subjects.close.next(event);
+		this._logDebug("WebSocket closed");
+		if (!!event.reason) this._logDebug(event.reason);
+		const shouldRetry = [
+			1001,
+			1006,
+			1011,
+			1012,
+			1013,
+			1014
+		].some((okToRetryCode) => event.code === okToRetryCode);
+		this._updateState((oldState) => {
+			oldState.authorization.token = null;
+			oldState.connection.state = shouldRetry ? ConnectionState$1.Unavailable : ConnectionState$1.Closed;
+			oldState.storage.state = oldState.storage.state === StorageState.Synced ? StorageState.Offline : StorageState.Unavailable;
+			oldState.webSocket = null;
+			return oldState;
+		});
+		if (shouldRetry) {
+			await 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;
+		if (typeof this._debug === "boolean" ? this._debug : this._debug.output.find((value) => value === message.type)) 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$1.Connecting) return;
+		this._logDebug("WebSocket connected");
+		this._updateState((oldState) => {
+			oldState.connection.state = ConnectionState$1.Open;
+			return oldState;
+		});
+		this._clearInterval(this._intervals.heartbeat);
+		this._intervals.heartbeat = setInterval(this._heartbeat.bind(this), HEARTBEAT_INTERVAL_MS);
+	}
+	async _onNavigatorOffline() {
+		if (this._state.connection.state === ConnectionState$1.Closed) return;
+		this._updateState((oldState) => {
+			oldState.connection.state = ConnectionState$1.Unavailable;
+			oldState.storage.state = oldState.storage.state === StorageState.Synced ? StorageState.Offline : StorageState.Unavailable;
+			return oldState;
+		});
+	}
+	async _onNavigatorOnline() {
+		if (this._state.connection.state !== ConnectionState$1.Unavailable) return;
+		await this._reconnect();
+	}
+	async _onVisibilityChange() {
+		if (typeof document === "undefined") return;
+		if (document.visibilityState !== "visible") return;
+		switch (this._state.connection.state) {
+			case ConnectionState$1.Open:
+				this._clearInterval(this._intervals.heartbeat);
+				setInterval(this._heartbeat.bind(this), HEARTBEAT_INTERVAL_MS);
+				return;
+			case ConnectionState$1.Unavailable:
+				await this._reconnect();
+				return;
+			default:
+		}
+	}
+	async _onWindowFocus() {
+		return await this._onVisibilityChange();
+	}
+	_parseMessage(message) {
+		/**
+		* !HACK
+		* @description We'll only handle stringified JSONs for now
+		* @date August 9, 2022
+		*/
+		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 {
+			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);
+	}
+	async _reconnect() {
+		this._closeWs();
+		/**
+		* @description User has manually closed this connection. We're not going to retry, since
+		* the user probably intends for this to stay closed. They will need to invoke connect
+		* themselves.
+		* @date April 28, 2025
+		*/
+		if (this._state.connection.state === ConnectionState$1.Closed) return;
+		const metadata = this._lastMetadata;
+		const params = typeof metadata === "undefined" ? [] : [{ metadata }];
+		await this.connect(...params);
+	}
+	_sendMessage(data) {
+		const webSocket = this._state.webSocket;
+		if (webSocket?.readyState !== WebSocket.OPEN) return;
+		const dataType = (() => {
+			if (typeof data === "object") return data.type ?? null;
+			if (typeof data !== "string") return null;
+			try {
+				return JSON.parse(data)?.type ?? null;
+			} catch {
+				return null;
+			}
+		})();
+		if (typeof this._debug === "boolean" ? this._debug : !dataType ? false : this._debug.input.some((value) => value === data.type)) 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;
+	}
+	#_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);
+		};
+	} });
+	_updateState(updater) {
+		let authorization;
+		try {
+			authorization = JSON.parse(JSON.stringify(this._state.authorization));
+		} catch {
+			throw new Error("User is not JSON serializable");
+		}
+		const newState = updater({
+			...this._state,
+			authorization,
+			connection: JSON.parse(JSON.stringify(this._state.connection)),
+			storage: JSON.parse(JSON.stringify(this._state.storage)),
+			webSocket: this._state.webSocket
+		});
+		this._state = newState;
+		this._logDebug("WebSocket new state: ", newState);
+		this._stateNotifier.subjects.connection.next(newState);
+		return newState;
+	}
 };
-__storage = new WeakMap();
 
-// src/PluvClient.ts
+//#endregion
+//#region 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);
-  }
+	get _defs() {
+		return { initialStorage: this._initialStorage };
+	}
+	get procedure() {
+		return new PluvProcedure();
+	}
+	constructor(options) {
+		this._publicKey = null;
+		this._rooms = /* @__PURE__ */ new Map();
+		this.createRoom = (room, options$1 = {}) => {
+			const oldRoom = this.getRoom(room);
+			if (oldRoom) return oldRoom;
+			const newRoom = new PluvRoom(room, {
+				addons: options$1.addons,
+				authEndpoint: this._authEndpoint,
+				debug: options$1.debug,
+				initialPresence: options$1.initialPresence,
+				initialStorage: options$1.initialStorage ?? this._initialStorage,
+				limits: this._limits,
+				metadata: this.metadata,
+				onAuthorizationFail: options$1.onAuthorizationFail,
+				presence: this._presence,
+				publicKey: this._publicKey ?? void 0,
+				reconnectTimeoutMs: options$1.reconnectTimeoutMs,
+				router: options$1.router,
+				wsEndpoint: this._wsEndpoint
+			});
+			this._rooms.set(room, newRoom);
+			this._logDebug(`New room was created: ${room}`);
+			return newRoom;
+		};
+		this.enter = async (room, ...args) => {
+			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);
+			await toEnter.connect(...args);
+			this._logDebug(`Entered room: ${room}`);
+			return toEnter;
+		};
+		this.getRoom = (room) => {
+			return this._rooms.get(room) ?? null;
+		};
+		this.getRooms = () => {
+			return Array.from(this._rooms.values());
+		};
+		this.leave = async (room) => {
+			const toLeave = typeof room === "string" ? this.getRoom(room) : room;
+			if (!toLeave) return;
+			await 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 = {
+			presenceMaxSize: MAX_PRESENCE_SIZE_BYTES,
+			...limits
+		};
+		this._presence = presence;
+		this._wsEndpoint = wsEndpoint;
+		if (!!publicKey) this._publicKey = publicKey;
+	}
+	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) {
+		if (typeof process === "undefined") return;
+		if (process.env?.NODE_ENV === "production") return;
+		if (this._debug) console.log(...data);
+	}
 };
 
-// src/createClient.ts
-var createClient = (options) => {
-  return new PluvClient(options);
+//#endregion
+//#region src/createClient.ts
+const createClient = (options) => {
+	return new PluvClient(options);
 };
 
-// src/infer.ts
-var infer = (callback) => {
-  return callback;
+//#endregion
+//#region src/infer.ts
+const infer = (callback) => {
+	return callback;
 };
 
-// src/MockedRoom.ts
-import { ConnectionState as ConnectionState2, StorageState as StorageState2 } from "@pluv/types";
-var __storage2;
+//#endregion
+//#region src/MockedRoom.ts
 var MockedRoom = class {
-  constructor(room, options) {
-    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.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.redo = () => {
-      this._crdtManager.doc.redo();
-    };
-    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 __privateGet(this, __storage2);
-        }
-      }
-    );
-    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);
-    };
-    this._event = new Proxy(
-      (event, callback) => this._eventNotifier.subscribe(event, callback),
-      {
-        get(fn, prop) {
-          return (callback) => fn(prop, callback);
-        }
-      }
-    );
-    this._other = (connectionId, callback) => {
-      const clientId = this._usersManager.getClientId(connectionId);
-      if (!clientId) return () => void 0;
-      return this._usersNotifier.subscribeOther(clientId, callback);
-    };
-    __privateAdd(this, __storage2, 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);
-          };
-        }
-      }
-    ));
-    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);
-    });
-  }
+	constructor(room, options) {
+		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: ConnectionState$1.Untouched
+			},
+			storage: { state: StorageState.Unavailable },
+			webSocket: null
+		};
+		this._stateNotifier = new StateNotifier();
+		this._subscriptions = { observeCrdt: null };
+		this.broadcast = new Proxy(async (event, data) => {
+			if (!this._state.webSocket) return;
+			if (this._state.connection.state !== ConnectionState$1.Open) return;
+			const type = event.toString();
+			const procedure = this._router._defs.events[type];
+			if (!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 = await procedure.config.broadcast(parsed, context);
+			Object.entries(output).forEach(([_type, _data]) => {
+				this._simulateEvent(_type, _data);
+			});
+		}, { get(fn, prop) {
+			return async (data) => {
+				return await fn(prop, data);
+			};
+		} });
+		this.canRedo = () => {
+			return !!this._crdtManager.doc.canRedo();
+		};
+		this.canUndo = () => {
+			return !!this._crdtManager.doc.canUndo();
+		};
+		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.redo = () => {
+			this._crdtManager.doc.redo();
+		};
+		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 ?? this._state.connection.id;
+			const crdtManager = this._crdtManager;
+			/**
+			* !HACK
+			* @description Don't transact anything if there is no origin, because
+			* that means the user isn't connected yet. This will mean events are
+			* lost unfortunately.
+			* @date September 23, 2023
+			*/
+			if (typeof _origin !== "string") return;
+			if (!crdtManager) return;
+			crdtManager.doc.transact(() => {
+				fn(crdtManager.doc.get());
+			}, _origin);
+		};
+		this.undo = () => {
+			this._crdtManager.doc.undo();
+		};
+		this.updateMyPresence = (presence$1) => {
+			const newPresence = typeof presence$1 === "function" ? presence$1(this.getMyPresence()) : presence$1;
+			this._usersManager.updateMyPresence(newPresence);
+			const myPresence = this._usersManager.myPresence;
+			const myself = this._usersManager.myself ?? null;
+			this._stateNotifier.subjects["my-presence"].next(myPresence);
+			if (!!myself) this._stateNotifier.subjects["myself"].next(myself);
+		};
+		this._event = new Proxy((event, callback) => this._eventNotifier.subscribe(event, callback), { get(fn, prop) {
+			return (callback) => fn(prop, callback);
+		} });
+		this._other = (connectionId, callback) => {
+			const clientId = this._usersManager.getClientId(connectionId);
+			if (!clientId) return () => void 0;
+			return this._usersNotifier.subscribeOther(clientId, callback);
+		};
+		const { events, initialPresence, initialStorage, limits, presence, router } = options;
+		this.id = room;
+		this._events = events;
+		this._limits = {
+			presenceMaxSize: MAX_PRESENCE_SIZE_BYTES,
+			...limits
+		};
+		this._router = 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() {
+		this._subscriptions.observeCrdt?.();
+		if (!this._crdtManager) return;
+		const unsubscribe = this._crdtManager.doc.subscribe((event) => {
+			const origin = event.origin ?? 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 {
+					...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((type$1) => {
+			const _type = type$1.toString();
+			const data$1 = result[_type];
+			if (!data$1) return;
+			this._eventNotifier.subject(_type).next(data$1);
+		});
+	}
+	#_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);
+		};
+	} });
 };
-__storage2 = new WeakMap();
 
-// 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
+//#endregion
+//#region src/register.ts
+const register = (params) => {
+	const { authEndpoint, publicKey } = params;
+	const wsEndpoint = ({ room }) => `wss://connect.pluv.io/api/room?room=${room}`;
+	return {
+		authEndpoint,
+		publicKey,
+		wsEndpoint
+	};
 };
+
+//#endregion
+export { AbstractStorageStore, ConnectionState, MockedRoom, PluvClient, PluvRoom, createClient, infer, register };
+//# sourceMappingURL=index.mjs.map