@pluv/client 5.0.1 → 5.0.2

package/dist/index.mjs

@@ -0,0 +1,1770 @@
+import { ConnectionState, ConnectionState as ConnectionState$1, StorageState } from "@pluv/types";
+import { noop } from "@pluv/crdt";
+import { makeSubject, subscribe } from "wonka";
+//#region src/AbstractStorageStore.ts
+var AbstractStorageStore = class {
+	constructor(room) {
+		this.room = room;
+	}
+};
+//#endregion
+//#region src/constants.ts
+const PLUV_PRESENCE_META_KEY = "__pluv";
+//#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);
+	}
+};
+//#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;
+		/**
+		* !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;
+	}
+};
+//#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;
+	}
+};
+//#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 = makeSubject();
+		this.subjects.set(name, newSubject);
+		return newSubject;
+	}
+	subscribe(name, callback) {
+		const subject = this.subject(name);
+		return subscribe(callback)(subject.source).unsubscribe;
+	}
+};
+//#endregion
+//#region src/ListenerManager.ts
+var ListenerManager = class {
+	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;
+	}
+};
+//#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);
+	}
+};
+//#endregion
+//#region src/StateNotifier.ts
+var StateNotifier = class {
+	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;
+	}
+};
+//#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();
+	}
+};
+//#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;
+	};
+};
+//#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;
+};
+//#endregion
+//#region src/UsersManager.ts
+var UsersManager = class {
+	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 = userInfo.connectionId;
+			return userInfo.user?.id ?? null ?? connectionId;
+		}
+		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"]) 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;
+	}
+};
+//#endregion
+//#region src/UsersNotifier.ts
+var UsersNotifier = class {
+	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;
+	}
+};
+//#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$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) => {
+			const newPresence = typeof presence === "function" ? presence(this.getMyPresence()) : presence;
+			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) => {
+			return addons.reduce((acc, addon) => () => ({
+				...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);
+		};
+		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 } = {
+			...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", { cause: err });
+		}
+	}
+	_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 = this._usersManager.getOther(connectionId);
+			const others = this._usersManager.getOthers();
+			this._usersNotifier.other(clientId).next(other);
+			this._stateNotifier.subjects.others.next(others);
+			if (!!other) this._usersNotifier.others.next({
+				others,
+				event: {
+					kind: "update",
+					user: other
+				}
+			});
+			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 = updateStorage(state).doc.getEncodedState();
+				this._addToStorageStore(encodedState);
+			}
+		} else {
+			const encodedState = updateStorage(state).doc.getEncodedState();
+			if (!!updates.length) this._crdtManager.applyUpdate({
+				update: updates,
+				origin
+			});
+			await this._addToStorageStore(encodedState);
+		}
+		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 = this._usersManager.getOthers();
+			this._usersNotifier.others.next({
+				others: remaining,
+				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;
+		}
+	}
+	_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;
+		}
+	}
+	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;
+	_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;
+	}
+};
+//#endregion
+//#region src/PluvClient.ts
+var PluvClient = class {
+	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 = {}) => {
+			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: options.initialStorage ?? this._initialStorage,
+				limits: this._limits,
+				metadata: this.metadata,
+				onAuthorizationFail: options.onAuthorizationFail,
+				presence: this._presence,
+				publicKey: this._publicKey ?? 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 = 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: 512,
+			...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);
+	}
+};
+//#endregion
+//#region src/createClient.ts
+const createClient = (options) => {
+	return new PluvClient(options);
+};
+//#endregion
+//#region src/infer.ts
+const infer = (callback) => {
+	return callback;
+};
+//#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: 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) => {
+			const newPresence = typeof presence === "function" ? presence(this.getMyPresence()) : presence;
+			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);
+		};
+		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 { events, initialPresence, initialStorage, limits, presence, router } = options;
+		this.id = room;
+		this._events = events;
+		this._limits = {
+			presenceMaxSize: 512,
+			...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) => {
+			const _type = type.toString();
+			const data = result[_type];
+			if (!data) return;
+			this._eventNotifier.subject(_type).next(data);
+		});
+	}
+	#_storage;
+};
+//#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