@pluv/client 0.0.0-canary-20261027014949

package/dist/index.mjs

@@ -0,0 +1,2625 @@
+import { ConnectionState, ConnectionState as ConnectionState$1, StorageState } from "@pluv/types";
+import { noop } from "@pluv/crdt";
+import { makeSubject, subscribe } from "wonka";
+// src/AbstractStorageStore.ts
+var AbstractStorageStore = class {
+	constructor(room) {
+		this.room = room;
+	}
+};
+// src/constants.ts
+const PLUV_PRESENCE_META_KEY = "__pluv";
+const LIST_USERS_TIMEOUT_MS = 1e4;
+// src/utils/assertSerializingSchema.ts
+const getJsonSchemaProducer = (schema) => {
+	const jsonSchema = schema?.["~standard"]?.jsonSchema;
+	if (!jsonSchema || typeof jsonSchema.input !== "function") return null;
+	return jsonSchema;
+};
+const assertSerializingSchema = (schema) => {
+	if (!getJsonSchemaProducer(schema)) throw new Error("Schema must implement Standard Schema and Standard JSON Schema on the same object (e.g. Zod 4.2+ or ArkType).");
+};
+// src/CrdtManager.ts
+var CrdtManager = class {
+	constructor(options) {
+		this.initialized = false;
+		const { initialStorage, storage = noop.doc() } = options;
+		this._docFactory = storage.getFactory(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;
+		this.doc = this._applyDocUpdates(this.doc, updates, origin).rebuildStorage();
+		this.initialized = true;
+		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
+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) {
+		const subscription = subscribe(callback)(this.rootSubject.source);
+		return () => {
+			subscription.unsubscribe();
+		};
+	}
+	subscribe(key, callback) {
+		const subject = this.subject(key);
+		const subscription = subscribe(callback)(subject.source);
+		return () => {
+			subscription.unsubscribe();
+		};
+	}
+};
+// 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);
+		const subscription = subscribe(callback)(subject.source);
+		return () => {
+			subscription.unsubscribe();
+		};
+	}
+};
+// 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;
+		const subscription = subscribe(callback)(source);
+		return () => {
+			subscription.unsubscribe();
+		};
+	}
+};
+// src/PendingRequestManager.ts
+/**
+* Correlate in-flight request ids to replies on a multiplexed socket.
+*/
+var PendingRequestManager = class {
+	constructor() {
+		this._waiters = /* @__PURE__ */ new Map();
+	}
+	get size() {
+		return this._waiters.size;
+	}
+	request(params) {
+		const requestId = globalThis.crypto.randomUUID();
+		return {
+			promise: new Promise((resolve) => {
+				const timeoutId = setTimeout(() => {
+					this.complete(requestId, params.onTimeout());
+				}, params.timeoutMs);
+				this._waiters.set(requestId, {
+					onAbort: params.onAbort,
+					resolve,
+					timeoutId
+				});
+			}),
+			requestId
+		};
+	}
+	complete(requestId, result) {
+		const pending = this._waiters.get(requestId) ?? null;
+		if (!pending) return false;
+		this._waiters.delete(requestId);
+		clearTimeout(pending.timeoutId);
+		pending.resolve(result);
+		return true;
+	}
+	failAll() {
+		Array.from(this._waiters.entries()).forEach(([requestId, pending]) => {
+			this.complete(requestId, pending.onAbort());
+		});
+	}
+};
+// src/StateNotifier.ts
+var StateNotifier = class {
+	constructor() {
+		this.subjects = {
+			connection: makeSubject(),
+			"my-presence": makeSubject(),
+			myself: makeSubject(),
+			others: makeSubject(),
+			roomStats: makeSubject(),
+			"storage-loaded": makeSubject()
+		};
+	}
+	subscribe(name, callback) {
+		const source = this.subjects[name]?.source;
+		if (!source) throw new Error(`Could not subscribe to source: ${name}`);
+		const subscription = subscribe(callback)(source);
+		return () => {
+			subscription.unsubscribe();
+		};
+	}
+};
+// src/StorageStore.ts
+var StorageStore = class extends AbstractStorageStore {
+	addUpdate() {
+		return Promise.resolve();
+	}
+	applyUpdates() {
+		return Promise.resolve();
+	}
+	destroy() {
+		return Promise.resolve();
+	}
+	flatten() {
+		return Promise.resolve();
+	}
+	getShouldFlatten() {
+		return Promise.resolve(false);
+	}
+	getUpdates() {
+		return Promise.resolve([]);
+	}
+	initialize() {
+		return Promise.resolve();
+	}
+};
+// src/StorageSync.ts
+/**
+* Holds remote storage updates until the document has loaded, and remembers when a catch-up
+* reply did not move the document.
+*/
+var StorageSync = class {
+	constructor() {
+		this._queue = [];
+		this._ready = false;
+		this._stalled = false;
+	}
+	get isReady() {
+		return this._ready;
+	}
+	hold(update) {
+		this._queue.push(update);
+	}
+	markReady() {
+		this._ready = true;
+		return this._takeQueue();
+	}
+	clearStall() {
+		this._stalled = false;
+	}
+	/**
+	* @description The first time a catch-up reply does not move the document. Later calls
+	* stay quiet until `clearStall()` or `reset()`.
+	*/
+	noteStall() {
+		if (this._stalled) return false;
+		this._stalled = true;
+		return true;
+	}
+	reset() {
+		this._queue = [];
+		this._ready = false;
+		this._stalled = false;
+	}
+	_takeQueue() {
+		const queued = this._queue.splice(0);
+		if (queued.length) this.clearStall();
+		return queued;
+	}
+};
+// src/utils/assertExhaustive.ts
+const assertExhaustive = (value) => {
+	throw new Error(`Unhandled value: ${value}`);
+};
+// src/utils/parsePluvSchema.ts
+function parsePluvSchema(schema, data) {
+	const result = schema["~standard"].validate(data);
+	if (result instanceof Promise) throw new Error("Async schemas are not supported. Schema validate() must be synchronous.");
+	if (result.issues) {
+		const message = result.issues[0]?.message ?? "Invalid input";
+		throw new Error(message);
+	}
+	return result.value;
+}
+// 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
+var UsersManager = class {
+	constructor(config) {
+		this._idMap = {
+			fromConnectionId: /* @__PURE__ */ new Map(),
+			fromClientKey: {
+				operator: /* @__PURE__ */ new Map(),
+				user: /* @__PURE__ */ new Map()
+			}
+		};
+		this._myself = null;
+		this._operators = /* @__PURE__ */ new Map();
+		this._others = /* @__PURE__ */ new Map();
+		this._presence = null;
+		this._presenceSeqs = {
+			operator: /* @__PURE__ */ new Map(),
+			user: /* @__PURE__ */ new Map()
+		};
+		this._localPresenceInFlight = 0;
+		const { initialPresence, limits, presence = null } = config;
+		this._presence = presence;
+		this._limits = limits;
+		const resolved = presence ? parsePluvSchema(presence, initialPresence ?? {}) : initialPresence ?? {};
+		this.initialPresence = resolved;
+		this._myPresence = resolved;
+	}
+	get myPresence() {
+		return this._myPresence;
+	}
+	get myself() {
+		return this._myself;
+	}
+	addConnection(params) {
+		/**
+		* @description Ensure that the presence is complete, so that it does not fail schema
+		* validation
+		* @date April 20, 2025
+		*/
+		const cleaned = pickBy(params.presence ?? {}, (value) => typeof value !== "undefined");
+		const presence = {
+			...this.initialPresence,
+			...cleaned
+		};
+		const info = this._toUserInfo(params, presence);
+		const clientKey = this._clientKeyFromInfo(info);
+		const myClientKey = this._myself ? this._clientKeyFromInfo(this._myself) : null;
+		const remaining = this._setConnectionId(params.connectionId, clientKey).size;
+		if (this._sameClientKey(myClientKey, clientKey)) return {
+			data: this._myself ?? info,
+			isMyself: true,
+			presenceChanged: false,
+			remaining
+		};
+		const others = this._mapForKind(clientKey.kind);
+		if (!others.get(clientKey.id)) {
+			others.set(clientKey.id, info);
+			this._setPresenceSeq(clientKey, params.presenceSeq ?? null);
+			return {
+				data: info,
+				isMyself: false,
+				presenceChanged: true,
+				remaining
+			};
+		}
+		const presenceChanged = this._isNewerPresenceSeq(clientKey, params.presenceSeq);
+		if (presenceChanged) {
+			others.set(clientKey.id, info);
+			this._setPresenceSeq(clientKey, params.presenceSeq);
+		}
+		return {
+			data: others.get(clientKey.id) ?? info,
+			isMyself: false,
+			presenceChanged,
+			remaining
+		};
+	}
+	clearConnections() {
+		this.removeMyself();
+		this._operators.clear();
+		this._others.clear();
+		this._presenceSeqs.operator.clear();
+		this._presenceSeqs.user.clear();
+		this._localPresenceInFlight = 0;
+		this._idMap.fromClientKey.operator.clear();
+		this._idMap.fromClientKey.user.clear();
+		this._idMap.fromConnectionId.clear();
+	}
+	deleteConnection(connectionId) {
+		const clientKey = this._clientKeyForConnection(connectionId);
+		this._deleteConnectionId(connectionId);
+		if (!clientKey) return null;
+		const userInfo = this._getByClientKey(clientKey);
+		if (!userInfo) return null;
+		const remaining = this._getConnectionIds(clientKey)?.size ?? 0;
+		const result = {
+			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._mapForKind(clientKey.kind).delete(clientKey.id);
+			this._presenceSeqsForKind(clientKey.kind).delete(clientKey.id);
+		}
+		return result;
+	}
+	/**
+	* Public participant id. Both kinds use `data.id`.
+	*/
+	getParticipantId(info) {
+		return this._clientKeyFromInfo(info).id;
+	}
+	isMyselfConnection(connectionId) {
+		if (!this._myself) return false;
+		return this._sameClientKey(this._clientKeyForConnection(connectionId), this._clientKeyFromInfo(this._myself));
+	}
+	getOther(userId, options) {
+		const kind = options?.kind ?? "user";
+		switch (kind) {
+			case "user": return this._others.get(userId) ?? null;
+			case "operator": return this._operators.get(userId) ?? null;
+			default: return assertExhaustive(kind);
+		}
+	}
+	getOtherByConnectionId(connectionId, options) {
+		const clientKey = this._clientKeyForConnection(connectionId);
+		if (!clientKey) return null;
+		const info = this._getByClientKey(clientKey);
+		if (!info) return null;
+		return (options?.kinds ?? ["user"]).includes(info.kind) ? info : null;
+	}
+	getOthers(options) {
+		const kinds = options?.kinds ?? ["user"];
+		const others = [];
+		if (kinds.includes("user")) others.push(...this._others.values());
+		if (kinds.includes("operator")) others.push(...this._operators.values());
+		return others;
+	}
+	getOccupancy(options) {
+		const kinds = new Set(options?.kinds ?? ["user"]);
+		const myselfKind = this._myself?.kind ?? "user";
+		const includeMyself = !!this._myself && kinds.has(myselfKind);
+		const myClientKey = this._myself ? this._clientKeyFromInfo(this._myself) : null;
+		let connectionCount = 0;
+		this._idMap.fromConnectionId.forEach((clientKey) => {
+			const info = this._sameClientKey(clientKey, myClientKey) ? this._myself : this._getByClientKey(clientKey);
+			if (info && kinds.has(info.kind)) connectionCount += 1;
+		});
+		const userCount = (kinds.has("user") ? this._others.size : 0) + (kinds.has("operator") ? this._operators.size : 0) + (includeMyself ? 1 : 0);
+		return {
+			connectionCount,
+			userCount
+		};
+	}
+	beginLocalPresenceWrite() {
+		this._localPresenceInFlight += 1;
+	}
+	/**
+	* @returns Whether this own-connection echo should apply. Stale echoes
+	* during a burst of local writes return false so they cannot rewind.
+	*/
+	ackOwnPresenceEcho() {
+		if (this._localPresenceInFlight > 0) this._localPresenceInFlight -= 1;
+		return this._localPresenceInFlight === 0;
+	}
+	patchPresence(params) {
+		const { connectionId, session, user } = params;
+		const { operator, presence: patch, seq } = session;
+		const presenceSeq = seq.presence;
+		const clientKey = this._clientKeyForConnection(connectionId);
+		const myClientKey = this._myself ? this._clientKeyFromInfo(this._myself) : null;
+		if (!clientKey) return null;
+		if (this._sameClientKey(myClientKey, clientKey)) {
+			if (!this._shouldApplyPresenceSeq(clientKey, presenceSeq)) return {
+				applied: false,
+				presence: this._myself?.presence ?? this._myPresence
+			};
+			return {
+				applied: true,
+				presence: this.updateMyPresence(patch, presenceSeq)
+			};
+		}
+		const other = this._getByClientKey(clientKey);
+		if (!other) return null;
+		if (!this._shouldApplyPresenceSeq(clientKey, presenceSeq)) return {
+			applied: false,
+			presence: other.presence
+		};
+		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 ? parsePluvSchema(this._presence, 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._mapForKind(clientKey.kind).set(clientKey.id, {
+			...other,
+			data: user,
+			operator,
+			presence: validated
+		});
+		this._setPresenceSeq(clientKey, presenceSeq);
+		return {
+			applied: true,
+			presence: validated
+		};
+	}
+	pruneConnections(activeConnectionIds) {
+		const myClientKey = this._myself ? this._clientKeyFromInfo(this._myself) : null;
+		const left = [];
+		Array.from(this._idMap.fromConnectionId.keys()).forEach((connectionId) => {
+			if (activeConnectionIds.has(connectionId)) return;
+			const clientKey = this._clientKeyForConnection(connectionId);
+			if (!clientKey || this._sameClientKey(clientKey, myClientKey)) return;
+			const deleted = this.deleteConnection(connectionId);
+			if (deleted && !deleted.remaining) left.push(deleted.data);
+		});
+		return left;
+	}
+	removeMyself() {
+		if (!this._myself) return;
+		const clientKey = this._clientKeyFromInfo(this._myself);
+		this._getConnectionIds(clientKey)?.forEach((connectionId) => {
+			this._idMap.fromConnectionId.delete(connectionId);
+		});
+		this._connectionsForKind(clientKey.kind).delete(clientKey.id);
+		this._presenceSeqsForKind(clientKey.kind).delete(clientKey.id);
+		this._localPresenceInFlight = 0;
+		this._myself = null;
+	}
+	replaceOthers(rows) {
+		const myClientKey = this._myself ? this._clientKeyFromInfo(this._myself) : null;
+		const previousUsers = new Map(this._others);
+		const previousOperators = new Map(this._operators);
+		const previousUserSeqs = new Map(this._presenceSeqs.user);
+		const previousOperatorSeqs = new Map(this._presenceSeqs.operator);
+		Array.from(this._idMap.fromConnectionId.entries()).forEach(([connectionId, clientKey]) => {
+			if (this._sameClientKey(clientKey, myClientKey)) return;
+			this._idMap.fromConnectionId.delete(connectionId);
+		});
+		Array.from(this._idMap.fromClientKey.user.keys()).forEach((id) => {
+			if (myClientKey?.kind === "user" && myClientKey.id === id) return;
+			this._idMap.fromClientKey.user.delete(id);
+		});
+		Array.from(this._idMap.fromClientKey.operator.keys()).forEach((id) => {
+			if (myClientKey?.kind === "operator" && myClientKey.id === id) return;
+			this._idMap.fromClientKey.operator.delete(id);
+		});
+		this._others.clear();
+		this._operators.clear();
+		this._presenceSeqs.user.clear();
+		this._presenceSeqs.operator.clear();
+		if (myClientKey) {
+			const mySeq = (() => {
+				switch (myClientKey.kind) {
+					case "user": return previousUserSeqs.get(myClientKey.id);
+					case "operator": return previousOperatorSeqs.get(myClientKey.id);
+					default: return assertExhaustive(myClientKey.kind);
+				}
+			})();
+			if (mySeq !== void 0) this._setPresenceSeq(myClientKey, mySeq);
+		}
+		rows.forEach((row) => {
+			const cleaned = pickBy(row.presence ?? {}, (value) => typeof value !== "undefined");
+			const snapshotPresence = {
+				...this.initialPresence,
+				...cleaned
+			};
+			const info = this._toUserInfo(row, snapshotPresence);
+			const clientKey = this._clientKeyFromInfo(info);
+			const previous = (() => {
+				switch (clientKey.kind) {
+					case "user": return previousUsers.get(clientKey.id);
+					case "operator": return previousOperators.get(clientKey.id);
+					default: return assertExhaustive(clientKey.kind);
+				}
+			})();
+			const previousSeq = (() => {
+				switch (clientKey.kind) {
+					case "user": return previousUserSeqs.get(clientKey.id);
+					case "operator": return previousOperatorSeqs.get(clientKey.id);
+					default: return assertExhaustive(clientKey.kind);
+				}
+			})();
+			const snapshotNewer = this._isNewerPresenceSeqValue(previousSeq, row.presenceSeq);
+			if (previous && !snapshotNewer) {
+				this._mapForKind(previous.kind).set(clientKey.id, previous);
+				this._setPresenceSeq(clientKey, previousSeq ?? null);
+			} else {
+				this._mapForKind(info.kind).set(clientKey.id, info);
+				this._setPresenceSeq(clientKey, row.presenceSeq ?? null);
+			}
+			row.connectionIds.forEach((connectionId) => {
+				this._setConnectionId(connectionId, clientKey);
+			});
+		});
+		const left = [];
+		previousUsers.forEach((_, id) => {
+			if (!this._others.has(id)) left.push({
+				id,
+				kind: "user"
+			});
+		});
+		previousOperators.forEach((_, id) => {
+			if (!this._operators.has(id)) left.push({
+				id,
+				kind: "operator"
+			});
+		});
+		return left;
+	}
+	setMyself(params) {
+		const presence = params.presence ?? this.initialPresence;
+		const info = this._toUserInfo(params, presence);
+		const clientKey = this._clientKeyFromInfo(info);
+		this._myself = info;
+		this._myPresence = presence;
+		this._setPresenceSeq(clientKey, params.presenceSeq ?? null);
+		this._setConnectionId(params.connectionId, clientKey);
+	}
+	setMyConnectionIds(connectionIds) {
+		if (!this._myself) return;
+		const clientKey = this._clientKeyFromInfo(this._myself);
+		this._getConnectionIds(clientKey)?.forEach((connectionId) => {
+			this._idMap.fromConnectionId.delete(connectionId);
+		});
+		this._connectionsForKind(clientKey.kind).delete(clientKey.id);
+		connectionIds.forEach((connectionId) => {
+			this._setConnectionId(connectionId, clientKey);
+		});
+	}
+	setPresence(connectionId, presence, presenceSeq) {
+		const clientKey = this._clientKeyForConnection(connectionId);
+		const myClientKey = this._myself ? this._clientKeyFromInfo(this._myself) : null;
+		if (!clientKey) return;
+		if (!this._shouldApplyPresenceSeq(clientKey, presenceSeq)) return;
+		if (this._sameClientKey(myClientKey, clientKey)) {
+			if (!this._myself) return;
+			this._myself.presence = presence;
+			this._myPresence = presence;
+			this._setPresenceSeq(clientKey, presenceSeq);
+			return;
+		}
+		const other = this._getByClientKey(clientKey);
+		if (!other) return;
+		this._mapForKind(clientKey.kind).set(clientKey.id, {
+			...other,
+			presence
+		});
+		this._setPresenceSeq(clientKey, presenceSeq);
+	}
+	/**
+	* @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, presenceSeq) {
+		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;
+		this._setPresenceSeq(this._clientKeyFromInfo(this._myself), presenceSeq);
+		return updated;
+	}
+	_toUserInfo(params, presence) {
+		switch (params.kind) {
+			case "operator": return {
+				data: params.data,
+				kind: params.kind,
+				operator: params.operator ?? null,
+				presence
+			};
+			case "user": return {
+				data: params.data,
+				kind: params.kind,
+				operator: null,
+				presence
+			};
+			default: return assertExhaustive(params.kind);
+		}
+	}
+	_clientKeyForConnection(connectionId) {
+		return this._idMap.fromConnectionId.get(connectionId) ?? null;
+	}
+	_clientKeyFromInfo(info) {
+		const id = info.data && typeof info.data.id === "string" ? info.data.id : null;
+		if (!id) throw new Error("Could not resolve user id");
+		switch (info.kind) {
+			case "operator":
+			case "user": return {
+				kind: info.kind,
+				id
+			};
+			default: return assertExhaustive(info.kind);
+		}
+	}
+	_sameClientKey(a, b) {
+		return !!a && !!b && a.kind === b.kind && a.id === b.id;
+	}
+	_mapForKind(kind) {
+		switch (kind) {
+			case "operator": return this._operators;
+			case "user": return this._others;
+			default: return assertExhaustive(kind);
+		}
+	}
+	_presenceSeqsForKind(kind) {
+		switch (kind) {
+			case "operator": return this._presenceSeqs.operator;
+			case "user": return this._presenceSeqs.user;
+			default: return assertExhaustive(kind);
+		}
+	}
+	_connectionsForKind(kind) {
+		switch (kind) {
+			case "operator": return this._idMap.fromClientKey.operator;
+			case "user": return this._idMap.fromClientKey.user;
+			default: return assertExhaustive(kind);
+		}
+	}
+	_getByClientKey(clientKey) {
+		return this._mapForKind(clientKey.kind).get(clientKey.id) ?? null;
+	}
+	/**
+	* Extra-tab joins and occupancy snapshots only replace presence when the
+	* incoming seq is a newer number. Connecting with no seq is not an
+	* interact. Equal seqs keep the value already applied.
+	*/
+	_isNewerPresenceSeq(clientKey, incoming) {
+		return this._isNewerPresenceSeqValue(this._presenceSeqsForKind(clientKey.kind).get(clientKey.id), incoming);
+	}
+	_isNewerPresenceSeqValue(previous, incoming) {
+		if (typeof incoming !== "number") return false;
+		if (typeof previous !== "number") return true;
+		return incoming > previous;
+	}
+	/**
+	* Local writes omit a seq and always apply. Remote writes apply when the
+	* seq is newer or equal (last-applied wins among equal seqs).
+	* A null seq applies only when we do not already have one.
+	*/
+	_shouldApplyPresenceSeq(clientKey, incoming) {
+		if (incoming === void 0) return true;
+		if (typeof incoming !== "number") return typeof this._presenceSeqsForKind(clientKey.kind).get(clientKey.id) !== "number";
+		const previous = this._presenceSeqsForKind(clientKey.kind).get(clientKey.id);
+		if (typeof previous !== "number") return true;
+		return incoming >= previous;
+	}
+	_setPresenceSeq(clientKey, incoming) {
+		if (typeof incoming === "number") {
+			this._presenceSeqsForKind(clientKey.kind).set(clientKey.id, incoming);
+			return;
+		}
+		if (incoming === void 0) return;
+		this._presenceSeqsForKind(clientKey.kind).set(clientKey.id, null);
+	}
+	_deleteConnectionId(connectionId) {
+		const clientKey = this._clientKeyForConnection(connectionId);
+		this._idMap.fromConnectionId.delete(connectionId);
+		if (!clientKey) return;
+		const connections = this._connectionsForKind(clientKey.kind);
+		const set = connections.get(clientKey.id) ?? null;
+		if (!set) return;
+		set.delete(connectionId);
+		if (!!set.size) return;
+		connections.delete(clientKey.id);
+	}
+	_getConnectionIds(clientKey) {
+		return this._connectionsForKind(clientKey.kind).get(clientKey.id) ?? null;
+	}
+	_setConnectionId(connectionId, clientKey) {
+		const connections = this._connectionsForKind(clientKey.kind);
+		const updated = (connections.get(clientKey.id) ?? /* @__PURE__ */ new Set()).add(connectionId);
+		this._idMap.fromConnectionId.set(connectionId, clientKey);
+		connections.set(clientKey.id, updated);
+		return updated;
+	}
+};
+// src/UsersNotifier.ts
+var UsersNotifier = class {
+	constructor() {
+		this.others = makeSubject();
+		this._otherSubjects = {
+			operator: /* @__PURE__ */ new Map(),
+			user: /* @__PURE__ */ new Map()
+		};
+	}
+	clear() {
+		this._subjectsForKind("user").forEach((subject) => {
+			subject.next(null);
+		});
+		this._subjectsForKind("operator").forEach((subject) => {
+			subject.next(null);
+		});
+		this._subjectsForKind("user").clear();
+		this._subjectsForKind("operator").clear();
+	}
+	delete(params) {
+		const { id, kind } = params;
+		const subjects = this._subjectsForKind(kind);
+		const subject = subjects.get(id);
+		if (!subject) return;
+		subject.next(null);
+		subjects.delete(id);
+	}
+	other(params) {
+		const { id, kind } = params;
+		const subjects = this._subjectsForKind(kind);
+		const subject = subjects.get(id);
+		if (subject) return subject;
+		const created = makeSubject();
+		subjects.set(id, created);
+		return created;
+	}
+	subscribeOther(id, callback, options) {
+		const kind = options?.kind ?? "user";
+		const subscription = subscribe(callback)(this.other({
+			id,
+			kind
+		}).source);
+		return () => {
+			subscription.unsubscribe();
+		};
+	}
+	subscribeOthers(callback, options) {
+		const kinds = options?.kinds ?? ["user"];
+		const subscription = subscribe(({ others, event }) => {
+			switch (event.kind) {
+				case "clear":
+				case "sync": break;
+				case "enter":
+				case "leave":
+				case "update":
+					if (!kinds.includes(event.user.kind)) return;
+					break;
+				default: assertExhaustive(event);
+			}
+			callback(others, event);
+		})(this.others.source);
+		return () => {
+			subscription.unsubscribe();
+		};
+	}
+	_subjectsForKind(kind) {
+		switch (kind) {
+			case "operator": return this._otherSubjects.operator;
+			case "user": return this._otherSubjects.user;
+			default: return assertExhaustive(kind);
+		}
+	}
+};
+// src/utils/sequenceCommit.ts
+/**
+* Runs `commit` after earlier commits. `ready` should already be running.
+* A rejection, or a throw from `commit`, is logged, and the next call still runs.
+* The storage caller returns before the write. This promise only orders the next commit.
+*/
+const sequenceCommit = (params) => {
+	return params.tail.then(() => params.ready).then((value) => {
+		try {
+			params.commit(value);
+		} catch (error) {
+			console.error(error);
+		}
+	}, (error) => {
+		console.error(error);
+	});
+};
+// 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/inRange.ts
+const inRange = (value, range) => {
+	const { max, min } = range;
+	return Number.isInteger(value) && value >= min && value <= max;
+};
+// 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._errorSubject = makeSubject();
+		this._intervals = { heartbeat: null };
+		this._listenerManager = new ListenerManager();
+		this._requests = new PendingRequestManager();
+		this._stateNotifier = new StateNotifier();
+		this._subscriptions = { observeCrdt: null };
+		this._timeouts = {
+			pong: null,
+			reconnect: null
+		};
+		this._usersNotifier = new UsersNotifier();
+		this._roomStats = {
+			connectionCount: 0,
+			userCount: 0
+		};
+		this._operatorStats = {
+			connectionCount: 0,
+			userCount: 0
+		};
+		this._lastMetadata = null;
+		this._seq = { presence: 0 };
+		this._storageSync = new StorageSync();
+		this._state = {
+			authorization: {
+				token: null,
+				user: null,
+				kind: "user",
+				operator: null
+			},
+			connection: {
+				attempts: 0,
+				id: null,
+				state: ConnectionState$1.Untouched
+			},
+			storage: { state: StorageState.Unavailable },
+			webSocket: null
+		};
+		this._windowListeners = null;
+		this._wsListeners = null;
+		this._storageProcedureNames = [];
+		this._storageCommits = Promise.resolve();
+		this.broadcast = new Proxy(async (event, data) => {
+			if (!this._state.webSocket) return;
+			if (this._state.connection.state !== ConnectionState$1.Open) return;
+			this._sendMessage({
+				data,
+				type: event.toString()
+			});
+		}, { 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 = (userId, options) => {
+			return this._usersManager.getOther(userId, options);
+		};
+		this.getOtherByConnectionId = (connectionId, options) => {
+			return this._usersManager.getOtherByConnectionId(connectionId, options);
+		};
+		this.getOthers = (options) => {
+			return this._usersManager.getOthers(options);
+		};
+		this.getRoomStats = (options) => {
+			const kinds = options?.kinds;
+			if (kinds === void 0) return this._roomStats;
+			if (kinds.length === 0) return {
+				connectionCount: 0,
+				userCount: 0
+			};
+			const includeUsers = kinds.includes("user");
+			const includeOperators = kinds.includes("operator");
+			return {
+				connectionCount: (includeUsers ? this._roomStats.connectionCount : 0) + (includeOperators ? this._operatorStats.connectionCount : 0),
+				userCount: (includeUsers ? this._roomStats.userCount : 0) + (includeOperators ? this._operatorStats.userCount : 0)
+			};
+		};
+		this.getStorage = (type) => {
+			if (!this.getStorageLoaded()) return null;
+			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.listUsers = (options = {}) => {
+			const resolved = options.limit ?? 50;
+			if (!inRange(resolved, {
+				min: 1,
+				max: 100
+			})) return Promise.resolve({
+				success: false,
+				error: {
+					code: "INVALID_LIMIT",
+					message: `Invalid listUsers limit. Limit must be an integer from 1 to ${100 .toLocaleString()}. Received: ${String(options.limit)}.`
+				}
+			});
+			if (!this._state.webSocket || this._state.connection.state !== ConnectionState$1.Open) return Promise.resolve({
+				success: false,
+				error: {
+					code: "NOT_CONNECTED",
+					message: "Room is not connected"
+				}
+			});
+			const { promise, requestId } = this._requests.request({
+				onAbort: () => ({
+					success: false,
+					error: {
+						code: "NOT_CONNECTED",
+						message: "Room is not connected"
+					}
+				}),
+				onTimeout: () => ({
+					success: false,
+					error: {
+						code: "FAILED",
+						message: "listUsers timed out"
+					}
+				}),
+				timeoutMs: LIST_USERS_TIMEOUT_MS
+			});
+			this._sendMessage({
+				type: "$listUsers",
+				data: {
+					cursor: options.cursor ?? null,
+					kinds: options.kinds,
+					limit: resolved,
+					requestId
+				}
+			});
+			return promise;
+		};
+		this.presence = new Proxy(async (name, data) => {
+			await this._runPresenceProcedure(name, data);
+		}, { get(fn, prop) {
+			return (data) => fn(prop, data);
+		} });
+		this.redo = () => {
+			this._crdtManager.doc.redo();
+		};
+		this.storage = new Proxy((name, data) => {
+			this._runStorageProcedure(name, data);
+		}, { get(fn, prop) {
+			return (data) => fn(prop, data);
+		} });
+		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 === "error") return (callback) => {
+				const subscription = subscribe(callback)(this._errorSubject.source);
+				return () => {
+					subscription.unsubscribe();
+				};
+			};
+			if (prop === "myPresence") return (callback) => {
+				return fn("my-presence", callback);
+			};
+			if (prop === "myself") return (callback) => {
+				return fn("myself", callback);
+			};
+			if (prop === "others") return (callback, options) => {
+				return this._usersNotifier.subscribeOthers((_listed, event) => {
+					const others = this._usersManager.getOthers(options);
+					if (event.kind === "sync") {
+						callback(others, {
+							kind: "sync",
+							users: others
+						});
+						return;
+					}
+					callback(others, event);
+				}, options);
+			};
+			if (prop === "roomStats") return (callback) => {
+				return fn("roomStats", 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;
+			throw new Error(`Unknown subject: ${prop.toString()}`);
+		} });
+		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 = async (presence) => {
+			await this._applyMyPresence(presence);
+		};
+		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 = (userId, callback, options) => {
+			return this._usersNotifier.subscribeOther(userId, callback, options);
+		};
+		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, reconnectTimeoutMs = RECONNECT_TIMEOUT_MS, storage: crdtStorage, treaty, 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;
+		this._listeners = { onAuthorizationFail: (error) => {
+			onAuthorizationFail?.(error);
+		} };
+		this._treaty = treaty;
+		this._usersManager = new UsersManager({
+			initialPresence,
+			limits: this._limits,
+			presence
+		});
+		this._crdtManager = new CrdtManager({
+			initialStorage,
+			storage: crdtStorage
+		});
+	}
+	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 {
+			authToken = await this._getAuthorization(this.id, params);
+			if (authToken) url.searchParams.set("token", encodeURIComponent(authToken));
+			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 = StorageState.Unavailable;
+			oldState.webSocket = null;
+			return oldState;
+		});
+		await this._storageStore.destroy();
+		this._crdtManager.destroy();
+		this._observeCrdt();
+		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 _applyMyPresence(presence, procedure) {
+		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);
+		if (!!this._state.webSocket && this._state.connection.state === ConnectionState$1.Open) this._usersManager.beginLocalPresenceWrite();
+		await this.broadcast("$updatePresence", {
+			presence: newPresence,
+			...procedure ? { procedure } : {}
+		});
+	}
+	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._storageSync.reset();
+		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._roomStats = {
+			connectionCount: 0,
+			userCount: 0
+		};
+		this._operatorStats = {
+			connectionCount: 0,
+			userCount: 0
+		};
+		this._stateNotifier.subjects.roomStats.next(this._roomStats);
+		this._requests.failAll();
+		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);
+			acc[prop] = serialized;
+			return acc;
+		}, {});
+		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 });
+		}
+	}
+	_getWsEndpoint(room, params) {
+		const metadata = params.metadata;
+		switch (typeof this._endpoints.wsEndpoint) {
+			case "undefined": return `/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 isMyself = this._usersManager.isMyselfConnection(connectionId);
+		const deleted = this._usersManager.deleteConnection(connectionId);
+		const others = this._usersManager.getOthers();
+		this._stateNotifier.subjects.others.next(others);
+		if (!deleted) {
+			if (isMyself) return;
+			console.warn("Could not identify exited connection");
+			return;
+		}
+		const { data: user, remaining } = deleted;
+		if (remaining) return;
+		this._usersNotifier.others.next({
+			others,
+			event: {
+				kind: "leave",
+				user
+			}
+		});
+		this._deleteOtherNotifier({
+			id: this._usersManager.getParticipantId(user),
+			kind: user.kind
+		});
+	}
+	_handlePresenceUpdatedMessage(message) {
+		const { connectionId } = message;
+		if (!connectionId) return;
+		if (!this._state.webSocket) throw new Error("Could not find WebSocket");
+		const data = message.data;
+		/**
+		* This is our own presence coming back from the server. Ignore it if we
+		* have already sent a newer local update, so a burst of writes (for
+		* example dragging) cannot snap backward. Apply the last reply so we
+		* can still pick up a newer value from another tab.
+		*/
+		if (connectionId === this._state.connection.id && !this._usersManager.ackOwnPresenceEcho()) return;
+		const patched = this._usersManager.patchPresence({
+			connectionId,
+			...data
+		});
+		if (!patched) {
+			/**
+			* !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,
+				data: message.user,
+				kind: data.session.kind,
+				operator: data.session.operator,
+				presence: data.session.presence,
+				presenceSeq: data.session.seq.presence
+			});
+			if (!added.presenceChanged) return;
+			const other = this._usersManager.getOtherByConnectionId(connectionId, { kinds: ["user", "operator"] });
+			const others = this._usersManager.getOthers();
+			if (other) this._notifyOther(other);
+			this._stateNotifier.subjects.others.next(others);
+			this._usersNotifier.others.next({
+				others,
+				event: {
+					kind: "update",
+					user: added.data
+				}
+			});
+			return;
+		}
+		if (!patched.applied) return;
+		const updated = patched.presence;
+		if (this._usersManager.isMyselfConnection(connectionId)) {
+			this._stateNotifier.subjects["my-presence"].next(updated);
+			this._stateNotifier.subjects.myself.next(this._usersManager.myself);
+			return;
+		}
+		const other = this._usersManager.getOtherByConnectionId(connectionId, { kinds: ["user", "operator"] });
+		const others = this._usersManager.getOthers();
+		if (other) this._notifyOther(other);
+		this._stateNotifier.subjects.others.next(others);
+		if (other) this._usersNotifier.others.next({
+			others,
+			event: {
+				kind: "update",
+				user: other
+			}
+		});
+	}
+	_handleReceiveOthers(message) {
+		if (!this._state.webSocket) throw new Error("Could not find WebSocket");
+		const data = message.data;
+		const leftIds = this._usersManager.replaceOthers(data.others.map((other) => ({
+			connectionIds: other.connectionIds,
+			data: other.data,
+			kind: other.session.kind,
+			operator: other.session.operator,
+			presence: other.session.presence,
+			presenceSeq: other.session.seq.presence
+		})));
+		this._usersManager.setMyConnectionIds(data.myConnectionIds);
+		leftIds.forEach((subject) => {
+			this._deleteOtherNotifier(subject);
+		});
+		data.others.forEach((row) => {
+			const connectionId = row.connectionIds[0];
+			if (!connectionId) return;
+			const other = this._usersManager.getOtherByConnectionId(connectionId, { kinds: ["user", "operator"] });
+			if (other) this._notifyOther(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._setRoomStats(data.stats);
+		this._updateState((oldState) => {
+			oldState.connection.id = connectionId;
+			oldState.authorization.user = user;
+			oldState.authorization.kind = data.session.kind;
+			oldState.authorization.operator = data.session.operator;
+			return oldState;
+		});
+		this._usersManager.setMyself({
+			connectionId,
+			data: user,
+			kind: data.session.kind,
+			operator: data.session.operator,
+			presence: data.session.presence ?? void 0,
+			presenceSeq: data.session.seq.presence
+		});
+		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,
+				stateVector: this._crdtManager.doc.getStateVector(),
+				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
+			});
+			this._addToStorageStore(encodedState);
+		}
+		for (const update of this._storageSync.markReady()) this._crdtManager.doc.applyEncodedState({
+			origin: ORIGIN_STORAGE_UPDATED,
+			update
+		});
+		const encodedState = this._crdtManager.doc.getEncodedState();
+		this._updateState((oldState) => {
+			oldState.storage.state = StorageState.Synced;
+			return oldState;
+		});
+		this._emitSharedTypes();
+		this._observeCrdt();
+		this._stateNotifier.subjects["storage-loaded"].next(true);
+		this._settleStorageDiff({
+			fromDiff: false,
+			moved: 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;
+		if (!this._storageSync.isReady) {
+			this._storageSync.hold(data.state);
+			return;
+		}
+		this._applyRemoteStorage(data.state, { fromDiff: false });
+	}
+	_handleStorageDiffMessage(message) {
+		const { connectionId } = message;
+		if (!connectionId) return;
+		if (!this._state.webSocket) throw new Error("Could not find WebSocket");
+		const data = message.data;
+		if (!this._storageSync.isReady) {
+			if (data.update) this._storageSync.hold(data.update);
+			return;
+		}
+		if (!data.update) {
+			if (this._crdtManager.doc.hasPending() || !this._crdtManager.doc.canDetectPending()) this._noteUnchangedStorage();
+			return;
+		}
+		this._applyRemoteStorage(data.update, { fromDiff: true });
+	}
+	_handleStorageResyncMessage(message) {
+		const { connectionId } = message;
+		if (!connectionId || connectionId !== this._state.connection.id) return;
+		if (!this._state.webSocket) return;
+		const stateVector = message.data.stateVector;
+		if (!stateVector) return;
+		const update = this._crdtManager.doc.encodeDiff(stateVector);
+		if (!update) return;
+		this._sendMessage({
+			type: "$updateStorage",
+			data: {
+				origin: connectionId,
+				resync: true,
+				update
+			}
+		});
+	}
+	_applyRemoteStorage(update, params) {
+		const before = this._crdtManager.doc.getStateVector();
+		this._crdtManager.doc.applyEncodedState({
+			origin: ORIGIN_STORAGE_UPDATED,
+			update
+		});
+		const moved = this._crdtManager.doc.getStateVector() !== before;
+		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);
+			acc[prop] = serialized;
+			return acc;
+		}, {});
+		this._crdtNotifier.rootSubject.next(storageRoot);
+		this._settleStorageDiff({
+			fromDiff: params.fromDiff,
+			moved
+		});
+	}
+	_noteUnchangedStorage() {
+		if (!this._storageSync.noteStall()) return;
+		console.warn("Storage update did not change the document");
+	}
+	_settleStorageDiff(params) {
+		const { fromDiff, moved } = params;
+		const doc = this._crdtManager.doc;
+		if (!(doc.hasPending() || !doc.canDetectPending())) {
+			this._storageSync.clearStall();
+			return;
+		}
+		if (fromDiff && !moved) {
+			this._noteUnchangedStorage();
+			return;
+		}
+		this._storageSync.clearStall();
+		this._requestStorageDiff();
+	}
+	_requestStorageDiff() {
+		const webSocket = this._state.webSocket;
+		if (!webSocket || webSocket.readyState !== WebSocket.OPEN) return;
+		this._sendMessage({
+			type: "$syncStorage",
+			data: { stateVector: this._crdtManager.doc.canDetectPending() ? this._crdtManager.doc.getStateVector() : "" }
+		});
+	}
+	_handleSyncStateReceived(message) {
+		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.pruneConnections(active).forEach((quitter) => {
+			const remaining = this._usersManager.getOthers();
+			this._deleteOtherNotifier({
+				id: this._usersManager.getParticipantId(quitter),
+				kind: quitter.kind
+			});
+			this._usersNotifier.others.next({
+				others: remaining,
+				event: {
+					kind: "leave",
+					user: quitter
+				}
+			});
+		});
+		const remaining = this._usersManager.getOthers();
+		this._stateNotifier.subjects.others.next(remaining);
+	}
+	_handleRoomError(message) {
+		const data = message.data;
+		this._errorSubject.next({
+			message: data.message,
+			stack: data.stack ?? null
+		});
+	}
+	_handleRoomStats(message) {
+		const data = message.data;
+		this._setRoomStats(data);
+	}
+	_handleUsersPage(message) {
+		const data = message.data;
+		this._requests.complete(data.requestId, data.success ? {
+			success: true,
+			pageInfo: data.pageInfo,
+			users: data.users
+		} : {
+			success: false,
+			error: data.error
+		});
+	}
+	_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 (connectionId === this._state.connection.id) {
+			this._sendMessage({
+				type: "$getOthers",
+				data: {}
+			});
+			return;
+		}
+		const added = this._usersManager.addConnection({
+			connectionId,
+			data: data.user,
+			kind: data.session.kind,
+			operator: data.session.operator,
+			presence: data.session.presence,
+			presenceSeq: data.session.seq.presence
+		});
+		if (added.isMyself) return;
+		const other = this._usersManager.getOtherByConnectionId(connectionId, { kinds: ["user", "operator"] });
+		const others = this._usersManager.getOthers();
+		if (added.remaining !== 1) {
+			if (!added.presenceChanged || !other) return;
+			this._notifyOther(other);
+			this._stateNotifier.subjects.others.next(others);
+			this._usersNotifier.others.next({
+				others,
+				event: {
+					kind: "update",
+					user: other
+				}
+			});
+			return;
+		}
+		if (other) this._notifyOther(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 && !!this._state.connection.id && this._state.webSocket.readyState === WebSocket.OPEN)) {
+				this._logDebug("Dropped a storage update: storage is not syncing");
+				return;
+			}
+			this._sendMessage({
+				type: "$updateStorage",
+				data: {
+					origin,
+					update: event.update,
+					...this._storageProcedureNames.at(-1) ? { procedure: this._storageProcedureNames.at(-1) } : {}
+				}
+			});
+		});
+		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);
+		if (!message.type.startsWith("$")) this._eventNotifier.subject(message.type).next(message);
+		switch (message.type) {
+			case "$error":
+				this._handleRoomError(message);
+				return;
+			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 "$roomStats":
+				this._handleRoomStats(message);
+				return;
+			case "$storageReceived":
+				this._handleStorageReceivedMessage(message);
+				return;
+			case "$storageDiff":
+				this._handleStorageDiffMessage(message);
+				return;
+			case "$storageResync":
+				this._handleStorageResyncMessage(message);
+				return;
+			case "$storageUpdated":
+				this._handleStorageUpdatedMessage(message);
+				return;
+			case "$syncStateReceived":
+				this._handleSyncStateReceived(message);
+				return;
+			case "$userJoined":
+				this._handleUserJoinedMessage(message);
+				return;
+			case "$usersPage":
+				this._handleUsersPage(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);
+	}
+	async _runPresenceProcedure(name, data) {
+		const procedures = this._treaty._defs.procedures.presence;
+		if (!procedures || !Object.hasOwn(procedures, name)) throw new Error(`Unknown presence procedure "${name}"`);
+		const procedure = procedures[name];
+		const myself = this._usersManager.myself;
+		if (!myself) throw new Error("Cannot run a treaty procedure before the local user is available");
+		const doc = this._crdtManager.doc;
+		const seq = ++this._seq.presence;
+		const patch = await procedure.apply(data, {
+			user: myself.data,
+			operator: myself.operator,
+			presence: this.getMyPresence(),
+			doc
+		});
+		if (seq !== this._seq.presence) return;
+		await this._applyMyPresence(patch, name);
+	}
+	_runStorageProcedure(name, data) {
+		if (!this.getStorageLoaded()) throw new Error("Cannot run a treaty storage procedure until storage is loaded");
+		if (typeof this._state.connection.id !== "string") throw new Error("Cannot run a treaty storage procedure without a connection id");
+		const procedures = this._treaty._defs.procedures.storage;
+		if (!procedures || !Object.hasOwn(procedures, name)) throw new Error(`Unknown storage procedure "${name}"`);
+		const procedure = procedures[name];
+		const myself = this._usersManager.myself;
+		if (!myself) throw new Error("Cannot run a treaty procedure before the local user is available");
+		const presence = this.getMyPresence();
+		const commit = (loaded) => {
+			if (!this.getStorageLoaded()) return;
+			const doc = this._crdtManager.doc;
+			const apply = () => {
+				procedure.apply(loaded ? loaded.input : data, {
+					user: myself.data,
+					operator: myself.operator,
+					presence,
+					doc
+				}, loaded?.prepared);
+			};
+			this._storageProcedureNames.push(name);
+			try {
+				if (procedure.config.transact === false) {
+					apply();
+					return;
+				}
+				this.transact(() => {
+					apply();
+				});
+			} finally {
+				this._storageProcedureNames.pop();
+			}
+		};
+		if (!procedure.prepared || !procedure.load) {
+			commit(void 0);
+			return;
+		}
+		const loading = procedure.load(data, {
+			user: myself.data,
+			operator: myself.operator,
+			presence
+		});
+		this._storageCommits = sequenceCommit({
+			tail: this._storageCommits,
+			ready: loading,
+			commit
+		});
+	}
+	_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 ? parsePluvSchema(this.metadata, metadata) : metadata;
+		this._lastMetadata = parsed;
+		return parsed;
+	}
+	#_storage;
+	_setRoomStats(stats) {
+		this._roomStats = stats.user;
+		this._operatorStats = stats.operator;
+		this._stateNotifier.subjects.roomStats.next(this._roomStats);
+	}
+	_notifyOther(other) {
+		this._usersNotifier.other({
+			id: this._usersManager.getParticipantId(other),
+			kind: other.kind
+		}).next(other);
+	}
+	_deleteOtherNotifier(params) {
+		this._usersNotifier.delete(params);
+	}
+	_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;
+	}
+};
+// src/PluvClient.ts
+var PluvClient = class {
+	get _defs() {
+		return {
+			initialStorage: this._initialStorage,
+			storage: this._treaty.storage,
+			treaty: this._treaty
+		};
+	}
+	constructor(options) {
+		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._treaty.presence,
+				reconnectTimeoutMs: options.reconnectTimeoutMs,
+				storage: this._treaty.storage ?? noop.doc(),
+				treaty: this._treaty,
+				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;
+			const roomId = typeof room === "string" ? room : room.id;
+			if (!toEnter) throw new Error(`Could not find room: ${roomId}.`);
+			this._rooms.set(toEnter.id, toEnter);
+			await toEnter.connect(...args);
+			this._logDebug(`Entered room: ${roomId}`);
+			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: ${toLeave.id}`);
+		};
+		const { authEndpoint, debug = false, initialStorage, limits, metadata, treaty, wsEndpoint } = options;
+		this.metadata = metadata;
+		if (metadata) assertSerializingSchema(metadata);
+		this._authEndpoint = authEndpoint;
+		this._debug = debug;
+		this._initialStorage = initialStorage;
+		this._limits = {
+			presenceMaxSize: 512,
+			...limits
+		};
+		this._treaty = treaty;
+		this._wsEndpoint = wsEndpoint;
+	}
+	_logDebug(...data) {
+		if (typeof process === "undefined") return;
+		if (process.env?.NODE_ENV === "production") return;
+		if (this._debug) console.log(...data);
+	}
+};
+// src/createClient.ts
+const createClient = () => ({ config: ((options) => new PluvClient(options)) });
+// src/MockedRoom.ts
+const participantOrder = (kind) => {
+	switch (kind) {
+		case "user": return 0;
+		case "operator": return 1;
+		default: return assertExhaustive(kind);
+	}
+};
+var MockedRoom = class {
+	constructor(room, options) {
+		this._crdtNotifier = new CrdtNotifier();
+		this._eventNotifier = new EventNotifier();
+		this._errorSubject = makeSubject();
+		this._usersNotifier = new UsersNotifier();
+		this._seq = { presence: 0 };
+		this._storageCommits = Promise.resolve();
+		this._state = {
+			authorization: {
+				token: null,
+				user: null,
+				kind: "user",
+				operator: 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) => {
+			this._simulateEvent(event, 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 = (userId, options) => {
+			return this._usersManager.getOther(userId, options);
+		};
+		this.getOtherByConnectionId = (connectionId, options) => {
+			return this._usersManager.getOtherByConnectionId(connectionId, options);
+		};
+		this.getOthers = (options) => {
+			return this._usersManager.getOthers(options);
+		};
+		this.getRoomStats = (options) => {
+			return this._usersManager.getOccupancy(options);
+		};
+		this.getStorage = (type) => {
+			const sharedType = this._crdtManager.get(type);
+			if (typeof sharedType === "undefined") return null;
+			return sharedType;
+		};
+		this.listUsers = (options = {}) => {
+			const kinds = new Set(options.kinds ?? ["user"]);
+			const myself = this._usersManager.myself;
+			const users = [...myself && kinds.has(myself.kind) ? [myself] : [], ...this._usersManager.getOthers({ kinds: [...kinds] })].map((person) => ({
+				data: person.data,
+				kind: person.kind,
+				operator: person.operator
+			})).toSorted((left, right) => {
+				const byKind = participantOrder(left.kind) - participantOrder(right.kind);
+				if (byKind !== 0) return byKind;
+				const a = String(left.data.id);
+				const b = String(right.data.id);
+				if (a < b) return -1;
+				if (a > b) return 1;
+				return 0;
+			});
+			const last = users.at(-1);
+			return Promise.resolve({
+				success: true,
+				pageInfo: {
+					endCursor: last ? {
+						kind: last.kind,
+						id: String(last.data.id)
+					} : null,
+					hasNextPage: false
+				},
+				users
+			});
+		};
+		this.presence = new Proxy(async (name, data) => {
+			await this._runPresenceProcedure(name, data);
+		}, { get(fn, prop) {
+			return (data) => fn(prop, data);
+		} });
+		this.redo = () => {
+			this._crdtManager.doc.redo();
+		};
+		this.storage = new Proxy((name, data) => {
+			this._runStorageProcedure(name, data);
+		}, { get(fn, prop) {
+			return (data) => fn(prop, data);
+		} });
+		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 === "error") return (callback) => {
+				const subscription = subscribe(callback)(this._errorSubject.source);
+				return () => {
+					subscription.unsubscribe();
+				};
+			};
+			if (prop === "myPresence") return (callback) => {
+				return fn("my-presence", callback);
+			};
+			if (prop === "myself") return (callback) => {
+				return fn("myself", callback);
+			};
+			if (prop === "others") return (callback, options) => {
+				return this._usersNotifier.subscribeOthers((_listed, event) => {
+					const others = this._usersManager.getOthers(options);
+					if (event.kind === "sync") {
+						callback(others, {
+							kind: "sync",
+							users: others
+						});
+						return;
+					}
+					callback(others, event);
+				}, options);
+			};
+			if (prop === "roomStats") return (callback) => {
+				return fn("roomStats", 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;
+			throw new Error(`Unknown subscription: ${String(prop)}`);
+		} });
+		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) => {
+			this._applyMyPresence(presence);
+		};
+		this._event = new Proxy((event, callback) => this._eventNotifier.subscribe(event, callback), { get(fn, prop) {
+			return (callback) => fn(prop, callback);
+		} });
+		this._other = (userId, callback, options) => {
+			return this._usersNotifier.subscribeOther(userId, callback, options);
+		};
+		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, myself, presence, storage, treaty } = options;
+		this.id = room;
+		this._events = events;
+		this._limits = {
+			presenceMaxSize: 512,
+			...limits
+		};
+		this._treaty = treaty;
+		this._usersManager = new UsersManager({
+			initialPresence,
+			limits: this._limits,
+			presence
+		});
+		if (myself) {
+			const connectionId = myself.connectionId ?? "mocked";
+			const kind = myself.kind ?? "user";
+			this._usersManager.setMyself({
+				connectionId,
+				data: myself.data,
+				kind,
+				operator: myself.operator,
+				presence: initialPresence
+			});
+			this._state.authorization.user = myself.data;
+			this._state.authorization.kind = kind;
+			this._state.authorization.operator = myself.operator ?? null;
+			this._state.connection.id = connectionId;
+			this._state.connection.state = ConnectionState$1.Open;
+		}
+		this._publishRoomStats();
+		this._crdtManager = new CrdtManager({
+			initialStorage,
+			storage
+		});
+		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;
+	}
+	_applyMyPresence(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);
+	}
+	_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);
+				acc[prop] = serialized;
+				return acc;
+			}, {});
+			this._crdtNotifier.rootSubject.next(storageRoot);
+		});
+		this._subscriptions.observeCrdt = unsubscribe;
+	}
+	_publishRoomStats() {
+		this._stateNotifier.subjects.roomStats.next(this._usersManager.getOccupancy());
+	}
+	async _runPresenceProcedure(name, data) {
+		const procedures = this._treaty._defs.procedures.presence;
+		if (!procedures || !Object.hasOwn(procedures, name)) throw new Error(`Unknown presence procedure "${name}"`);
+		const procedure = procedures[name];
+		const myself = this._usersManager.myself;
+		if (!myself) throw new Error("Cannot run a treaty procedure before the local user is available");
+		const doc = this._crdtManager.doc;
+		const seq = ++this._seq.presence;
+		const patch = await procedure.apply(data, {
+			user: myself.data,
+			operator: myself.operator,
+			presence: this.getMyPresence(),
+			doc
+		});
+		if (seq !== this._seq.presence) return;
+		this._applyMyPresence(patch);
+	}
+	_runStorageProcedure(name, data) {
+		const origin = this._state.connection.id ?? "mocked";
+		const procedures = this._treaty._defs.procedures.storage;
+		if (!procedures || !Object.hasOwn(procedures, name)) throw new Error(`Unknown storage procedure "${name}"`);
+		const procedure = procedures[name];
+		const myself = this._usersManager.myself;
+		if (!myself) throw new Error("Cannot run a treaty procedure before the local user is available");
+		const presence = this.getMyPresence();
+		const commit = (loaded) => {
+			if (!this.getStorageLoaded()) return;
+			const doc = this._crdtManager.doc;
+			const apply = () => {
+				procedure.apply(loaded ? loaded.input : data, {
+					user: myself.data,
+					operator: myself.operator,
+					presence,
+					doc
+				}, loaded?.prepared);
+			};
+			if (procedure.config.transact === false) {
+				apply();
+				return;
+			}
+			this.transact(() => {
+				apply();
+			}, origin);
+		};
+		if (!procedure.prepared || !procedure.load) {
+			commit(void 0);
+			return;
+		}
+		const loading = procedure.load(data, {
+			user: myself.data,
+			operator: myself.operator,
+			presence
+		});
+		this._storageCommits = sequenceCommit({
+			tail: this._storageCommits,
+			ready: loading,
+			commit
+		});
+	}
+	_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((outputType) => {
+			const _type = outputType;
+			const outputData = result[_type];
+			if (!outputData) return;
+			this._eventNotifier.subject(_type).next({
+				connectionId: this._state.connection.id,
+				data: outputData,
+				operator: this._state.authorization.operator,
+				room: this.id,
+				type: _type,
+				user: this._state.authorization.user
+			});
+		});
+	}
+	#_storage;
+};
+export { AbstractStorageStore, ConnectionState, MockedRoom, PluvClient, PluvRoom, createClient, parsePluvSchema };
+
+//# sourceMappingURL=index.mjs.map