@pluv/io 5.0.0 → 5.0.1

package/dist/index.mjs

@@ -1,1421 +0,0 @@
-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)).toString();
-	};
-	const decode = async (jwt) => {
-		const { payload } = await jwtDecrypt(jwt, await getEncryptionKey(secret), { 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) {
-		return new PluvRouter(Object.assign(Object.create(null), ...routers.map((router) => router._defs.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 = -1 * 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, 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 (authorize) this._authorize = authorize;
-		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();
-		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;
-			return currentTime - (this._platform.getLastPing(pluvWs) ?? pluvWs.state.timers.ping) > 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;
-		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;
-		});
-		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 [doc, context] = await Promise.all([this._doc, this._getContext()]);
-				const encodedState = doc.getEncodedState();
-				doc.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;
-		/**
-		* @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") {
-			if (Date.now() - this._lastGarbageCollectMs > 6e4) await this.garbageCollect();
-		}
-		const user = pluvWs.session.user ?? null;
-		this._sendMessage(pluvWs, {
-			connectionId: senderId,
-			room: this.id,
-			user,
-			...message
-		});
-	}
-	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;
-		}
-		Promise.resolve(resolver(inputs, resolverCtx)).then((output) => {
-			if (!output) return;
-			Object.keys(output).forEach((type) => {
-				const data = output[type] ?? {};
-				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.0";
-//#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
-					}
-				}), {}) } };
-			}),
-			$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, 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 (authorize) this._authorize = authorize;
-		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