@pluv/io 3.2.2 → 4.0.1

package/dist/index.mjs

@@ -1,1532 +1,1446 @@
-var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-var __objRest = (source, exclude) => {
-  var target = {};
-  for (var prop in source)
-    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
-      target[prop] = source[prop];
-  if (source != null && __getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(source)) {
-      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
-        target[prop] = source[prop];
-    }
-  return target;
-};
-var __async = (__this, __arguments, generator) => {
-  return new Promise((resolve, reject) => {
-    var fulfilled = (value) => {
-      try {
-        step(generator.next(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var rejected = (value) => {
-      try {
-        step(generator.throw(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
-    step((generator = generator.apply(__this, __arguments)).next());
-  });
-};
+import { makeSubject, subscribe } from "wonka";
+import hkdf from "@panva/hkdf";
+import { EncryptJWT, jwtDecrypt } from "jose";
+import { noop } from "@pluv/crdt";
+import colors from "kleur";
 
-// src/AbstractPersistence.ts
-var AbstractPersistence = class {
-};
+//#region src/AbstractPersistence.ts
+var AbstractPersistence = class {};
 
-// src/Persistence.ts
+//#endregion
+//#region src/Persistence.ts
 var Persistence = class extends AbstractPersistence {
-  constructor() {
-    super(...arguments);
-    this._storages = /* @__PURE__ */ new Map();
-    this._users = /* @__PURE__ */ new Map();
-  }
-  addUser(room, connectionId, user) {
-    var _a;
-    const users = (_a = this._users.get(room)) != null ? _a : /* @__PURE__ */ new Map();
-    this._users.set(room, users);
-    users.set(connectionId, user);
-    return Promise.resolve();
-  }
-  deleteStorageState(room) {
-    this._storages.delete(room);
-    return Promise.resolve();
-  }
-  deleteUser(room, connectionId) {
-    return __async(this, null, function* () {
-      const users = this._users.get(room);
-      if (!users) return;
-      users.delete(connectionId);
-      if (!users.size) {
-        yield this.deleteUsers(room);
-        yield this.deleteStorageState(room);
-      }
-      return Promise.resolve();
-    });
-  }
-  deleteUsers(room) {
-    this._users.delete(room);
-    return Promise.resolve();
-  }
-  getSize(room) {
-    var _a, _b;
-    return Promise.resolve((_b = (_a = this._users.get(room)) == null ? void 0 : _a.size) != null ? _b : 0);
-  }
-  getStorageState(room) {
-    var _a;
-    const storage = (_a = this._storages.get(room)) != null ? _a : null;
-    return Promise.resolve(storage);
-  }
-  getUser(room, connectionId) {
-    var _a;
-    const user = (_a = this._users.get(room)) == null ? void 0 : _a.get(connectionId);
-    return Promise.resolve(user != null ? user : null);
-  }
-  getUsers(room) {
-    return __async(this, null, function* () {
-      const users = this._users.get(room);
-      if (!users) return /* @__PURE__ */ new Map();
-      return users;
-    });
-  }
-  getUsersSize(room) {
-    return __async(this, null, function* () {
-      return this._users.size;
-    });
-  }
-  initialize(roomContext) {
-    return this;
-  }
-  setStorageState(room, state) {
-    this._storages.set(room, state);
-    return Promise.resolve();
-  }
+	_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();
+	}
 };
 
-// src/PubSub.ts
-import { makeSubject, subscribe } from "wonka";
-
-// src/AbstractPubSub.ts
-var AbstractPubSub = class {
-};
+//#endregion
+//#region src/AbstractPubSub.ts
+var AbstractPubSub = class {};
 
-// src/PubSub.ts
+//#endregion
+//#region src/PubSub.ts
 var PubSub = class extends AbstractPubSub {
-  constructor() {
-    super(...arguments);
-    this._currentSubscriptionId = 0;
-    // Map of roomName to subjects
-    this._subjects = /* @__PURE__ */ new Map();
-    // Map of roomName to subscription ids
-    this._subscriptionsRefs = /* @__PURE__ */ new Map();
-    // Map of
-    this._unsubscriptions = /* @__PURE__ */ new Map();
-  }
-  publish(roomName, payload) {
-    return __async(this, null, function* () {
-      const subject = this._subjects.get(roomName);
-      if (!subject) return;
-      Promise.resolve(subject.next(payload));
-    });
-  }
-  subscribe(roomName, onMessage) {
-    var _a;
-    const id = this._currentSubscriptionId++;
-    const refs = (_a = this._subscriptionsRefs.get(roomName)) != null ? _a : [];
-    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) {
-    var _a;
-    const [roomName, unsubscribe] = (_a = this._unsubscriptions.get(subscriptionId)) != null ? _a : [];
-    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);
-  }
+	_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);
+	}
 };
 
-// src/AbstractPlatform.ts
+//#endregion
+//#region src/AbstractPlatform.ts
 var AbstractPlatform = class {
-  constructor(config = {}) {
-    this._initialized = false;
-    const { roomContext, persistence, pubSub } = config;
-    this._meta = config._meta;
-    if (!!roomContext) this._roomContext = roomContext;
-    this.persistence = persistence != null ? persistence : new Persistence();
-    this.pubSub = pubSub != null ? pubSub : new PubSub();
-  }
-  validateConfig(config) {
-  }
-  _initialize() {
-    if (this._initialized) throw new Error("Platform is already initialized");
-    this._initialized = true;
-    return this;
-  }
+	_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;
+	}
 };
 
-// src/AbstractWebSocket.ts
+//#endregion
+//#region src/AbstractWebSocket.ts
 var AbstractWebSocket = class {
-  constructor(webSocket, config) {
-    /** The connection is not yet open. */
-    this.CONNECTING = 0;
-    /** The connection is open and ready to communicate. */
-    this.OPEN = 1;
-    /** The connection is in the process of closing. */
-    this.CLOSING = 2;
-    /** The connection is closed. */
-    this.CLOSED = 3;
-    const { persistence, platform, room } = config;
-    this.persistence = persistence;
-    this._platform = platform;
-    this.room = room;
-    this.webSocket = webSocket;
-  }
-  handleError(params) {
-    var _a, _b, _c;
-    const { error, message: _message, room, session } = params;
-    const message = error instanceof Error ? error.message : "Unexpected error";
-    const stack = error instanceof Error ? (_a = error.stack) != null ? _a : null : null;
-    const connectionId = (_b = session == null ? void 0 : session.id) != null ? _b : null;
-    return this.sendMessage({
-      connectionId,
-      data: { message, stack },
-      room,
-      type: "$error",
-      user: (_c = session == null ? void 0 : session.user) != null ? _c : null
-    });
-  }
-  sendMessage(data) {
-    return this.send(JSON.stringify(data));
-  }
+	/** 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));
+	}
 };
 
-// src/authorize.ts
-import hkdf from "@panva/hkdf";
-import { EncryptJWT, jwtDecrypt } from "jose";
-var DEFAULT_MAX_AGE_MS = 6e4;
-var getEncryptionKey = (secret) => __async(null, null, function* () {
-  return yield hkdf("sha256", secret, "", "Pluv.io Generated Encryption Key", 32);
-});
-var now = () => Date.now() / 1e3 | 0;
-var authorize = (params) => {
-  const { platform, secret } = params;
-  const encode = (encodeParams) => __async(null, null, function* () {
-    const { maxAge = DEFAULT_MAX_AGE_MS, room, user } = encodeParams;
-    const encryptionSecret = yield getEncryptionKey(secret);
-    const token = yield 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);
-    return token.toString();
-  });
-  const decode = (jwt) => __async(null, null, function* () {
-    const encryptionSecret = yield getEncryptionKey(secret);
-    const { payload } = yield jwtDecrypt(jwt, encryptionSecret, {
-      clockTolerance: 15
-    });
-    return payload != null ? payload : null;
-  });
-  return { decode, encode };
+//#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);
 };
-
-// src/PluvIO.ts
-import { noop as noop3 } from "@pluv/crdt";
-
-// src/PluvProcedure.ts
-var PluvProcedure = class _PluvProcedure {
-  constructor(config = {}) {
-    this._broadcast = null;
-    this._input = null;
-    this._self = null;
-    this._sync = null;
-    const { broadcast, input, self, sync } = config;
-    this._broadcast = broadcast != null ? broadcast : null;
-    this._input = input != null ? input : null;
-    this._self = self != null ? self : null;
-    this._sync = sync != null ? sync : null;
-  }
-  get config() {
-    var _a, _b, _c, _d, _e, _f, _g;
-    return {
-      broadcast: (_b = (_a = this._broadcast) == null ? void 0 : _a.bind(this)) != null ? _b : null,
-      input: (_c = this._input) != null ? _c : null,
-      resolver: this._resolver(),
-      self: (_e = (_d = this._self) == null ? void 0 : _d.bind(this)) != null ? _e : null,
-      sync: (_g = (_f = this._sync) == null ? void 0 : _f.bind(this)) != null ? _g : null
-    };
-  }
-  broadcast(resolver) {
-    const { broadcast } = this.config;
-    if (!!broadcast) throw new Error("Broadcast was already defined for this procedure");
-    return new _PluvProcedure(__spreadProps(__spreadValues({}, this.config), {
-      broadcast: resolver
-    }));
-  }
-  input(input) {
-    return new _PluvProcedure({
-      input
-    });
-  }
-  self(resolver) {
-    const { self } = this.config;
-    if (!!self) throw new Error("Self was already defined for this procedure");
-    return new _PluvProcedure(__spreadProps(__spreadValues({}, 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(__spreadProps(__spreadValues({}, this.config), {
-      sync: resolver
-    }));
-  }
-  _resolver() {
-    return (data, context) => {
-      var _a, _b, _c;
-      return __spreadValues(__spreadValues(__spreadValues({}, (_a = this._broadcast) == null ? void 0 : _a.call(this, data, context)), (_b = this._self) == null ? void 0 : _b.call(this, data, context)), (_c = this._sync) == null ? void 0 : _c.call(this, data, context));
-    };
-  }
+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
+	};
 };
 
-// src/PluvRouter.ts
-var PluvRouter = class _PluvRouter {
-  constructor(events) {
-    this._defs = { events: {} };
-    const invalidName = Object.keys(events).find((name) => !this._isValidEventName(name));
-    if (typeof invalidName === "string") {
-      throw new Error(
-        `Invalid event name. Event names must be formatted as valid JavaScript variable names: "${invalidName}"`
-      );
-    }
-    this._defs = { events };
-  }
-  static merge(...routers) {
-    const events = Object.assign(
-      /* @__PURE__ */ Object.create(null),
-      ...routers.map((router) => router._defs.events)
-    );
-    return new _PluvRouter(events);
-  }
-  _isValidEventName(name) {
-    return /^[a-z_$][a-z0-9_$]*$/gi.test(name);
-  }
+//#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)
+			};
+		};
+	}
 };
 
-// src/PluvServer.ts
-import { noop as noop2 } from "@pluv/crdt";
-import colors2 from "kleur";
-
-// src/IORoom.ts
-import { noop } from "@pluv/crdt";
-import colors from "kleur";
+//#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);
+	}
+};
 
-// src/constants.ts
-var GARBAGE_COLLECT_INTERVAL_MS = 6e4;
-var MAX_PRESENCE_SIZE_BYTES = 512;
-var MAX_STORAGE_SIZE_BYTES = 31457280;
-var MAX_USER_ID_LENGTH = 128;
-var MAX_USER_SIZE_BYTES = 512;
-var PING_TIMEOUT_MS = 3e4;
+//#endregion
+//#region src/constants.ts
+const GARBAGE_COLLECT_INTERVAL_MS = 6e4;
+const MAX_PRESENCE_SIZE_BYTES = 512;
+const MAX_STORAGE_SIZE_BYTES = 31457280;
+const MAX_USER_ID_LENGTH = 128;
+const MAX_USER_SIZE_BYTES = 512;
+const PING_TIMEOUT_MS = 3e4;
 
-// src/utils/oneLine.ts
-var 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/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();
 };
 
-// src/utils/pickBy.ts
-var pickBy = (obj, by) => {
-  const result = {};
-  const keys = Object.keys(obj);
-  for (let i = 0; i < keys.length; ++i) {
-    const key = keys[i];
-    const value = obj[key];
-    if (by(value)) result[key] = value;
-  }
-  return result;
+//#endregion
+//#region src/utils/pickBy.ts
+const pickBy = (obj, by) => {
+	const result = {};
+	const keys = Object.keys(obj);
+	for (let i = 0; i < keys.length; ++i) {
+		const key = keys[i];
+		const value = obj[key];
+		if (by(value)) result[key] = value;
+	}
+	return result;
 };
 
-// src/IORoom.ts
+//#endregion
+//#region src/IORoom.ts
 var IORoom = class {
-  constructor(id, config) {
-    this._lastGarbageCollectMs = -1 * (GARBAGE_COLLECT_INTERVAL_MS + 1);
-    this._uninitialize = null;
-    this._authorize = null;
-    this._sessions = /* @__PURE__ */ new Map();
-    this._userSessionss = /* @__PURE__ */ new Map();
-    const {
-      _meta,
-      authorize: authorize2,
-      context,
-      crdt = noop,
-      debug,
-      getInitialStorage,
-      onDestroy,
-      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(__spreadProps(__spreadValues({}, !!_meta ? { _meta } : {}), { roomContext }));
-    this._listeners = {
-      onDestroy: (event) => onDestroy == null ? void 0 : onDestroy(event),
-      onMessage: (event) => onMessage == null ? void 0 : onMessage(event),
-      onUserConnected: (event) => onUserConnected == null ? void 0 : onUserConnected(event),
-      onUserDisconnected: (event) => onUserDisconnected == null ? void 0 : onUserDisconnected(event)
-    };
-    if (authorize2) this._authorize = authorize2;
-    const webSockets = this._platform.getWebSockets();
-    webSockets.forEach((webSocket) => {
-      var _a;
-      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 = (_a = pluvWs.session.user) == null ? void 0 : _a.id;
-      if (!!userId) this._addUserSession(userId, sessionId);
-    });
-    const { doc, uninitialize } = this._initialize();
-    this._doc = doc;
-    this._uninitialize = uninitialize;
-  }
-  /**
-   * @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() {
-    var _a;
-    return Promise.resolve(!!((_a = this._uninitialize) == null ? void 0 : _a.then((result) => !!result)));
-  }
-  /**
-   * @description Closes a connection with the specified sessionId
-   * @param sessionId The session id of the connection to close
-   */
-  evict(sessionId) {
-    return __async(this, null, function* () {
-      const session = this._sessions.get(sessionId);
-      if (session) session.state.quit = true;
-      yield this._emitQuitters();
-    });
-  }
-  /**
-   * @description Closes all connections to this room, effectively destroying
-   * the room
-   */
-  evictAll() {
-    return __async(this, null, function* () {
-      const sessions = Array.from(this._sessions.values());
-      sessions.forEach((session) => {
-        session.state.quit = true;
-      });
-      yield this._emitQuitters();
-    });
-  }
-  /**
-   * @description The IORoom will garbage collect occasionally as connections ping/pong the
-   * server
-   */
-  garbageCollect() {
-    return __async(this, null, function* () {
-      this._lastGarbageCollectMs = Date.now();
-      this._emitQuitters();
-      this._emitSyncState();
-    });
-  }
-  getSize() {
-    const currentTime = (/* @__PURE__ */ new Date()).getTime();
-    return Array.from(this._sessions.values()).reduce((count, pluvWs) => {
-      var _a;
-      if (pluvWs.state.quit) return count;
-      const pingTime = (_a = this._platform.getLastPing(pluvWs)) != null ? _a : pluvWs.state.timers.ping;
-      return currentTime - pingTime > PING_TIMEOUT_MS ? count : count + 1;
-    }, 0);
-  }
-  onClose(webSocket) {
-    this._ensureDetached();
-    const wsSession = this._getAbstractWs(webSocket);
-    if (!wsSession) return () => __async(this, null, function* () {
-      return void 0;
-    });
-    return this._onClose(wsSession);
-  }
-  onError(webSocket) {
-    this._ensureDetached();
-    const wsSession = this._getAbstractWs(webSocket);
-    if (!wsSession) return () => __async(this, null, function* () {
-      return void 0;
-    });
-    return this._onClose(wsSession);
-  }
-  onMessage(webSocket) {
-    this._ensureDetached();
-    const wsSession = this._getAbstractWs(webSocket);
-    if (!wsSession) return () => __async(this, null, function* () {
-      return void 0;
-    });
-    return this._onMessage(wsSession);
-  }
-  register(webSocket, ...options) {
-    return __async(this, null, function* () {
-      var _a, _b;
-      const _options = (_a = options[0]) != null ? _a : {};
-      const token = (_b = _options.token) != null ? _b : null;
-      const sessionId = this._platform.getSessionId(webSocket);
-      const sessionExists = typeof sessionId === "string" && this._sessions.has(sessionId);
-      if (sessionExists) return;
-      if (!(yield this._initialized)) {
-        this._initialize();
-        yield this._initialized;
-      }
-      const user = yield this._getAuthorizedUser(token, _options);
-      const ioAuthorize = this._getIOAuthorize(_options);
-      const isUnauthorized = !!ioAuthorize && !user;
-      const pluvWs = this._platform.convertWebSocket(webSocket, { room: this.id });
-      if (isUnauthorized) {
-        this._logDebug(`${colors.blue("Authorization failed for connection")}`);
-        pluvWs.handleError({ error: 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, __spreadProps(__spreadValues({}, prevState), {
-          presence: latest.presence,
-          timers: __spreadProps(__spreadValues({}, prevState.timers), { presence: latest.timer })
-        }));
-        this._addUserSession(user.id, pluvWs.sessionId);
-      }
-      this._logDebug(
-        `${colors.blue(`Registering connection for room ${this.id}:`)} ${pluvWs.sessionId}`
-      );
-      yield this._platform.acceptWebSocket(pluvWs);
-      this._sessions.set(pluvWs.sessionId, pluvWs);
-      yield this._platform.persistence.addUser(this.id, pluvWs.sessionId, user != null ? 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);
-      }
-      yield this._emitRegistered(pluvWs);
-      const size = this.getSize();
-      this._logDebug(oneLine`
+	id;
+	_doc;
+	_lastGarbageCollectMs = -1 * (GARBAGE_COLLECT_INTERVAL_MS + 1);
+	_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: authorize$1, 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$1) this._authorize = authorize$1;
+		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) > PING_TIMEOUT_MS ? 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) {
-    var _a;
-    const set = (_a = this._userSessionss.get(userId)) != null ? _a : /* @__PURE__ */ new Set();
-    const updated = set.add(sessionId);
-    this._userSessionss.set(userId, updated);
-    return updated;
-  }
-  _broadcast(params) {
-    return __async(this, null, function* () {
-      var _a, _b, _c;
-      const { message, senderId } = params;
-      const sender = senderId ? (_a = this._sessions.get(senderId)) != null ? _a : null : null;
-      const session = (_b = sender == null ? void 0 : sender.session) != null ? _b : null;
-      const user = (_c = session == null ? void 0 : session.user) != null ? _c : null;
-      if (typeof senderId !== "string") return;
-      this._platform.pubSub.publish(this.id, __spreadValues({
-        connectionId: senderId != null ? senderId : null,
-        room: this.id,
-        user
-      }, message));
-    });
-  }
-  _closeWebSockets(webSockets) {
-    return __async(this, null, function* () {
-      const closeWebSocket = (webSocket) => __async(this, null, function* () {
-        webSocket.state = __spreadProps(__spreadValues({}, webSocket.state), { quit: true });
-        const sessionId = webSocket.sessionId;
-        this._logDebug(
-          `${colors.blue(`Unregistering connection for room ${this.id}:`)} ${sessionId}`
-        );
-        this._sessions.delete(sessionId);
-        yield this._platform.persistence.deleteUser(this.id, sessionId).catch(() => null);
-        yield this._broadcast({
-          message: { type: "$exit", data: { sessionId } },
-          senderId: sessionId
-        });
-        const session = webSocket.session;
-        const user = session.user;
-        if (!!user) this._removeUserSession(user.id, sessionId);
-        try {
-          const [doc, context] = yield Promise.all([this._doc, this._getContext()]);
-          const encodedState = doc.getEncodedState();
-          yield 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((webSocket) => __async(this, null, function* () {
-        yield closeWebSocket(webSocket).catch(() => null);
-      }));
-      yield 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;
-      const uninitialize = (yield this._uninitialize).bind(this);
-      yield uninitialize();
-    });
-  }
-  _emitQuitters() {
-    return __async(this, null, function* () {
-      const currentTime = (/* @__PURE__ */ new Date()).getTime();
-      const quitters = Array.from(this._sessions.values()).filter((pluvWs) => {
-        return pluvWs.state.quit || currentTime - pluvWs.state.timers.ping > PING_TIMEOUT_MS;
-      });
-      this._closeWebSockets(quitters);
-    });
-  }
-  _emitRegistered(pluvWs) {
-    return __async(this, null, function* () {
-      const session = pluvWs.session;
-      const sessionId = session.id;
-      const presence = session.presence;
-      const user = session.user;
-      const [doc, context] = yield Promise.all([this._doc, this._getContext()]);
-      const encodedState = doc.isEmpty() ? null : doc.getEncodedState();
-      yield this._sendSelfMessage(
-        {
-          type: "$registered",
-          data: {
-            presence,
-            sessionId,
-            state: encodedState,
-            timers: { presence: session.timers.presence }
-          }
-        },
-        { sessionId, user }
-      );
-      try {
-        yield Promise.resolve(
-          this._listeners.onUserConnected({
-            context,
-            encodedState,
-            platform: this._platform,
-            room: this.id,
-            user,
-            webSocket: pluvWs.webSocket
-          })
-        );
-      } catch (err) {
-        console.error(err);
-      }
-    });
-  }
-  _emitSyncState() {
-    return __async(this, null, function* () {
-      const connectionIds = yield this._platform.persistence.getUsers(this.id).then((map) => Object.keys(map));
-      yield 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) {
-    var _a, _b;
-    if (webSocket instanceof AbstractWebSocket) return webSocket;
-    const sessionId = this._platform.getSessionId(webSocket);
-    if (typeof sessionId === "string") {
-      const session = (_a = this._sessions.get(sessionId)) != null ? _a : null;
-      if (session) return session;
-    }
-    const sessions = Array.from(this._sessions.values());
-    return (_b = sessions.find((pluvWs) => pluvWs.webSocket === webSocket)) != null ? _b : null;
-  }
-  /**
-   * TODO
-   * @description Revisit any cast types
-   * @date July 17, 2025
-   */
-  _getAuthorizedUser(token, options) {
-    return __async(this, null, function* () {
-      var _a;
-      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 = yield 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 (_a = ioAuthorize.user.parse(payload.user)) != null ? _a : null;
-      } catch (e) {
-        this._logDebug(`${colors.blue("Token fails validation:")} ${token}`);
-        return null;
-      }
-    });
-  }
-  _getContext() {
-    return __async(this, null, function* () {
-      return typeof this._context === "function" ? yield Promise.resolve(this._context(this._roomContext)) : yield Promise.resolve(this._context);
-    });
-  }
-  _getInitialDoc() {
-    return __async(this, null, function* () {
-      const doc = this._docFactory.getEmpty();
-      const [encodedState, context] = yield Promise.all([
-        this._platform.persistence.getStorageState(this.id),
-        this._getContext()
-      ]);
-      if (!encodedState) {
-        const loadedState = yield this._getInitialStorage({
-          context,
-          room: this.id
-        });
-        if (!!loadedState && !this._docFactory.isEmpty(loadedState)) {
-          doc.applyEncodedState({ update: loadedState });
-        }
-      }
-      if (typeof encodedState === "string") doc.applyEncodedState({ update: encodedState });
-      return doc;
-    });
-  }
-  _getIOAuthorize(options) {
-    if (typeof this._authorize === "function") return this._authorize(options);
-    return this._authorize;
-  }
-  _getLatestPresence(userId) {
-    var _a, _b;
-    if (!this._authorize) return { timer: null, presence: null };
-    const sessionIds = Array.from((_b = (_a = this._userSessionss.get(userId)) == null ? void 0 : _a.values()) != null ? _b : []);
-    if (!sessionIds.length) return { timer: null, presence: null };
-    return sessionIds.reduce(
-      (state, sessionId) => {
-        var _a2, _b2;
-        const pluvWs = (_a2 = this._sessions.get(sessionId)) != null ? _a2 : null;
-        if (!pluvWs) return state;
-        const session = pluvWs.session;
-        const presence = session.presence;
-        const timer = session.timers.presence;
-        if (((_b2 = session.user) == null ? void 0 : _b2.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) {
-    var _a;
-    return (_a = this._router._defs.events[message.type]) != null ? _a : 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() {
-    const sessions = Array.from(this._sessions.values()).map((pluvWs) => pluvWs.session);
-    return sessions;
-  }
-  _initialize() {
-    const promise = (() => __async(this, null, function* () {
-      this._logDebug(`${colors.blue(`Initializing room: ${this.id}`)}`);
-      if (!!this._uninitialize) {
-        const uninitialize2 = (yield this._uninitialize).bind(this);
-        yield uninitialize2();
-        this._uninitialize = null;
-      }
-      const pubSubId = yield this._platform.pubSub.subscribe(
-        this.id,
-        (_a) => __async(this, null, function* () {
-          var _b = _a, { options = {} } = _b, message = __objRest(_b, ["options"]);
-          yield promise;
-          const sender = {
-            sessionId: message.connectionId,
-            user: message.user
-          };
-          switch (options.type) {
-            case "self": {
-              yield this._sendSelfMessage(message, sender);
-              return;
-            }
-            case "sync": {
-              yield this._sendSyncMessage(message, sender);
-              return;
-            }
-            case "broadcast":
-            default: {
-              const sessionIds = options.sessionIds;
-              yield this._sendBroadcastMessage(message, sender, sessionIds);
-            }
-          }
-        })
-      );
-      const doc = yield this._getInitialDoc();
-      const uninitialize = () => __async(this, null, function* () {
-        this._platform.pubSub.unsubscribe(pubSubId);
-        const [doc2, context] = yield Promise.all([this._doc, this._getContext()]);
-        const encodedState = doc2.getEncodedState();
-        doc2.destroy();
-        this._doc = Promise.resolve(this._docFactory.getEmpty());
-        yield Promise.resolve(
-          this._listeners.onDestroy(__spreadProps(__spreadValues({}, "_meta" in this._platform && !!this._platform._meta ? { _meta: this._platform._meta } : {}), {
-            context,
-            encodedState,
-            platform: this._platform,
-            room: this.id
-          }))
-        );
-        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(this, null, function* () {
-      if (!(yield this._initialized)) return;
-      yield this._closeWebSockets([webSocket]);
-    });
-  }
-  _onMessage(webSocket) {
-    return (event) => __async(this, null, function* () {
-      var _a, _b, _c, _d, _e, _f;
-      if (!(yield 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] = yield Promise.all([this._doc, this._getContext()]);
-      const eventContext = {
-        context,
-        doc,
-        garbageCollect: () => __async(this, null, function* () {
-          yield this.garbageCollect();
-        }),
-        platform: this._platform,
-        get presence() {
-          return session.presence;
-        },
-        set presence(presence) {
-          var _a2;
-          const sessionId2 = (_a2 = this.session) == null ? void 0 : _a2.id;
-          if (!sessionId2) return;
-          setPresence({ presence, sessionId: sessionId2, timer: this.time });
-        },
-        room: this.id,
-        session,
-        sessions,
-        time: (/* @__PURE__ */ new Date()).getTime()
-      };
-      if (pluvWs.state.quit) {
-        yield 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(__spreadProps(__spreadValues({}, "_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) {
-        yield 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;
-      }
-      yield Promise.all([
-        (_b = (_a = procedure.config).broadcast) == null ? void 0 : _b.call(_a, inputs, eventContext),
-        (_d = (_c = procedure.config).self) == null ? void 0 : _d.call(_c, inputs, eventContext),
-        (_f = (_e = procedure.config).sync) == null ? void 0 : _f.call(_e, inputs, eventContext)
-      ]).then((_0) => __async(this, [_0], function* ([broadcast, self, sync]) {
-        const handleBroadcast = () => __async(this, null, function* () {
-          if (!broadcast) return;
-          const messages = Object.entries(broadcast).map((_02) => __async(this, [_02], function* ([type, data]) {
-            yield this._broadcast({
-              message: { data, type },
-              senderId: sessionId
-            });
-          }));
-          yield Promise.all(messages);
-        });
-        const handleSelf = () => __async(this, null, function* () {
-          if (!self) return;
-          const messages = Object.entries(self).map((_02) => __async(this, [_02], function* ([type, data]) {
-            yield this._sendSelfMessage({ data, type }, { sessionId, user });
-          }));
-          yield Promise.all(messages);
-        });
-        const handleSync = () => __async(this, null, function* () {
-          if (!sync) return;
-          yield this._platform.pubSub.publish(this.id, __spreadValues({
-            connectionId: session.id,
-            options: { type: "sync" },
-            room: this.id,
-            user
-          }, message));
-          const messages = Object.entries(sync).map((_02) => __async(this, [_02], function* ([type, data]) {
-            yield this._sendSelfMessage({ data, type }, { sessionId, user });
-          }));
-          yield Promise.all(messages);
-        });
-        yield Promise.all([handleBroadcast(), handleSelf(), handleSync()]);
-      }));
-    });
-  }
-  _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 (e) {
-      return null;
-    }
-  }
-  _setPresence(params) {
-    var _a, _b;
-    const { presence, sessionId, timer: _timer } = params;
-    const timer = _timer != null ? _timer : (/* @__PURE__ */ new Date()).getTime();
-    const pluvWs = (_a = this._sessions.get(sessionId)) != null ? _a : null;
-    if (!pluvWs) return;
-    const wsSession = pluvWs.session;
-    const user = wsSession.user;
-    const sessionIds = user ? /* @__PURE__ */ new Set([...(_b = this._userSessionss.get(user.id)) != null ? _b : [], sessionId]) : /* @__PURE__ */ new Set([sessionId]);
-    sessionIds.forEach((sId) => {
-      const pWs = this._sessions.get(sId);
-      const session = pWs == null ? void 0 : pWs.session;
-      if (!session) return;
-      const prevState = session.webSocket.state;
-      this._platform.setSerializedState(session.webSocket, __spreadProps(__spreadValues({}, prevState), {
-        presence,
-        timers: __spreadProps(__spreadValues({}, 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;
-  }
-  _sendMessage(pluvWs, message) {
-    return __async(this, null, function* () {
-      if (!(yield this._initialized)) return;
-      yield Promise.resolve(pluvWs.sendMessage(message));
-    });
-  }
-  _sendBroadcastMessage(message, sender, sessionIds) {
-    return __async(this, null, function* () {
-      var _a, _b;
-      const { data, type } = message;
-      const connectionId = (_a = sender == null ? void 0 : sender.sessionId) != null ? _a : null;
-      const room = this.id;
-      if (typeof connectionId !== "string") return;
-      const webSockets = (_b = sessionIds == null ? void 0 : sessionIds.reduce((dict, id) => {
-        const pluvWs = this._sessions.get(id);
-        return pluvWs ? dict.set(id, pluvWs) : dict;
-      }, /* @__PURE__ */ new Map())) != null ? _b : this._sessions;
-      const promises = Array.from(webSockets.values()).map((pluvWs) => __async(this, null, function* () {
-        var _a2;
-        const session = pluvWs.session;
-        const user = (_a2 = session.user) != null ? _a2 : null;
-        this._sendMessage(pluvWs, { connectionId, data, room, type, user });
-      }));
-      yield Promise.all(promises);
-    });
-  }
-  _sendSelfMessage(message, sender) {
-    return __async(this, null, function* () {
-      var _a, _b;
-      const senderId = (_a = sender == null ? void 0 : sender.sessionId) != null ? _a : null;
-      if (typeof senderId !== "string") return;
-      const pluvWs = this._sessions.get(senderId);
-      if (!pluvWs) return;
-      if (message.type === "$pong") {
-        const elapsedMs = Date.now() - this._lastGarbageCollectMs;
-        if (elapsedMs > GARBAGE_COLLECT_INTERVAL_MS) {
-          yield this.garbageCollect();
-        }
-      }
-      const session = pluvWs.session;
-      const user = (_b = session.user) != null ? _b : null;
-      this._sendMessage(pluvWs, __spreadValues({
-        connectionId: senderId,
-        room: this.id,
-        user
-      }, message));
-    });
-  }
-  _sendSyncMessage(message, sender) {
-    return __async(this, null, function* () {
-      var _a;
-      if (!sender) return;
-      const connectionId = sender.sessionId;
-      if (typeof connectionId !== "string") return;
-      const [doc, context] = yield Promise.all([this._doc, this._getContext()]);
-      const resolverCtx = {
-        context,
-        doc,
-        garbageCollect: () => __async(this, null, function* () {
-          yield this.garbageCollect();
-        }),
-        platform: this._platform,
-        get presence() {
-          return null;
-        },
-        set presence(presence) {
-          return;
-        },
-        room: this.id,
-        session: null,
-        sessions: this._getSessions(),
-        time: (/* @__PURE__ */ new Date()).getTime()
-      };
-      const resolver = (_a = this._getProcedure(message)) == null ? void 0 : _a.config.sync;
-      if (!resolver) return;
-      let inputs;
-      try {
-        inputs = this._getProcedureInputs(message);
-      } catch (e) {
-        return;
-      }
-      Promise.resolve(resolver(inputs, resolverCtx)).then((output) => {
-        if (!output) return;
-        Object.keys(output).forEach((type) => {
-          var _a2, _b;
-          const data = (_a2 = output[type]) != null ? _a2 : {};
-          this._platform.pubSub.publish(this.id, {
-            connectionId,
-            data,
-            options: { type: "self" },
-            room: this.id,
-            type,
-            user: (_b = sender.user) != null ? _b : null
-          });
-        });
-      });
-    });
-  }
+		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 > PING_TIMEOUT_MS;
+		});
+		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;
+					case "broadcast":
+					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$1, context] = await Promise.all([this._doc, this._getContext()]);
+				const encodedState = doc$1.getEncodedState();
+				doc$1.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$1 = this.session?.id;
+					if (!sessionId$1) return;
+					setPresence({
+						presence,
+						sessionId: sessionId$1,
+						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 ? new Set([...this._userSessionss.get(user.id) ?? [], sessionId]) : 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 > GARBAGE_COLLECT_INTERVAL_MS) 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
+				});
+			});
+		});
+	}
 };
 
-// src/version.generated.ts
-var version = "3.2.2";
+//#endregion
+//#region src/version.generated.ts
+const version = "4.0.1";
 
-// src/PluvServer.ts
+//#endregion
+//#region src/PluvServer.ts
 var PluvServer = class {
-  constructor(options) {
-    this.version = version;
-    this._getInitialStorage = (...args) => {
-      var _a;
-      const getInitialStorage = typeof this._config.getInitialStorage !== "string" ? (_a = this._config.getInitialStorage) != null ? _a : () => null : () => null;
-      return getInitialStorage(...args);
-    };
-    this._config = __spreadValues({
-      crdt: noop2,
-      debug: false,
-      router: new PluvRouter({})
-    }, options);
-    const {
-      onRoomDeleted,
-      onRoomMessage,
-      onStorageUpdated,
-      onUserConnected,
-      onUserDisconnected
-    } = options;
-    this._docFactory = this._config.crdt.doc(() => ({}));
-    this._listeners = {
-      onRoomDeleted: (event) => onRoomDeleted == null ? void 0 : onRoomDeleted(event),
-      onRoomMessage: (event) => onRoomMessage == null ? void 0 : onRoomMessage(event),
-      onStorageUpdated: (event) => onStorageUpdated == null ? void 0 : onStorageUpdated(event),
-      onUserConnected: (event) => onUserConnected == null ? void 0 : onUserConnected(event),
-      onUserDisconnected: (event) => onUserDisconnected == null ? void 0 : onUserDisconnected(event)
-    };
-  }
-  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();
-        const others = sessions.filter((wsSession) => {
-          if (wsSession.id === (session == null ? void 0 : session.id)) return false;
-          if (wsSession.quit) return false;
-          if (currentTime - wsSession.timers.ping > PING_TIMEOUT_MS) return false;
-          return true;
-        }).reduce(
-          (acc, { id, presence, timers, user }) => __spreadProps(__spreadValues({}, acc), {
-            [id]: {
-              connectionId: id,
-              presence,
-              room,
-              timers: { presence: timers.presence },
-              user
-            }
-          }),
-          {}
-        );
-        return { $othersReceived: { others } };
-      }),
-      $initializeSession: this._procedure.broadcast((data, { session }) => {
-        const presence = data == null ? void 0 : 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((_0, _1) => __async(this, [_0, _1], function* (data, { context, doc, platform, room, session }) {
-        const oldState = yield platform.persistence.getStorageState(room);
-        const update = data == null ? void 0 : data.update;
-        if (!oldState) {
-          const loadedState = yield this._getInitialStorage({ context, room });
-          if (!!loadedState && !this._docFactory.isEmpty(loadedState)) {
-            doc.applyEncodedState({ update: loadedState });
-          }
-        }
-        if (!doc.isEmpty()) {
-          const encodedState2 = doc.getEncodedState();
-          return {
-            $storageReceived: { changeKind: "unchanged", state: encodedState2 }
-          };
-        }
-        if (!!update) {
-          const encodedState2 = doc.applyEncodedState({ update }).getEncodedState();
-          const storageSize = new TextEncoder().encode(encodedState2).length;
-          if (!!this._config.limits.storageMaxSize && storageSize > this._config.limits.storageMaxSize) {
-            throw new Error("Storage has exceeded the size limit");
-          }
-          yield platform.persistence.setStorageState(room, encodedState2).catch((error) => {
-            this._logDebug(error);
-          });
-          listeners.onStorageUpdated({
-            context,
-            encodedState: encodedState2,
-            platform,
-            room,
-            user: session == null ? void 0 : session.user,
-            webSocket: session == null ? void 0 : session.webSocket.webSocket
-          });
-          return {
-            $storageReceived: { changeKind: "initialized", state: encodedState2 }
-          };
-        }
-        const encodedState = doc.getEncodedState();
-        return { $storageReceived: { changeKind: "empty", state: encodedState } };
-      })),
-      $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, __spreadProps(__spreadValues({}, prevState), {
-          timers: __spreadProps(__spreadValues({}, prevState.timers), {
-            ping: currentTime
-          })
-        }));
-        return { $pong: {} };
-      }),
-      $updatePresence: this._procedure.broadcast((data, context) => {
-        const presence = data == null ? void 0 : data.presence;
-        const { session } = context;
-        if (!session) return {};
-        const cleanedPatch = pickBy(
-          presence != null ? presence : {},
-          (value) => typeof value !== "undefined"
-        );
-        const updated = Object.assign(/* @__PURE__ */ 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`
+	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 > PING_TIMEOUT_MS) 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 }) => {
-        var _a;
-        const origin = data == null ? void 0 : data.origin;
-        const update = (_a = data == null ? void 0 : data.update) != null ? _a : null;
-        if (origin === "$initialized" && Object.keys(doc.toJson()).length) return {};
-        const updated = update === null ? doc : doc.applyEncodedState({ update });
-        const encodedState = updated.getEncodedState();
-        const storageSize = new TextEncoder().encode(encodedState).length;
-        if (!!this._config.limits.storageMaxSize && storageSize > this._config.limits.storageMaxSize) {
-          throw new Error(oneLine`
+				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;
-  }
-  createRoom(room, ...options) {
-    var _a, _c;
-    const _b = (_a = options[0]) != null ? _a : {}, { _meta, debug, onDestroy, onMessage } = _b, platformRoomContext = __objRest(_b, ["_meta", "debug", "onDestroy", "onMessage"]);
-    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, __spreadProps(__spreadValues({}, !!_meta ? { _meta } : {}), {
-      authorize: (_c = this._config.authorize) != null ? _c : void 0,
-      context: this._config.context,
-      crdt: this._config.crdt,
-      debug: debug != null ? debug : this._config.debug,
-      getInitialStorage: this._getInitialStorage,
-      onDestroy(event) {
-        return __async(this, null, function* () {
-          logDebug(`${colors2.blue("Deleting empty room:")} ${room}`);
-          yield Promise.resolve(onDestroy == null ? void 0 : onDestroy(event));
-          yield Promise.resolve(listeners.onRoomDeleted(event));
-          yield event.platform.persistence.deleteStorageState(room);
-          logDebug(`${colors2.blue("Deleted room:")} ${room}`);
-        });
-      },
-      onMessage(event) {
-        return __async(this, null, function* () {
-          yield Promise.resolve(onMessage == null ? void 0 : onMessage(event));
-          yield Promise.resolve(listeners.onRoomMessage(event));
-        });
-      },
-      onUserConnected(event) {
-        return __async(this, null, function* () {
-          yield Promise.resolve(listeners.onUserConnected(event));
-        });
-      },
-      onUserDisconnected(event) {
-        return __async(this, null, function* () {
-          yield Promise.resolve(listeners.onUserDisconnected(event));
-        });
-      },
-      platform,
-      roomContext,
-      router: this._router
-    }));
-    this._logDebug(`${colors2.blue("Created room:")} ${room}`);
-    return newRoom;
-  }
-  createToken(params) {
-    return __async(this, null, function* () {
-      return yield this._config.io.createToken(params);
-    });
-  }
-  _getListeners() {
-    return this._listeners;
-  }
-  _logDebug(...data) {
-    if (this._config.debug) console.log(...data);
-  }
+				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);
+	}
 };
 
-// src/PluvIO.ts
+//#endregion
+//#region src/PluvIO.ts
 var PluvIO = class {
-  constructor(options) {
-    this.version = version;
-    this._authorize = null;
-    this._context = {};
-    const { authorize: authorize2, context, crdt = noop3, debug = false, limits, platform } = options;
-    this._crdt = crdt;
-    this._debug = debug;
-    this._limits = __spreadValues({
-      presenceMaxSize: MAX_PRESENCE_SIZE_BYTES,
-      storageMaxSize: MAX_STORAGE_SIZE_BYTES,
-      userIdMaxLength: MAX_USER_ID_LENGTH,
-      userMaxSize: MAX_USER_SIZE_BYTES
-    }, limits);
-    this._platform = platform;
-    if (authorize2) this._authorize = authorize2;
-    if (context) this._context = context;
-  }
-  get procedure() {
-    return new PluvProcedure();
-  }
-  createToken(params) {
-    return __async(this, null, function* () {
-      var _a;
-      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`
+	version = version;
+	_authorize = null;
+	_context = {};
+	_crdt;
+	_debug;
+	_limits;
+	_platform;
+	get procedure() {
+		return new PluvProcedure();
+	}
+	constructor(options) {
+		const { authorize: authorize$1, context, crdt = noop, debug = false, limits, platform } = options;
+		this._crdt = crdt;
+		this._debug = debug;
+		this._limits = {
+			presenceMaxSize: MAX_PRESENCE_SIZE_BYTES,
+			storageMaxSize: MAX_STORAGE_SIZE_BYTES,
+			userIdMaxLength: MAX_USER_ID_LENGTH,
+			userMaxSize: MAX_USER_SIZE_BYTES,
+			...limits
+		};
+		this._platform = platform;
+		if (authorize$1) this._authorize = authorize$1;
+		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`
+		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();
-      if (platform._createToken) {
-        return yield platform._createToken(__spreadProps(__spreadValues({}, params), { authorize: ioAuthorize }));
-      }
-      const secret = (_a = ioAuthorize == null ? void 0 : ioAuthorize.secret) != null ? _a : null;
-      if (!secret) throw new Error("`authorize` was specified without a valid secret");
-      return yield 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`
+		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) {
-    var _a, _b;
-    const serverConfig = (_a = config[0]) != null ? _a : {};
-    return new PluvServer(__spreadProps(__spreadValues({}, serverConfig), {
-      authorize: (_b = this._authorize) != null ? _b : 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;
-  }
+		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;
+	}
 };
 
-// src/createIO.ts
-var createIO = (params) => {
-  const { authorize: authorize2, context, crdt, debug, limits, platform } = params;
-  return new PluvIO({
-    authorize: authorize2,
-    context,
-    crdt,
-    debug,
-    limits,
-    platform
-  });
-};
-export {
-  AbstractPersistence,
-  AbstractPlatform,
-  AbstractPubSub,
-  AbstractWebSocket,
-  PluvIO,
-  PluvProcedure,
-  PluvRouter,
-  PluvServer,
-  authorize,
-  createIO
+//#endregion
+//#region src/createIO.ts
+const createIO = (params) => {
+	const { authorize: authorize$1, context, crdt, debug, limits, platform } = params;
+	return new PluvIO({
+		authorize: authorize$1,
+		context,
+		crdt,
+		debug,
+		limits,
+		platform
+	});
 };
+
+//#endregion
+export { AbstractPersistence, AbstractPlatform, AbstractPubSub, AbstractWebSocket, PluvIO, PluvProcedure, PluvRouter, PluvServer, authorize, createIO };
+//# sourceMappingURL=index.mjs.map