@pluv/io 5.0.1 → 5.0.3

package/dist/index.mjs

@@ -0,0 +1,1427 @@
+import { makeSubject, subscribe } from "wonka";
+import { hkdf } from "@panva/hkdf";
+import { EncryptJWT, jwtDecrypt } from "jose";
+import { noop } from "@pluv/crdt";
+import colors from "kleur";
+//#region src/AbstractPersistence.ts
+var AbstractPersistence = class {};
+//#endregion
+//#region src/Persistence.ts
+var Persistence = class extends AbstractPersistence {
+	_storages = /* @__PURE__ */ new Map();
+	_users = /* @__PURE__ */ new Map();
+	addUser(room, connectionId, user) {
+		const users = this._users.get(room) ?? /* @__PURE__ */ new Map();
+		this._users.set(room, users);
+		users.set(connectionId, user);
+		return Promise.resolve();
+	}
+	deleteStorageState(room) {
+		this._storages.delete(room);
+		return Promise.resolve();
+	}
+	async deleteUser(room, connectionId) {
+		const users = this._users.get(room);
+		if (!users) return;
+		users.delete(connectionId);
+		if (!users.size) {
+			await this.deleteUsers(room);
+			await this.deleteStorageState(room);
+		}
+		return Promise.resolve();
+	}
+	deleteUsers(room) {
+		this._users.delete(room);
+		return Promise.resolve();
+	}
+	getSize(room) {
+		return Promise.resolve(this._users.get(room)?.size ?? 0);
+	}
+	getStorageState(room) {
+		const storage = this._storages.get(room) ?? null;
+		return Promise.resolve(storage);
+	}
+	getUser(room, connectionId) {
+		const user = this._users.get(room)?.get(connectionId);
+		return Promise.resolve(user ?? null);
+	}
+	async getUsers(room) {
+		const users = this._users.get(room);
+		if (!users) return /* @__PURE__ */ new Map();
+		return users;
+	}
+	async getUsersSize(room) {
+		return this._users.size;
+	}
+	initialize(roomContext) {
+		return this;
+	}
+	setStorageState(room, state) {
+		this._storages.set(room, state);
+		return Promise.resolve();
+	}
+};
+//#endregion
+//#region src/AbstractPubSub.ts
+var AbstractPubSub = class {};
+//#endregion
+//#region src/PubSub.ts
+var PubSub = class extends AbstractPubSub {
+	_currentSubscriptionId = 0;
+	_subjects = /* @__PURE__ */ new Map();
+	_subscriptionsRefs = /* @__PURE__ */ new Map();
+	_unsubscriptions = /* @__PURE__ */ new Map();
+	async publish(roomName, payload) {
+		const subject = this._subjects.get(roomName);
+		if (!subject) return;
+		Promise.resolve(subject.next(payload));
+	}
+	subscribe(roomName, onMessage) {
+		const id = this._currentSubscriptionId++;
+		const refs = this._subscriptionsRefs.get(roomName) ?? [];
+		const subject = makeSubject();
+		this._subjects.set(roomName, subject);
+		this._subscriptionsRefs.set(roomName, [...refs, id]);
+		const unsubscribe = subscribe(onMessage)(subject.source).unsubscribe;
+		this._unsubscriptions.set(id, [roomName, unsubscribe]);
+		return Promise.resolve(id);
+	}
+	unsubscribe(subscriptionId) {
+		const [roomName, unsubscribe] = this._unsubscriptions.get(subscriptionId) ?? [];
+		if (!roomName || !unsubscribe) return;
+		const refs = this._subscriptionsRefs.get(roomName);
+		if (!refs) return;
+		if (refs.length === 1) {
+			this._subjects.delete(roomName);
+			this._subscriptionsRefs.delete(roomName);
+			this._unsubscriptions.delete(subscriptionId);
+			return;
+		}
+		const index = refs.indexOf(subscriptionId);
+		this._subscriptionsRefs.set(roomName, index === -1 ? refs : [...refs.slice(0, index), ...refs.slice(index + 1)]);
+		unsubscribe();
+		this._unsubscriptions.delete(subscriptionId);
+	}
+};
+//#endregion
+//#region src/AbstractPlatform.ts
+var AbstractPlatform = class {
+	_initContext;
+	_roomContext;
+	_initialized = false;
+	persistence;
+	pubSub;
+	_createToken;
+	_fetch;
+	constructor(config = {}) {
+		const { roomContext, persistence, pubSub } = config;
+		this._meta = config._meta;
+		if (!!roomContext) this._roomContext = roomContext;
+		this.persistence = persistence ?? new Persistence();
+		this.pubSub = pubSub ?? new PubSub();
+	}
+	validateConfig(config) {}
+	_initialize() {
+		if (this._initialized) throw new Error("Platform is already initialized");
+		this._initialized = true;
+		return this;
+	}
+};
+//#endregion
+//#region src/AbstractWebSocket.ts
+var AbstractWebSocket = class {
+	/** The connection is not yet open. */
+	CONNECTING = 0;
+	/** The connection is open and ready to communicate. */
+	OPEN = 1;
+	/** The connection is in the process of closing. */
+	CLOSING = 2;
+	/** The connection is closed. */
+	CLOSED = 3;
+	persistence;
+	room;
+	webSocket;
+	_platform;
+	constructor(webSocket, config) {
+		const { persistence, platform, room } = config;
+		this.persistence = persistence;
+		this._platform = platform;
+		this.room = room;
+		this.webSocket = webSocket;
+	}
+	handleError(params) {
+		const { error, message: _message, room, session } = params;
+		const message = error instanceof Error ? error.message : "Unexpected error";
+		const stack = error instanceof Error ? error.stack ?? null : null;
+		const connectionId = session?.id ?? null;
+		return this.sendMessage({
+			connectionId,
+			data: {
+				message,
+				stack
+			},
+			room,
+			type: "$error",
+			user: session?.user ?? null
+		});
+	}
+	sendMessage(data) {
+		return this.send(JSON.stringify(data));
+	}
+};
+//#endregion
+//#region src/authorize.ts
+const DEFAULT_MAX_AGE_MS = 6e4;
+const getEncryptionKey = async (secret) => {
+	return await hkdf("sha256", secret, "", "Pluv.io Generated Encryption Key", 32);
+};
+const now = () => Date.now() / 1e3 | 0;
+const authorize = (params) => {
+	const { platform, secret } = params;
+	const encode = async (encodeParams) => {
+		const { maxAge = DEFAULT_MAX_AGE_MS, room, user } = encodeParams;
+		const encryptionSecret = await getEncryptionKey(secret);
+		return await new EncryptJWT({
+			room,
+			sub: room ? `${room}|${user.id}` : user.id,
+			user
+		}).setProtectedHeader({
+			alg: "dir",
+			enc: "A256GCM"
+		}).setIssuedAt().setExpirationTime(now() + maxAge).setJti(platform.randomUUID()).encrypt(encryptionSecret);
+	};
+	const decode = async (jwt) => {
+		const encryptionSecret = await getEncryptionKey(secret);
+		const { payload } = await jwtDecrypt(jwt, encryptionSecret, { clockTolerance: 15 });
+		return payload ?? null;
+	};
+	return {
+		decode,
+		encode
+	};
+};
+//#endregion
+//#region src/PluvProcedure.ts
+var PluvProcedure = class PluvProcedure {
+	_broadcast = null;
+	_input = null;
+	_self = null;
+	_sync = null;
+	get config() {
+		return {
+			broadcast: this._broadcast?.bind(this) ?? null,
+			input: this._input ?? null,
+			resolver: this._resolver(),
+			self: this._self?.bind(this) ?? null,
+			sync: this._sync?.bind(this) ?? null
+		};
+	}
+	constructor(config = {}) {
+		const { broadcast, input, self, sync } = config;
+		this._broadcast = broadcast ?? null;
+		this._input = input ?? null;
+		this._self = self ?? null;
+		this._sync = sync ?? 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 });
+	}
+	self(resolver) {
+		const { self } = this.config;
+		if (!!self) throw new Error("Self was already defined for this procedure");
+		return new PluvProcedure({
+			...this.config,
+			self: resolver
+		});
+	}
+	sync(resolver) {
+		const { sync } = this.config;
+		if (!!sync) throw new Error("Sync was already defined for this procedure");
+		return new PluvProcedure({
+			...this.config,
+			sync: resolver
+		});
+	}
+	_resolver() {
+		return (data, context) => {
+			return {
+				...this._broadcast?.(data, context),
+				...this._self?.(data, context),
+				...this._sync?.(data, context)
+			};
+		};
+	}
+};
+//#endregion
+//#region src/PluvRouter.ts
+var PluvRouter = class PluvRouter {
+	_defs = { events: {} };
+	constructor(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));
+		return new PluvRouter(events);
+	}
+	_isValidEventName(name) {
+		return /^[a-z_$][a-z0-9_$]*$/gi.test(name);
+	}
+};
+const MAX_STORAGE_SIZE_BYTES = 31457280;
+//#endregion
+//#region src/utils/oneLine.ts
+const oneLine = (strings, ...values) => {
+	return strings.map((str) => str.replace(/\s+/g, " ")).reduce((acc, str, i) => acc + str + (i < values.length ? values[i] : ""), "").replace(/\s+/g, " ").trim();
+};
+//#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/IORoom.ts
+var IORoom = class {
+	id;
+	_doc;
+	_lastGarbageCollectMs = -60001;
+	_uninitialize = null;
+	_authorize = null;
+	_context;
+	_crdt;
+	_debug;
+	_docFactory;
+	_getInitialStorage;
+	_listeners;
+	_platform;
+	_roomContext;
+	_router;
+	_sessions = /* @__PURE__ */ new Map();
+	_userSessionss = /* @__PURE__ */ new Map();
+	_wasDocEmptyOnInit = true;
+	_storageInitializedViaSession = false;
+	/**
+	* @ignore
+	* @readonly
+	* @deprecated Internal use only. Changes to this will never be marked as breaking.
+	*/
+	get _defs() {
+		return {
+			authorize: this._authorize,
+			context: this._context,
+			crdt: this._crdt,
+			events: this._router._defs.events,
+			platform: this._platform
+		};
+	}
+	get broadcast() {
+		const _broadcast = (event, data) => {
+			const message = {
+				type: event,
+				data
+			};
+			return Promise.resolve(this._broadcast({ message }));
+		};
+		return new Proxy(_broadcast, { get(fn, prop) {
+			return (data) => fn(prop, data);
+		} });
+	}
+	get _initialized() {
+		return Promise.resolve(!!this._uninitialize?.then((result) => !!result));
+	}
+	constructor(id, config) {
+		const { _meta, authorize: authorizeConfig, context, crdt = noop, debug, getInitialStorage, onRoomDestroyed, onStorageDestroyed, onMessage, onUserConnected, onUserDisconnected, platform, roomContext, router } = config;
+		this.id = id;
+		this._context = context;
+		this._crdt = crdt;
+		this._debug = debug;
+		this._docFactory = crdt.doc(() => ({}));
+		this._getInitialStorage = getInitialStorage;
+		this._roomContext = roomContext;
+		this._router = router;
+		this._platform = platform.initialize({
+			...!!_meta ? { _meta } : {},
+			roomContext
+		});
+		this._listeners = {
+			onRoomDestroyed: (event) => onRoomDestroyed?.(event),
+			onStorageDestroyed: (event) => onStorageDestroyed?.(event),
+			onMessage: (event) => onMessage?.(event),
+			onUserConnected: (event) => onUserConnected?.(event),
+			onUserDisconnected: (event) => onUserDisconnected?.(event)
+		};
+		if (authorizeConfig) this._authorize = authorizeConfig;
+		this._platform.getWebSockets().forEach((webSocket) => {
+			const deserialized = this._platform.getSerializedState(webSocket);
+			const sessionId = this._platform.getSessionId(webSocket);
+			if (!deserialized) return;
+			if (typeof sessionId !== "string") return;
+			const pluvWs = this._platform.convertWebSocket(webSocket, { room: this.id });
+			this._sessions.set(sessionId, pluvWs);
+			const userId = pluvWs.session.user?.id;
+			if (!!userId) this._addUserSession(userId, sessionId);
+		});
+		const { doc, uninitialize } = this._initialize();
+		this._doc = doc;
+		this._uninitialize = uninitialize;
+	}
+	/**
+	* @description Closes a connection with the specified sessionId
+	* @param sessionId The session id of the connection to close
+	*/
+	async evict(sessionId) {
+		const session = this._sessions.get(sessionId);
+		if (session) session.state.quit = true;
+		await this._emitQuitters();
+	}
+	/**
+	* @description Closes all connections to this room, effectively destroying
+	* the room
+	*/
+	async evictAll() {
+		Array.from(this._sessions.values()).forEach((session) => {
+			session.state.quit = true;
+		});
+		await this._emitQuitters();
+	}
+	/**
+	* @description The IORoom will garbage collect occasionally as connections ping/pong the
+	* server
+	*/
+	async garbageCollect() {
+		this._lastGarbageCollectMs = Date.now();
+		await Promise.all([this._emitQuitters(), this._emitSyncState()]);
+	}
+	getSize() {
+		const currentTime = (/* @__PURE__ */ new Date()).getTime();
+		/**
+		* @description Doing this instead of .size because some sessions
+		* in the map can be considered as "omitted".
+		* @date December 21, 2022
+		*/
+		return Array.from(this._sessions.values()).reduce((count, pluvWs) => {
+			if (pluvWs.state.quit) return count;
+			const pingTime = this._platform.getLastPing(pluvWs) ?? pluvWs.state.timers.ping;
+			return currentTime - pingTime > 3e4 ? count : count + 1;
+		}, 0);
+	}
+	onClose(webSocket) {
+		this._ensureDetached();
+		const wsSession = this._getAbstractWs(webSocket);
+		if (!wsSession) return async () => void 0;
+		return this._onClose(wsSession);
+	}
+	onError(webSocket) {
+		this._ensureDetached();
+		const wsSession = this._getAbstractWs(webSocket);
+		if (!wsSession) return async () => void 0;
+		return this._onClose(wsSession);
+	}
+	onMessage(webSocket) {
+		this._ensureDetached();
+		const wsSession = this._getAbstractWs(webSocket);
+		if (!wsSession) return async () => void 0;
+		return this._onMessage(wsSession);
+	}
+	async register(webSocket, ...options) {
+		const _options = options[0] ?? {};
+		const token = _options.token ?? null;
+		/**
+		* TODO
+		* @description Update the sessionId strategy so that the userId can be used to retrieve
+		* the session in O(1) time if authorized.
+		* @date April 15, 2025
+		*/
+		const sessionId = this._platform.getSessionId(webSocket);
+		if (typeof sessionId === "string" && this._sessions.has(sessionId)) return;
+		if (!await this._initialized) {
+			this._initialize();
+			await this._initialized;
+		}
+		const user = await this._getAuthorizedUser(token, _options);
+		const isUnauthorized = !!this._getIOAuthorize(_options) && !user;
+		const pluvWs = this._platform.convertWebSocket(webSocket, { room: this.id });
+		if (isUnauthorized) {
+			this._logDebug(colors.blue("Authorization failed for connection"));
+			pluvWs.handleError({
+				error: /* @__PURE__ */ new Error("Not authorized"),
+				room: this.id
+			});
+			pluvWs.close(3e3, "WebSocket unauthorized.");
+			return;
+		}
+		if (!!user) {
+			const latest = this._getLatestPresence(user.id);
+			const prevState = pluvWs.state;
+			pluvWs.user = user;
+			this._platform.setSerializedState(pluvWs, {
+				...prevState,
+				presence: latest.presence,
+				timers: {
+					...prevState.timers,
+					presence: latest.timer
+				}
+			});
+			this._addUserSession(user.id, pluvWs.sessionId);
+		}
+		this._logDebug(`${colors.blue(`Registering connection for room ${this.id}:`)} ${pluvWs.sessionId}`);
+		await this._platform.acceptWebSocket(pluvWs);
+		this._sessions.set(pluvWs.sessionId, pluvWs);
+		await this._platform.persistence.addUser(this.id, pluvWs.sessionId, user ?? {});
+		if (this._platform._config.registrationMode === "attached") {
+			const onClose = this._onClose(pluvWs).bind(this);
+			const onMessage = this._onMessage(pluvWs).bind(this);
+			pluvWs.addEventListener("close", onClose);
+			pluvWs.addEventListener("error", onClose);
+			pluvWs.addEventListener("message", onMessage);
+		}
+		await this._emitRegistered(pluvWs);
+		const size = this.getSize();
+		this._logDebug(oneLine`
+            ${colors.blue(`Registered connection for room ${this.id}:`)}
+            ${pluvWs.sessionId}
+        `);
+		this._logDebug(`${colors.blue(`Room ${this.id} size:`)} ${size}`);
+	}
+	_addUserSession(userId, sessionId) {
+		const updated = (this._userSessionss.get(userId) ?? /* @__PURE__ */ new Set()).add(sessionId);
+		this._userSessionss.set(userId, updated);
+		return updated;
+	}
+	async _broadcast(params) {
+		const { message, senderId } = params;
+		const user = ((senderId ? this._sessions.get(senderId) ?? null : null)?.session ?? null)?.user ?? null;
+		if (typeof senderId !== "string") return;
+		await this._platform.pubSub.publish(this.id, {
+			connectionId: senderId ?? null,
+			room: this.id,
+			user,
+			...message
+		});
+	}
+	async _closeWebSockets(webSockets) {
+		const closeWebSocket = async (webSocket) => {
+			webSocket.state = {
+				...webSocket.state,
+				quit: true
+			};
+			const sessionId = webSocket.sessionId;
+			this._logDebug(`${colors.blue(`Unregistering connection for room ${this.id}:`)} ${sessionId}`);
+			this._sessions.delete(sessionId);
+			await this._platform.persistence.deleteUser(this.id, sessionId).catch(() => null);
+			await this._broadcast({
+				message: {
+					type: "$exit",
+					data: { sessionId }
+				},
+				senderId: sessionId
+			});
+			const user = webSocket.session.user;
+			if (!!user) this._removeUserSession(user.id, sessionId);
+			try {
+				const [doc, context] = await Promise.all([this._doc, this._getContext()]);
+				const encodedState = doc.getEncodedState();
+				await Promise.resolve(this._listeners.onUserDisconnected({
+					context,
+					encodedState,
+					platform: this._platform,
+					room: this.id,
+					user
+				}));
+			} catch (error) {
+				console.error(error);
+			}
+			this._logDebug(`${colors.blue(`Unregistered connection for room ${this.id}:`)} ${webSocket.sessionId}`);
+		};
+		const promises = webSockets.map(async (webSocket) => {
+			await closeWebSocket(webSocket).catch(() => null);
+		});
+		await Promise.all(promises).catch(() => null);
+		const size = this.getSize();
+		this._logDebug(`${colors.blue(`Room ${this.id} size:`)} ${size}`);
+		if (!!size) return;
+		if (!this._uninitialize) return;
+		await (await this._uninitialize).bind(this)();
+	}
+	async _emitQuitters() {
+		const currentTime = (/* @__PURE__ */ new Date()).getTime();
+		const quitters = Array.from(this._sessions.values()).filter((pluvWs) => {
+			return pluvWs.state.quit || currentTime - pluvWs.state.timers.ping > 3e4;
+		});
+		await this._closeWebSockets(quitters);
+	}
+	async _emitRegistered(pluvWs) {
+		const session = pluvWs.session;
+		const sessionId = session.id;
+		const presence = session.presence;
+		const user = session.user;
+		const [doc, context] = await Promise.all([this._doc, this._getContext()]);
+		const encodedState = doc.isEmpty() ? null : doc.getEncodedState();
+		await this._sendSelfMessage({
+			type: "$registered",
+			data: {
+				presence,
+				sessionId,
+				state: encodedState,
+				timers: { presence: session.timers.presence }
+			}
+		}, {
+			sessionId,
+			user
+		});
+		try {
+			await Promise.resolve(this._listeners.onUserConnected({
+				context,
+				encodedState,
+				platform: this._platform,
+				room: this.id,
+				user,
+				webSocket: pluvWs.webSocket
+			}));
+		} catch (err) {
+			console.error(err);
+		}
+	}
+	async _emitSyncState() {
+		const connectionIds = await this._platform.persistence.getUsers(this.id).then((map) => Object.keys(map));
+		await this._broadcast({ message: {
+			type: "$syncStateReceived",
+			data: { connectionIds }
+		} });
+	}
+	_ensureDetached() {
+		if (this._platform._config.registrationMode === "detached") return;
+		throw new Error("Platform must use detached mode");
+	}
+	_getAbstractWs(webSocket) {
+		if (webSocket instanceof AbstractWebSocket) return webSocket;
+		const sessionId = this._platform.getSessionId(webSocket);
+		if (typeof sessionId === "string") {
+			const session = this._sessions.get(sessionId) ?? null;
+			if (session) return session;
+		}
+		return Array.from(this._sessions.values()).find((pluvWs) => pluvWs.webSocket === webSocket) ?? null;
+	}
+	/**
+	* TODO
+	* @description Revisit any cast types
+	* @date July 17, 2025
+	*/
+	async _getAuthorizedUser(token, options) {
+		const ioAuthorize = this._getIOAuthorize(options);
+		if (!ioAuthorize) return null;
+		if (!token) return null;
+		if (!ioAuthorize.secret) throw new Error("`authorize` was specified without a valid secret");
+		const payload = await authorize({
+			platform: this._platform,
+			secret: ioAuthorize.secret
+		}).decode(token);
+		if (!payload) {
+			this._logDebug(colors.blue("Could not decode token:"));
+			this._logDebug(token);
+			return null;
+		}
+		if (payload.room !== this.id) {
+			this._logDebug(colors.blue(`Token is not authorized for room ${this.id}:`));
+			this._logDebug(colors.blue("Received:"), payload.room);
+			this._logDebug(token);
+			return null;
+		}
+		try {
+			return ioAuthorize.user.parse(payload.user) ?? null;
+		} catch {
+			this._logDebug(`${colors.blue("Token fails validation:")} ${token}`);
+			return null;
+		}
+	}
+	async _getContext() {
+		return typeof this._context === "function" ? await Promise.resolve(this._context(this._roomContext)) : await Promise.resolve(this._context);
+	}
+	async _getInitialDoc() {
+		const doc = this._docFactory.getEmpty();
+		const [encodedState, context] = await Promise.all([this._platform.persistence.getStorageState(this.id), this._getContext()]);
+		if (!encodedState) {
+			const loadedState = await this._getInitialStorage({
+				context,
+				room: this.id
+			});
+			if (!!loadedState && !this._docFactory.isEmpty(loadedState)) doc.applyEncodedState({ update: loadedState });
+		}
+		if (typeof encodedState === "string") {
+			doc.applyEncodedState({ update: encodedState });
+			if (!doc.isEmpty()) this._storageInitializedViaSession = true;
+		}
+		return doc;
+	}
+	_getIOAuthorize(options) {
+		if (typeof this._authorize === "function") return this._authorize(options);
+		return this._authorize;
+	}
+	_getLatestPresence(userId) {
+		if (!this._authorize) return {
+			timer: null,
+			presence: null
+		};
+		const sessionIds = Array.from(this._userSessionss.get(userId)?.values() ?? []);
+		if (!sessionIds.length) return {
+			timer: null,
+			presence: null
+		};
+		return sessionIds.reduce((state, sessionId) => {
+			const pluvWs = this._sessions.get(sessionId) ?? null;
+			if (!pluvWs) return state;
+			const session = pluvWs.session;
+			const presence = session.presence;
+			const timer = session.timers.presence;
+			if (session.user?.id !== userId) return state;
+			if (typeof state.timer !== "number") return {
+				presence,
+				timer
+			};
+			if (typeof timer !== "number") return state;
+			return timer > state.timer ? {
+				presence,
+				timer
+			} : state;
+		}, {
+			presence: null,
+			timer: null
+		});
+	}
+	_getProcedure(message) {
+		return this._router._defs.events[message.type] ?? null;
+	}
+	_getProcedureInputs(message) {
+		const procedure = this._getProcedure(message);
+		if (!procedure) return message.data;
+		return procedure.config.input ? procedure.config.input.parse(message.data) : message.data;
+	}
+	_getSession(webSocket) {
+		const pluvWs = this._getAbstractWs(webSocket);
+		if (!pluvWs) throw new Error("Session could not be found");
+		return pluvWs.session;
+	}
+	_getSessions() {
+		return Array.from(this._sessions.values()).map((pluvWs) => pluvWs.session);
+	}
+	_initialize() {
+		const promise = (async () => {
+			this._logDebug(colors.blue(`Initializing room: ${this.id}`));
+			if (!!this._uninitialize) {
+				await (await this._uninitialize).bind(this)();
+				this._uninitialize = null;
+			}
+			const pubSubId = await this._platform.pubSub.subscribe(this.id, async ({ options = {}, ...message }) => {
+				await promise;
+				const sender = {
+					sessionId: message.connectionId,
+					user: message.user
+				};
+				switch (options.type) {
+					case "self":
+						await this._sendSelfMessage(message, sender);
+						return;
+					case "sync":
+						await this._sendSyncMessage(message, sender);
+						return;
+					default: {
+						const sessionIds = options.sessionIds;
+						await this._sendBroadcastMessage(message, sender, sessionIds);
+					}
+				}
+			});
+			const doc = await this._getInitialDoc();
+			this._wasDocEmptyOnInit = doc.isEmpty();
+			const uninitialize = async () => {
+				this._platform.pubSub.unsubscribe(pubSubId);
+				const [resolvedDoc, context] = await Promise.all([this._doc, this._getContext()]);
+				const encodedState = resolvedDoc.getEncodedState();
+				resolvedDoc.destroy();
+				this._doc = Promise.resolve(this._docFactory.getEmpty());
+				await Promise.resolve(this._listeners.onRoomDestroyed({
+					..."_meta" in this._platform && !!this._platform._meta ? { _meta: this._platform._meta } : {},
+					context,
+					platform: this._platform,
+					room: this.id
+				}));
+				if (this._storageInitializedViaSession) {
+					await Promise.resolve(this._listeners.onStorageDestroyed({
+						..."_meta" in this._platform && !!this._platform._meta ? { _meta: this._platform._meta } : {},
+						context,
+						encodedState,
+						platform: this._platform,
+						room: this.id
+					}));
+					this._storageInitializedViaSession = false;
+				}
+				this._uninitialize = null;
+			};
+			return {
+				doc,
+				uninitialize
+			};
+		})();
+		this._doc = promise.then((result) => result.doc);
+		this._uninitialize = promise.then((result) => result.uninitialize);
+		return {
+			doc: this._doc,
+			uninitialize: this._uninitialize
+		};
+	}
+	_logDebug(...data) {
+		if (this._debug) console.log(...data);
+	}
+	_onClose(webSocket) {
+		return async () => {
+			if (!await this._initialized) return;
+			await this._closeWebSockets([webSocket]);
+		};
+	}
+	_onMessage(webSocket) {
+		return async (event) => {
+			if (!await this._initialized) return;
+			const pluvWs = this._getAbstractWs(webSocket);
+			if (!pluvWs) throw new Error("Could not get session");
+			const session = this._getSession(pluvWs);
+			const sessions = this._getSessions();
+			const setPresence = (params) => {
+				this._setPresence.bind(this)(params);
+			};
+			const [doc, context] = await Promise.all([this._doc, this._getContext()]);
+			const eventContext = {
+				context,
+				doc,
+				garbageCollect: async () => {
+					await this.garbageCollect();
+				},
+				platform: this._platform,
+				get presence() {
+					return session.presence;
+				},
+				set presence(presence) {
+					const sessionId = this.session?.id;
+					if (!sessionId) return;
+					setPresence({
+						presence,
+						sessionId,
+						timer: this.time
+					});
+				},
+				room: this.id,
+				session,
+				sessions,
+				time: (/* @__PURE__ */ new Date()).getTime()
+			};
+			if (pluvWs.state.quit) {
+				await this._closeWebSockets([pluvWs]).catch(() => null);
+				pluvWs.close(1011, "WebSocket broken.");
+				return;
+			}
+			const message = this._parseMessage(event);
+			if (!message) return;
+			const procedure = this._getProcedure(message);
+			this._listeners.onMessage({
+				..."_meta" in this._platform && !!this._platform._meta ? { _meta: this._platform._meta } : {},
+				context,
+				encodedState: doc.getEncodedState(),
+				message,
+				platform: this._platform,
+				room: this.id,
+				user: session.user,
+				webSocket: session.webSocket.webSocket
+			});
+			const sessionId = session.id;
+			const user = session.user;
+			if (!procedure) {
+				await this._broadcast({
+					message,
+					senderId: sessionId
+				});
+				return;
+			}
+			let inputs;
+			try {
+				inputs = this._getProcedureInputs(message);
+			} catch (error) {
+				pluvWs.handleError({
+					error,
+					message: "Invalid input",
+					room: this.id,
+					session
+				});
+				return;
+			}
+			await Promise.all([
+				procedure.config.broadcast?.(inputs, eventContext),
+				procedure.config.self?.(inputs, eventContext),
+				procedure.config.sync?.(inputs, eventContext)
+			]).then(async ([broadcast, self, sync]) => {
+				const handleBroadcast = async () => {
+					if (!broadcast) return;
+					const messages = Object.entries(broadcast).map(async ([type, data]) => {
+						await this._broadcast({
+							message: {
+								data,
+								type
+							},
+							senderId: sessionId
+						});
+					});
+					await Promise.all(messages);
+				};
+				const handleSelf = async () => {
+					if (!self) return;
+					const messages = Object.entries(self).map(async ([type, data]) => {
+						await this._sendSelfMessage({
+							data,
+							type
+						}, {
+							sessionId,
+							user
+						});
+					});
+					await Promise.all(messages);
+				};
+				const handleSync = async () => {
+					if (!sync) return;
+					await this._platform.pubSub.publish(this.id, {
+						connectionId: session.id,
+						options: { type: "sync" },
+						room: this.id,
+						user,
+						...message
+					});
+					const messages = Object.entries(sync).map(async ([type, data]) => {
+						await this._sendSelfMessage({
+							data,
+							type
+						}, {
+							sessionId,
+							user
+						});
+					});
+					await Promise.all(messages);
+				};
+				await Promise.all([
+					handleBroadcast(),
+					handleSelf(),
+					handleSync()
+				]);
+			});
+			await this._checkStorageInitializedViaSession();
+		};
+	}
+	_parseMessage(message) {
+		try {
+			const parsed = this._platform.parseData(message.data);
+			if (typeof parsed !== "object") return null;
+			if (typeof parsed.type !== "string") return null;
+			if (typeof parsed.data !== "object") return null;
+			return parsed;
+		} catch {
+			return null;
+		}
+	}
+	_setPresence(params) {
+		const { presence, sessionId, timer: _timer } = params;
+		const timer = _timer ?? (/* @__PURE__ */ new Date()).getTime();
+		const pluvWs = this._sessions.get(sessionId) ?? null;
+		if (!pluvWs) return;
+		const user = pluvWs.session.user;
+		(user ? /* @__PURE__ */ new Set([...this._userSessionss.get(user.id) ?? [], sessionId]) : /* @__PURE__ */ new Set([sessionId])).forEach((sId) => {
+			const session = this._sessions.get(sId)?.session;
+			if (!session) return;
+			const prevState = session.webSocket.state;
+			this._platform.setSerializedState(session.webSocket, {
+				...prevState,
+				presence,
+				timers: {
+					...prevState.timers,
+					presence: timer
+				}
+			});
+		});
+	}
+	_removeUserSession(userId, sessionId) {
+		const set = this._userSessionss.get(userId);
+		if (!set) return null;
+		set.delete(sessionId);
+		if (!!set.size) return set;
+		this._userSessionss.delete(userId);
+		return set;
+	}
+	async _checkStorageInitializedViaSession() {
+		if (this._storageInitializedViaSession) return;
+		const doc = await this._doc;
+		if (this._wasDocEmptyOnInit && !doc.isEmpty() && this._sessions.size > 0) this._storageInitializedViaSession = true;
+	}
+	async _sendMessage(pluvWs, message) {
+		if (!await this._initialized) return;
+		await Promise.resolve(pluvWs.sendMessage(message));
+	}
+	async _sendBroadcastMessage(message, sender, sessionIds) {
+		const { data, type } = message;
+		const connectionId = sender?.sessionId ?? null;
+		const room = this.id;
+		if (typeof connectionId !== "string") return;
+		const webSockets = sessionIds?.reduce((dict, id) => {
+			const pluvWs = this._sessions.get(id);
+			return pluvWs ? dict.set(id, pluvWs) : dict;
+		}, /* @__PURE__ */ new Map()) ?? this._sessions;
+		const promises = Array.from(webSockets.values()).map(async (pluvWs) => {
+			const user = pluvWs.session.user ?? null;
+			this._sendMessage(pluvWs, {
+				connectionId,
+				data,
+				room,
+				type,
+				user
+			});
+		});
+		await Promise.all(promises);
+	}
+	async _sendSelfMessage(message, sender) {
+		const senderId = sender?.sessionId ?? null;
+		if (typeof senderId !== "string") return;
+		const pluvWs = this._sessions.get(senderId);
+		if (!pluvWs) return;
+		const user = pluvWs.session.user ?? null;
+		await this._sendMessage(pluvWs, {
+			connectionId: senderId,
+			room: this.id,
+			user,
+			...message
+		});
+		/**
+		* @description Note that this will not fire for Cloudflare's hibernatable websockets
+		* because the server will auto-respond with the $pong event without calling any
+		* functions.
+		* @date April 18, 2025
+		*/
+		if (message.type === "$pong") {
+			/**
+			* @description Garbage collection is awaited after responding, since it can close
+			* websockets and flush persistence. Blocking the $pong response on it risks
+			* exceeding the client's pong timeout and triggering a spurious reconnect.
+			*/
+			if (Date.now() - this._lastGarbageCollectMs > 6e4) await this.garbageCollect();
+		}
+	}
+	async _sendSyncMessage(message, sender) {
+		if (!sender) return;
+		const connectionId = sender.sessionId;
+		if (typeof connectionId !== "string") return;
+		const [doc, context] = await Promise.all([this._doc, this._getContext()]);
+		const resolverCtx = {
+			context,
+			doc,
+			garbageCollect: async () => {
+				await this.garbageCollect();
+			},
+			platform: this._platform,
+			get presence() {
+				return null;
+			},
+			set presence(presence) {},
+			room: this.id,
+			session: null,
+			sessions: this._getSessions(),
+			time: (/* @__PURE__ */ new Date()).getTime()
+		};
+		const resolver = this._getProcedure(message)?.config.sync;
+		if (!resolver) return;
+		let inputs;
+		try {
+			inputs = this._getProcedureInputs(message);
+		} catch {
+			return;
+		}
+		const output = await resolver(inputs, resolverCtx);
+		if (!output) return;
+		await Promise.all(Object.keys(output).map((type) => {
+			const data = output[type] ?? {};
+			return this._platform.pubSub.publish(this.id, {
+				connectionId,
+				data,
+				options: { type: "self" },
+				room: this.id,
+				type,
+				user: sender.user ?? null
+			});
+		}));
+	}
+};
+//#endregion
+//#region src/version.generated.ts
+const version = "5.0.3";
+//#endregion
+//#region src/PluvServer.ts
+var PluvServer = class {
+	version = version;
+	_config;
+	_docFactory;
+	get fetch() {
+		return (...args) => {
+			const platform = this._config.platform();
+			platform.validateConfig(this._config);
+			if (!platform._fetch) throw new Error(`\`${platform._name}\` does not support \`fetch\``);
+			return platform._fetch(...args);
+		};
+	}
+	/**
+	* @ignore
+	* @readonly
+	* @deprecated Internal use only. Changes to this will never be marked as breaking.
+	*/
+	get _defs() {
+		return {
+			authorize: this._config.authorize,
+			context: this._config.context,
+			crdt: this._config.crdt,
+			events: this._router._defs.events,
+			platform: this._config.platform()
+		};
+	}
+	get _baseRouter() {
+		const listeners = this._getListeners();
+		return new PluvRouter({
+			$getOthers: this._procedure.sync((data, { room, session, sessions }) => {
+				const currentTime = Date.now();
+				return { $othersReceived: { others: sessions.filter((wsSession) => {
+					if (wsSession.id === session?.id) return false;
+					if (wsSession.quit) return false;
+					if (currentTime - wsSession.timers.ping > 3e4) return false;
+					return true;
+				}).reduce((acc, { id, presence, timers, user }) => {
+					acc[id] = {
+						connectionId: id,
+						presence,
+						room,
+						timers: { presence: timers.presence },
+						user
+					};
+					return acc;
+				}, {}) } };
+			}),
+			$initializeSession: this._procedure.broadcast((data, { session }) => {
+				const presence = data?.presence;
+				const timers = session.timers;
+				if (!session) return {};
+				session.presence = presence;
+				return { $userJoined: {
+					connectionId: session.id,
+					user: session.user,
+					presence,
+					timers: { presence: timers.presence }
+				} };
+			}).self(async (data, { context, doc, platform, room, session }) => {
+				const oldState = await platform.persistence.getStorageState(room);
+				/**
+				* !HACK
+				* @description This is the frontend's initialStorage. We only want to
+				* apply this if the server's storage is empty (i.e. no initial storage
+				* has been applied)
+				*/
+				const update = data?.update;
+				if (!oldState) {
+					const loadedState = await this._getInitialStorage({
+						context,
+						room
+					});
+					if (!!loadedState && !this._docFactory.isEmpty(loadedState)) doc.applyEncodedState({ update: loadedState });
+				}
+				/**
+				* @description Storage was already initialized. Don't overwrite the current
+				* storage state with the incoming initial storage. Return what the current state
+				* is without changes.
+				* @date May 7, 2025
+				*/
+				if (!doc.isEmpty()) return { $storageReceived: {
+					changeKind: "unchanged",
+					state: doc.getEncodedState()
+				} };
+				/**
+				* @description Storage was never initialized, and there is an incoming
+				* initialStorage from the client. Apply the initialStorage and persist the state
+				* as an update.
+				* @date May 7, 2025
+				*/
+				if (!!update) {
+					const encodedState = doc.applyEncodedState({ update }).getEncodedState();
+					const storageSize = new TextEncoder().encode(encodedState).length;
+					if (!!this._config.limits.storageMaxSize && storageSize > this._config.limits.storageMaxSize) throw new Error("Storage has exceeded the size limit");
+					await platform.persistence.setStorageState(room, encodedState).catch((error) => {
+						this._logDebug(error);
+					});
+					listeners.onStorageUpdated({
+						context,
+						encodedState,
+						platform,
+						room,
+						user: session?.user,
+						webSocket: session?.webSocket.webSocket
+					});
+					return { $storageReceived: {
+						changeKind: "initialized",
+						state: encodedState
+					} };
+				}
+				return { $storageReceived: {
+					changeKind: "empty",
+					state: doc.getEncodedState()
+				} };
+			}),
+			$ping: this._procedure.self((data, { platform, session }) => {
+				if (!session) return {};
+				const currentTime = (/* @__PURE__ */ new Date()).getTime();
+				const prevState = session.webSocket.state;
+				platform.setSerializedState(session.webSocket, {
+					...prevState,
+					timers: {
+						...prevState.timers,
+						ping: currentTime
+					}
+				});
+				return { $pong: {} };
+			}),
+			$updatePresence: this._procedure.broadcast((data, context) => {
+				const presence = data?.presence;
+				const { session } = context;
+				if (!session) return {};
+				const cleanedPatch = pickBy(presence ?? {}, (value) => typeof value !== "undefined");
+				const updated = Object.assign(Object.create(null), session.presence, cleanedPatch);
+				const bytes = new TextEncoder().encode(JSON.stringify(updated)).length;
+				if (!!this._config.limits.presenceMaxSize && bytes > this._config.limits.presenceMaxSize) throw new Error(oneLine`
+                        Large presence. Presence must be at most
+                        ${this._config.limits.presenceMaxSize.toLocaleString()} bytes.
+                        Current size: ${bytes.toLocaleString()} bytes
+                    `);
+				context.presence = updated;
+				return { $presenceUpdated: {
+					presence: updated,
+					timers: { presence: session.timers.presence }
+				} };
+			}),
+			$updateStorage: this._procedure.broadcast((data, { context, doc, platform, room }) => {
+				const origin = data?.origin;
+				const update = data?.update ?? null;
+				if (origin === "$initialized" && Object.keys(doc.toJson()).length) return {};
+				const encodedState = (update === null ? doc : doc.applyEncodedState({ update })).getEncodedState();
+				const storageSize = new TextEncoder().encode(encodedState).length;
+				if (!!this._config.limits.storageMaxSize && storageSize > this._config.limits.storageMaxSize) throw new Error(oneLine`
+                        Large Storage. Storage must be at most
+                        ${this._config.limits.storageMaxSize.toLocaleString()} bytes.
+                        Current size: ${storageSize.toLocaleString()} bytes
+                    `);
+				platform.persistence.setStorageState(room, encodedState).then(() => {
+					listeners.onStorageUpdated({
+						context,
+						encodedState,
+						platform,
+						room
+					});
+				});
+				return { $storageUpdated: { state: encodedState } };
+			})
+		});
+	}
+	get _procedure() {
+		return new PluvProcedure();
+	}
+	get _router() {
+		return this._config.router ? PluvRouter.merge(this._baseRouter, this._config.router) : this._baseRouter;
+	}
+	constructor(options) {
+		this._config = {
+			crdt: noop,
+			debug: false,
+			router: new PluvRouter({}),
+			...options
+		};
+		const { onRoomDestroyed, onRoomMessage, onStorageDestroyed, onStorageUpdated, onUserConnected, onUserDisconnected } = options;
+		this._docFactory = this._config.crdt.doc(() => ({}));
+		this._listeners = {
+			onRoomDestroyed: (event) => onRoomDestroyed?.(event),
+			onRoomMessage: (event) => onRoomMessage?.(event),
+			onStorageDestroyed: (event) => onStorageDestroyed?.(event),
+			onStorageUpdated: (event) => onStorageUpdated?.(event),
+			onUserConnected: (event) => onUserConnected?.(event),
+			onUserDisconnected: (event) => onUserDisconnected?.(event)
+		};
+	}
+	createRoom(room, ...options) {
+		const { _meta, debug, ...platformRoomContext } = options[0] ?? {};
+		const platform = this._config.platform();
+		platform.validateConfig(this._config);
+		if (platform._config.handleMode !== "io") throw new Error(`\`createRoom\` is unsupported for \`${platform._name}\``);
+		if (!/^[a-z0-9](?:[a-z0-9-_]*[a-z0-9])?$/i.test(room)) throw new Error("Unsupported room name");
+		const roomContext = platformRoomContext;
+		const listeners = this._getListeners();
+		const logDebug = this._logDebug.bind(this);
+		const newRoom = new IORoom(room, {
+			...!!_meta ? { _meta } : {},
+			authorize: this._config.authorize ?? void 0,
+			context: this._config.context,
+			crdt: this._config.crdt,
+			debug: debug ?? this._config.debug,
+			getInitialStorage: this._getInitialStorage,
+			async onRoomDestroyed(event) {
+				logDebug(`${colors.blue("Deleting empty room:")} ${room}`);
+				await Promise.resolve(listeners.onRoomDestroyed(event));
+				logDebug(`${colors.blue("Deleted room:")} ${room}`);
+			},
+			async onStorageDestroyed(event) {
+				logDebug(`${colors.blue("Destroying storage for room:")} ${room}`);
+				await Promise.resolve(listeners.onStorageDestroyed(event));
+				await event.platform.persistence.deleteStorageState(room);
+				logDebug(`${colors.blue("Destroyed storage for room:")} ${room}`);
+			},
+			async onMessage(event) {
+				await Promise.resolve(listeners.onRoomMessage(event));
+			},
+			async onUserConnected(event) {
+				await Promise.resolve(listeners.onUserConnected(event));
+			},
+			async onUserDisconnected(event) {
+				await Promise.resolve(listeners.onUserDisconnected(event));
+			},
+			platform,
+			roomContext,
+			router: this._router
+		});
+		this._logDebug(`${colors.blue("Created room:")} ${room}`);
+		return newRoom;
+	}
+	async createToken(params) {
+		return await this._config.io.createToken(params);
+	}
+	_getInitialStorage = (...args) => {
+		return (typeof this._config.getInitialStorage !== "string" ? this._config.getInitialStorage ?? (() => null) : (() => null))(...args);
+	};
+	_getListeners() {
+		return this._listeners;
+	}
+	_logDebug(...data) {
+		if (this._config.debug) console.log(...data);
+	}
+};
+//#endregion
+//#region src/PluvIO.ts
+var PluvIO = class {
+	version = version;
+	_authorize = null;
+	_context = {};
+	_crdt;
+	_debug;
+	_limits;
+	_platform;
+	get procedure() {
+		return new PluvProcedure();
+	}
+	constructor(options) {
+		const { authorize: authorizeConfig, context, crdt = noop, debug = false, limits, platform } = options;
+		this._crdt = crdt;
+		this._debug = debug;
+		this._limits = {
+			presenceMaxSize: 512,
+			storageMaxSize: MAX_STORAGE_SIZE_BYTES,
+			userIdMaxLength: 128,
+			userMaxSize: 512,
+			...limits
+		};
+		this._platform = platform;
+		if (authorizeConfig) this._authorize = authorizeConfig;
+		if (context) this._context = context;
+	}
+	async createToken(params) {
+		if (!this._authorize) throw new Error("IO does not specify authorize during initialization.");
+		const ioAuthorize = this._getIOAuthorize(params);
+		const user = params.user;
+		const parsed = !!ioAuthorize ? ioAuthorize.user.parse(user) : user;
+		if (!!this._limits.userIdMaxLength && user.id.length > this._limits.userIdMaxLength) throw new Error(oneLine`
+                createToken was called with a long user id. User ID must be at
+                most 128 characters. Current length: ${user.id.length.toLocaleString()}
+            `);
+		const bytes = new TextEncoder().encode(JSON.stringify(parsed)).length;
+		if (!!this._limits.userMaxSize && bytes > this._limits.userMaxSize) throw new Error(oneLine`
+                createToken called with large payload. User must be at most 512
+                bytes. Current size: ${bytes.toLocaleString()}
+            `);
+		const platform = this._platform();
+		/**
+		* !HACK
+		* @description Allow the platform to overwrite this behavior as needed. This is introduced
+		* to support platformPluv
+		* @date December 15, 2024
+		*/
+		if (platform._createToken) return await platform._createToken({
+			...params,
+			authorize: ioAuthorize
+		});
+		const secret = ioAuthorize?.secret ?? null;
+		if (!secret) throw new Error("`authorize` was specified without a valid secret");
+		return await authorize({
+			platform,
+			secret
+		}).encode(params);
+	}
+	mergeRouters(...routers) {
+		return PluvRouter.merge(...routers);
+	}
+	router(events) {
+		const invalidName = Object.keys(events).find((name) => name.includes("$"));
+		if (typeof invalidName === "string") throw new Error(oneLine`
+                Invalid event name. Event names must not contain $: "${invalidName}"
+            `);
+		return new PluvRouter(events);
+	}
+	server(...config) {
+		return new PluvServer({
+			...config[0] ?? {},
+			authorize: this._authorize ?? void 0,
+			context: this._context,
+			crdt: this._crdt,
+			debug: this._debug,
+			io: this,
+			limits: this._limits,
+			platform: this._platform
+		});
+	}
+	_getIOAuthorize(options) {
+		if (typeof this._authorize === "function") return this._authorize(options);
+		return this._authorize;
+	}
+};
+//#endregion
+//#region src/createIO.ts
+const createIO = (params) => {
+	const { authorize, context, crdt, debug, limits, platform } = params;
+	return new PluvIO({
+		authorize,
+		context,
+		crdt,
+		debug,
+		limits,
+		platform
+	});
+};
+//#endregion
+export { AbstractPersistence, AbstractPlatform, AbstractPubSub, AbstractWebSocket, PluvIO, PluvProcedure, PluvRouter, PluvServer, authorize, createIO };
+
+//# sourceMappingURL=index.mjs.map