@pluv/io 0.0.0-canary-20261027014949

package/dist/index.mjs

@@ -0,0 +1,3591 @@
+import { hkdf } from "@panva/hkdf";
+import { EncryptJWT, jwtDecrypt } from "jose";
+import { noop } from "@pluv/crdt";
+import colors from "kleur";
+// src/utils/ArmedWait.ts
+/**
+* The first `arm` starts one wait. Another `arm` during that wait does nothing.
+* When the wait ends, `work` runs. `keepAlive` covers the wait and that work.
+* `clear` cancels a pending wait and settles `keepAlive` without running `work`.
+*/
+var ArmedWait = class {
+	_intervalMs;
+	_keepAlive;
+	_done = null;
+	_timer = null;
+	constructor(_intervalMs, _keepAlive) {
+		this._intervalMs = _intervalMs;
+		this._keepAlive = _keepAlive;
+	}
+	arm(work) {
+		if (this._timer) return;
+		const pending = new Promise((resolve) => {
+			this._done = resolve;
+			this._timer = setTimeout(() => {
+				this._timer = null;
+				this._done = null;
+				work().finally(resolve);
+			}, this._intervalMs);
+		});
+		this._keepAlive(pending);
+	}
+	clear() {
+		if (!this._timer) return;
+		clearTimeout(this._timer);
+		this._timer = null;
+		const done = this._done;
+		this._done = null;
+		done?.();
+	}
+};
+// src/utils/assertExhaustive.ts
+const assertExhaustive = (value) => {
+	throw new Error(`Unhandled value: ${value}`);
+};
+const JS_IDENTIFIER = /^[a-z_$][a-z0-9_$]*$/i;
+const MAX_STORAGE_SIZE_BYTES = 31457280;
+const PING_TIMEOUT_MS = 3e4;
+const DEFAULT_MAX_CONNECTIONS = 256;
+const STORAGE_EDITS_INTERVAL_MS = 1e3;
+const STORAGE_SNAPSHOT_INTERVAL_MS = 1e3;
+const LIST_USERS_DEFAULT_LIMIT = 50;
+const LIST_USERS_MAX_LIMIT = 100;
+const SERVER_ORIGIN_EVENTS = [
+	"$error",
+	"$roomStats",
+	"$syncStateReceived"
+];
+const isServerOriginEvent = (type) => {
+	return SERVER_ORIGIN_EVENTS.includes(type);
+};
+// 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/assertPresenceFanoutBudget.ts
+const resolveMaxConnections = (limits) => {
+	const maxConnections = limits.maxConnections ?? 256;
+	if (!Number.isInteger(maxConnections) || maxConnections < 1) throw new Error(`limits.maxConnections must be a positive integer. Received: ${String(limits.maxConnections)}.`);
+	return maxConnections;
+};
+const assertPresenceFanoutBudget = (limits) => {
+	const maxConnections = resolveMaxConnections(limits);
+	if (maxConnections * maxConnections <= 1e5) return;
+	if (limits.dangerouslyAllowHighPresenceFanout) return;
+	throw new Error(oneLine`
+        maxConnections (${maxConnections.toLocaleString()}) is too high.
+        Set dangerouslyAllowHighPresenceFanout: true to allow this.
+    `);
+};
+// src/PluvRouter.ts
+var PluvRouter = class {
+	_defs = { events: {} };
+	/** Event names this router defines. */
+	eventNames = /* @__PURE__ */ new Set();
+	constructor(events) {
+		const names = Object.keys(events);
+		assertEventNames(names, { allowDollar: false });
+		this._defs = { events };
+		this.eventNames = new Set(names);
+	}
+	static merge(...routers) {
+		const seen = /* @__PURE__ */ new Set();
+		for (const router of routers) for (const name of Object.keys(router._defs.events)) {
+			if (seen.has(name)) throw new Error(`Duplicate event name "${name}" when merging routers`);
+			seen.add(name);
+		}
+		const events = Object.assign(Object.create(null), ...routers.map((router) => router._defs.events));
+		return createInternalPluvRouter(events);
+	}
+};
+// src/utils/assertEventNames.ts
+const assertEventNames = (names, options = {}) => {
+	const allowDollar = options.allowDollar ?? false;
+	for (const name of names) {
+		if (!allowDollar && name.includes("$")) throw new Error(oneLine`
+                Invalid event name. Event names must not contain $: "${name}"
+            `);
+		if (!JS_IDENTIFIER.test(name)) throw new Error(`Invalid event name. Event names must be formatted as valid JavaScript variable names: "${name}"`);
+	}
+};
+// src/utils/createInternalPluvRouter.ts
+/**
+* Build a router that may include `$` protocol events. Not part of the public
+* package API — import via `__internal` or sibling modules under `@pluv/io`.
+*/
+const createInternalPluvRouter = (events) => {
+	const names = Object.keys(events);
+	assertEventNames(names, { allowDollar: true });
+	const router = Object.create(PluvRouter.prototype);
+	router._defs = { events };
+	router.eventNames = new Set(names);
+	return router;
+};
+// src/utils/getLiveSessions.ts
+const getLiveSessions = (sessions) => {
+	return sessions.filter((session) => !session.quit);
+};
+// src/utils/sessionKind.ts
+const getSessionKind = (session) => {
+	switch (session.kind) {
+		case "operator":
+		case "user": return session.kind;
+		default: return assertExhaustive(session.kind);
+	}
+};
+const getSessionOperator = (session) => {
+	const kind = getSessionKind(session);
+	switch (kind) {
+		case "operator": return session.operator ?? null;
+		case "user": return null;
+		default: return assertExhaustive(kind);
+	}
+};
+// src/utils/getMyConnectionIds.ts
+const getMyConnectionIds = (sessions, requester) => {
+	if (!requester) return [];
+	const live = getLiveSessions(sessions);
+	const kind = getSessionKind(requester);
+	const userId = requester.user?.id;
+	if (typeof userId !== "string") return [requester.id];
+	return live.filter((session) => getSessionKind(session) === kind && session.user?.id === userId).map((session) => session.id);
+};
+// src/utils/getRoomStatsFromSessions.ts
+const getRoomStatsFromSessions = (sessions) => {
+	const live = getLiveSessions(sessions);
+	const occupantIds = /* @__PURE__ */ new Set();
+	const operatorIds = /* @__PURE__ */ new Set();
+	let occupantConnections = 0;
+	let operatorConnections = 0;
+	for (const session of live) {
+		const kind = getSessionKind(session);
+		const userId = session.user?.id;
+		switch (kind) {
+			case "operator":
+				operatorConnections += 1;
+				if (typeof userId === "string") operatorIds.add(userId);
+				break;
+			case "user":
+				occupantConnections += 1;
+				if (typeof userId === "string") occupantIds.add(userId);
+				break;
+			default: assertExhaustive(kind);
+		}
+	}
+	return {
+		user: {
+			connectionCount: occupantConnections,
+			userCount: occupantIds.size
+		},
+		operator: {
+			connectionCount: operatorConnections,
+			userCount: operatorIds.size
+		}
+	};
+};
+// src/utils/groupLiveUsers.ts
+/**
+* Group live sockets by `(kind, user id)`. Extra tabs of the same kind share
+* one row. The socket with the newest `seq.presence` supplies `presence`,
+* `data`, and `operator`. `excludeSessionId` drops that person's whole row.
+* `key` is `user.id`.
+*/
+const groupLiveUsers = (sessions, options = {}) => {
+	const live = getLiveSessions(sessions);
+	const excluded = options.excludeSessionId ? live.find((session) => session.id === options.excludeSessionId) : null;
+	const excludedRef = excluded ? liveUserKey(excluded) : null;
+	const kinds = options.kinds ? new Set(options.kinds) : null;
+	const grouped = {
+		operator: /* @__PURE__ */ new Map(),
+		user: /* @__PURE__ */ new Map()
+	};
+	const presenceSeqs = {
+		operator: /* @__PURE__ */ new Map(),
+		user: /* @__PURE__ */ new Map()
+	};
+	for (const session of live) {
+		const ref = liveUserKey(session);
+		if (!ref) continue;
+		if (kinds && !kinds.has(ref.kind)) continue;
+		if (sameParticipant(ref, excludedRef)) continue;
+		const rows = rowsForKind(grouped, ref.kind);
+		const seqs = seqsForKind(presenceSeqs, ref.kind);
+		const row = rows.get(ref.id);
+		const presenceSeq = session.seq.presence;
+		const operator = getSessionOperator(session);
+		if (!row) {
+			rows.set(ref.id, {
+				connectionIds: [session.id],
+				data: session.user,
+				key: ref.id,
+				kind: ref.kind,
+				operator,
+				presence: session.presence
+			});
+			seqs.set(ref.id, presenceSeq);
+			continue;
+		}
+		row.connectionIds.push(session.id);
+		const previousSeq = seqs.get(ref.id) ?? null;
+		if (typeof presenceSeq !== "number") continue;
+		if (typeof previousSeq === "number" && presenceSeq <= previousSeq) continue;
+		row.data = session.user;
+		row.operator = operator;
+		row.presence = session.presence;
+		seqs.set(ref.id, presenceSeq);
+	}
+	return [...grouped.user.values(), ...grouped.operator.values()];
+};
+const liveUserKey = (session) => {
+	const kind = getSessionKind(session);
+	const id = session.user?.id;
+	if (typeof id !== "string") return null;
+	return {
+		kind,
+		id
+	};
+};
+const sameParticipant = (a, b) => {
+	return !!a && !!b && a.kind === b.kind && a.id === b.id;
+};
+const rowsForKind = (grouped, kind) => {
+	switch (kind) {
+		case "operator": return grouped.operator;
+		case "user": return grouped.user;
+		default: return assertExhaustive(kind);
+	}
+};
+const seqsForKind = (seqs, kind) => {
+	switch (kind) {
+		case "operator": return seqs.operator;
+		case "user": return seqs.user;
+		default: return assertExhaustive(kind);
+	}
+};
+// src/utils/invokeProcedureResolvers.ts
+/**
+* Runs `self` first. A synchronous throw must not start `broadcast`.
+* If `broadcast` throws after `self` returned a promise, that work still runs.
+* The promise stays attached so its rejection is not unhandled.
+*/
+const invokeProcedureResolvers = (resolvers) => {
+	let selfResult;
+	try {
+		selfResult = resolvers.self();
+	} catch (error) {
+		return {
+			ok: false,
+			error
+		};
+	}
+	try {
+		return {
+			ok: true,
+			broadcast: resolvers.broadcast(),
+			self: selfResult
+		};
+	} catch (error) {
+		Promise.resolve(selfResult).catch(() => void 0);
+		return {
+			ok: false,
+			error
+		};
+	}
+};
+// src/utils/isThenable.ts
+const isThenable = (value) => typeof value === "object" && value !== null && typeof value.then === "function";
+// src/utils/listLiveUsers.ts
+const participantOrder = (kind) => {
+	switch (kind) {
+		case "user": return 0;
+		case "operator": return 1;
+		default: return assertExhaustive(kind);
+	}
+};
+const compareToCursor = (row, cursor) => {
+	const byKind = participantOrder(row.kind) - participantOrder(cursor.kind);
+	if (byKind !== 0) return byKind;
+	if (row.key < cursor.id) return -1;
+	if (row.key > cursor.id) return 1;
+	return 0;
+};
+const listLiveUsers = (sessions, options) => {
+	const rows = groupLiveUsers(sessions, { kinds: options.kinds ?? ["user"] }).toSorted((left, right) => {
+		const byKind = participantOrder(left.kind) - participantOrder(right.kind);
+		if (byKind !== 0) return byKind;
+		if (left.key < right.key) return -1;
+		if (left.key > right.key) return 1;
+		return 0;
+	});
+	const cursor = options.cursor ?? null;
+	const startIndex = cursor == null ? 0 : rows.findIndex((row) => compareToCursor(row, cursor) > 0);
+	const from = startIndex < 0 ? rows.length : startIndex;
+	const slice = rows.slice(from, from + options.limit);
+	const hasNextPage = from + slice.length < rows.length;
+	const last = slice.at(-1);
+	return {
+		pageInfo: {
+			endCursor: last ? {
+				kind: last.kind,
+				id: last.key
+			} : null,
+			hasNextPage
+		},
+		users: slice.map((row) => ({
+			data: row.data,
+			kind: row.kind,
+			operator: row.operator
+		}))
+	};
+};
+// src/utils/resolveListUsersLimit.ts
+const resolveListUsersLimit = (limit) => {
+	const resolved = limit ?? 50;
+	if (!Number.isInteger(resolved) || resolved < 1 || resolved > 100) return {
+		success: false,
+		error: {
+			code: "INVALID_LIMIT",
+			message: `Invalid listUsers limit. Limit must be an integer from 1 to ${100 .toLocaleString()}. Received: ${String(limit)}.`
+		}
+	};
+	return {
+		success: true,
+		limit: resolved
+	};
+};
+// src/utils/pageLiveUsers.ts
+const pageLiveUsers = (sessions, options = {}) => {
+	const resolved = resolveListUsersLimit(options.limit);
+	if (!resolved.success) return resolved;
+	return {
+		success: true,
+		...listLiveUsers(sessions, {
+			cursor: options.cursor ?? null,
+			kinds: options.kinds,
+			limit: resolved.limit
+		})
+	};
+};
+// src/utils/parseOperatorUser.ts
+const parseOperatorUser = (value) => {
+	if (!value || typeof value !== "object") throw new Error("Invalid operator");
+	const record = value;
+	if (typeof record.id !== "string" || !record.id) throw new Error("Invalid operator id");
+	if (typeof record.name !== "string") throw new Error("Invalid operator name");
+	if (record.imageUrl !== null && typeof record.imageUrl !== "string") throw new Error("Invalid operator imageUrl");
+	return {
+		id: record.id,
+		name: record.name,
+		imageUrl: record.imageUrl
+	};
+};
+// src/utils/parsePluvSchema.ts
+function parsePluvSchema(schema, data) {
+	const result = schema["~standard"].validate(data);
+	if (result instanceof Promise) throw new Error("Async schemas are not supported. Schema validate() must be synchronous.");
+	if (result.issues) {
+		const message = result.issues[0]?.message ?? "Invalid input";
+		throw new Error(message);
+	}
+	return result.value;
+}
+// src/utils/pickBy.ts
+const pickBy = (obj, by) => {
+	const result = {};
+	const keys = Object.keys(obj);
+	for (let i = 0; i < keys.length; ++i) {
+		const key = keys[i];
+		const value = obj[key];
+		if (by(value)) result[key] = value;
+	}
+	return result;
+};
+// src/utils/resolveIOSecret.ts
+/**
+* Resolve a static or context-function JWT secret.
+*/
+const resolveIOSecret = (secret, context) => {
+	if (typeof secret === "function") return secret(context);
+	return secret;
+};
+// src/utils/throttle.ts
+const throttle = (fn, options) => {
+	const { wait } = options;
+	let lastInvokeMs = Number.NEGATIVE_INFINITY;
+	let pending = false;
+	let timer = null;
+	const flush = () => {
+		lastInvokeMs = Date.now();
+		pending = false;
+		fn();
+	};
+	const schedule = () => {
+		pending = true;
+		if (timer) return;
+		const remaining = wait - (Date.now() - lastInvokeMs);
+		timer = setTimeout(() => {
+			timer = null;
+			if (!pending) return;
+			flush();
+		}, remaining <= 0 ? 0 : remaining);
+	};
+	const cancel = () => {
+		if (timer) {
+			clearTimeout(timer);
+			timer = null;
+		}
+		pending = false;
+	};
+	return {
+		cancel,
+		schedule
+	};
+};
+// src/AbstractPersistence.ts
+var AbstractPersistence = class {};
+// src/Persistence.ts
+var Persistence = class extends AbstractPersistence {
+	_storages = /* @__PURE__ */ new Map();
+	_users = /* @__PURE__ */ new Map();
+	addUser(room, connectionId, user) {
+		const users = this._users.get(room) ?? /* @__PURE__ */ new Map();
+		this._users.set(room, users);
+		users.set(connectionId, user);
+		return Promise.resolve();
+	}
+	deleteStorageState(room) {
+		this._storages.delete(room);
+		return Promise.resolve();
+	}
+	async deleteUser(room, connectionId) {
+		const users = this._users.get(room);
+		if (!users) return;
+		users.delete(connectionId);
+		if (!users.size) {
+			await this.deleteUsers(room);
+			await this.deleteStorageState(room);
+		}
+		return Promise.resolve();
+	}
+	deleteUsers(room) {
+		this._users.delete(room);
+		return Promise.resolve();
+	}
+	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.get(room)?.size ?? 0;
+	}
+	initialize(roomContext) {
+		return this;
+	}
+	setStorageState(room, state) {
+		this._storages.set(room, state);
+		return Promise.resolve();
+	}
+};
+// src/AbstractPubSub.ts
+var AbstractPubSub = class {};
+// src/PubSub.ts
+var PubSub = class extends AbstractPubSub {
+	_nextId = 0;
+	_rooms = /* @__PURE__ */ new Map();
+	async publish(roomName, payload) {
+		const room = this._rooms.get(roomName);
+		if (!room?.size) return;
+		await Promise.all([...room.values()].map((handler) => Promise.resolve(handler(payload))));
+	}
+	subscribe(roomName, onMessage) {
+		const id = this._nextId++;
+		const room = this._rooms.get(roomName) ?? /* @__PURE__ */ new Map();
+		room.set(id, onMessage);
+		this._rooms.set(roomName, room);
+		return Promise.resolve(id);
+	}
+	unsubscribe(subscriptionId) {
+		for (const [roomName, room] of this._rooms) {
+			if (!room.delete(subscriptionId)) continue;
+			if (room.size === 0) this._rooms.delete(roomName);
+			return;
+		}
+	}
+};
+// src/AbstractPlatform.ts
+var AbstractPlatform = class {
+	_initContext;
+	_roomContext;
+	_initialized = false;
+	_keptAlive = /* @__PURE__ */ new Set();
+	persistence;
+	pubSub;
+	_createToken;
+	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();
+	}
+	/**
+	* Retain `promise` until it settles. Cloudflare uses this to keep the isolate awake.
+	* The default holds the reference and does nothing else.
+	*/
+	keepAlive(promise) {
+		this._keptAlive.add(promise);
+		promise.finally(() => {
+			this._keptAlive.delete(promise);
+		});
+	}
+	/**
+	* Normalize register/createToken init context before authorize runs.
+	* Platforms may convert runtime-specific request types (e.g. Node `IncomingMessage`).
+	*/
+	normalizeInitContext(initContext) {
+		return initContext;
+	}
+	validateConfig(config) {}
+	_initialize() {
+		if (this._initialized) throw new Error(oneLine`
+                Platform is already initialized. The \`platform\` factory passed to
+                \`createIO().platform(...)\` must return a new platform instance each
+                time it is called (e.g. \`platformNode()\`), not reuse one.
+            `);
+		this._initialized = true;
+		return this;
+	}
+};
+// src/roomEffects.ts
+const DEFERRED_RESULT = "$u";
+const deferredResult = (promise) => {
+	return Object.defineProperty({}, DEFERRED_RESULT, { value: promise });
+};
+const isDeferredResult = (value) => {
+	if (typeof value !== "object" || value === null || !(DEFERRED_RESULT in value)) return false;
+	const descriptor = Object.getOwnPropertyDescriptor(value, DEFERRED_RESULT);
+	return descriptor?.enumerable === false && isThenable(descriptor.value);
+};
+const deferredResultPromise = (result) => result[DEFERRED_RESULT];
+const isSuspended = (value) => typeof value === "object" && value !== null && "suspended" in value && value.suspended === true;
+const isErrorMessage = (value) => {
+	return typeof value === "object" && value !== null && "message" in value && typeof value.message === "string";
+};
+const emptyRoomEffects = () => ({
+	attachments: [],
+	broadcast: [],
+	closes: [],
+	connectionId: null,
+	destroy: false,
+	error: null,
+	self: [],
+	storageDirty: false
+});
+// src/AbstractWebSocket.ts
+const errorMessage = (error) => {
+	if (isErrorMessage(error)) return error.message;
+	return "Unexpected error";
+};
+var AbstractWebSocket = class {
+	/** The connection is not yet open. */
+	CONNECTING = 0;
+	/** The connection is open and ready to communicate. */
+	OPEN = 1;
+	/** The connection is in the process of closing. */
+	CLOSING = 2;
+	/** The connection is closed. */
+	CLOSED = 3;
+	persistence;
+	room;
+	webSocket;
+	_platform;
+	constructor(webSocket, config) {
+		const { persistence, platform, room } = config;
+		this.persistence = persistence;
+		this._platform = platform;
+		this.room = room;
+		this.webSocket = webSocket;
+	}
+	handleError(params) {
+		const { error, message: _message, room, session } = params;
+		const message = errorMessage(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,
+			operator: session?.operator ?? null
+		});
+	}
+	sendMessage(data) {
+		return this.send(JSON.stringify(data));
+	}
+};
+// src/CommitGate.ts
+/**
+* Orders one commit after another.
+* `idle` means the latest reserved turn has already finished.
+* `reserve` takes the next turn. `previous` settles when the earlier turn
+* finishes. `finish` runs once, when this turn's commit has ended.
+*/
+var CommitGate = class {
+	#turn = {
+		done: true,
+		promise: Promise.resolve()
+	};
+	get idle() {
+		return this.#turn.done;
+	}
+	reserve() {
+		const previous = this.#turn.promise;
+		let settled = false;
+		let resolveTurn = () => void 0;
+		const turn = {
+			done: false,
+			promise: new Promise((resolve) => {
+				resolveTurn = resolve;
+			})
+		};
+		const finish = () => {
+			if (settled) return;
+			settled = true;
+			turn.done = true;
+			resolveTurn();
+		};
+		this.#turn = turn;
+		return {
+			previous,
+			finish
+		};
+	}
+};
+// src/authorize.ts
+/** Default token lifetime: 60 seconds (passed to jose as seconds). */
+const DEFAULT_MAX_AGE_MS = 6e4;
+const getEncryptionKey = async (secret) => {
+	return await hkdf("sha256", secret, "", "Pluv.io Generated Encryption Key", 32);
+};
+const isOperatorToken = (params) => {
+	return params.kind === "operator";
+};
+const now = () => Date.now() / 1e3 | 0;
+const maxAgeMsToSeconds = (maxAgeMs) => {
+	return Math.max(1, Math.ceil(maxAgeMs / 1e3));
+};
+const resolveJwtIdentity = (params) => {
+	const { room } = params;
+	switch (params.kind) {
+		case "operator": {
+			const { operator, user } = params;
+			return {
+				kind: "operator",
+				operator,
+				room,
+				sub: `${room}|operator|${operator.id}`,
+				user
+			};
+		}
+		case "user":
+		case void 0: {
+			const { user } = params;
+			return {
+				kind: "user",
+				operator: null,
+				room,
+				sub: `${room}|${user.id}`,
+				user
+			};
+		}
+		default: return assertExhaustive(params);
+	}
+};
+const authorize = (params) => {
+	const { platform, secret } = params;
+	const encode = async (encodeParams) => {
+		const { maxAge = DEFAULT_MAX_AGE_MS } = encodeParams;
+		const claims = resolveJwtIdentity(encodeParams);
+		const encryptionSecret = await getEncryptionKey(secret);
+		return await new EncryptJWT({ ...claims }).setProtectedHeader({
+			alg: "dir",
+			enc: "A256GCM"
+		}).setIssuedAt().setExpirationTime(now() + maxAgeMsToSeconds(maxAge)).setJti(platform.randomUUID()).encrypt(encryptionSecret);
+	};
+	const decode = async (jwt) => {
+		try {
+			const encryptionSecret = await getEncryptionKey(secret);
+			const { payload } = await jwtDecrypt(jwt, encryptionSecret, { clockTolerance: 15 });
+			const decoded = payload ?? null;
+			if (!decoded) return null;
+			const kind = decoded.kind;
+			switch (kind) {
+				case "operator": return {
+					kind: "operator",
+					operator: decoded.operator,
+					room: decoded.room,
+					sub: decoded.sub,
+					user: decoded.user
+				};
+				case "user":
+				case void 0: return {
+					kind: "user",
+					operator: null,
+					room: decoded.room,
+					sub: decoded.sub,
+					user: decoded.user
+				};
+				default: return assertExhaustive(kind);
+			}
+		} catch {
+			return null;
+		}
+	};
+	return {
+		decode,
+		encode
+	};
+};
+// src/PluvProcedure.ts
+var PluvProcedure = class PluvProcedure {
+	_broadcast = null;
+	_input = null;
+	_self = null;
+	get config() {
+		return {
+			broadcast: this._broadcast?.bind(this) ?? null,
+			input: this._input ?? null,
+			self: this._self?.bind(this) ?? null
+		};
+	}
+	constructor(config = {}) {
+		const { broadcast, input, self } = config;
+		this._broadcast = broadcast ?? null;
+		this._input = input ?? null;
+		this._self = self ?? 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
+		});
+	}
+};
+// src/createSessionRouter.ts
+const baseProcedureFactory$1 = () => () => {
+	return new PluvProcedure();
+};
+const asSession = (event) => {
+	return event;
+};
+const createSessionRouter = (params) => {
+	const readLimits = () => typeof params.limits === "function" ? params.limits() : params.limits;
+	const baseProcedure = baseProcedureFactory$1();
+	return createInternalPluvRouter({
+		$getOthers: baseProcedure().self((_data, raw) => {
+			const { session, sessions } = asSession(raw);
+			const presenceSeqById = new Map(sessions.map((item) => [item.id, item.seq.presence]));
+			const others = groupLiveUsers(sessions, { excludeSessionId: session.id }).map(({ connectionIds, data, presence, kind, operator }) => ({
+				connectionIds,
+				data,
+				session: {
+					kind,
+					operator,
+					presence,
+					seq: { presence: connectionIds.reduce((max, id) => {
+						const seq = presenceSeqById.get(id) ?? null;
+						if (typeof seq !== "number") return max;
+						if (typeof max !== "number") return seq;
+						return seq > max ? seq : max;
+					}, null) }
+				}
+			}));
+			return { $othersReceived: {
+				myConnectionIds: getMyConnectionIds(sessions, session),
+				others
+			} };
+		}),
+		$listUsers: baseProcedure().self((data, raw) => {
+			const { sessions } = asSession(raw);
+			const result = pageLiveUsers(sessions, data);
+			if (!result.success) return { $usersPage: {
+				requestId: data.requestId,
+				success: false,
+				error: {
+					code: result.error.code === "INVALID_LIMIT" ? "INVALID_LIMIT" : "FAILED",
+					message: result.error.message
+				}
+			} };
+			return { $usersPage: {
+				requestId: data.requestId,
+				success: true,
+				pageInfo: result.pageInfo,
+				users: result.users
+			} };
+		}),
+		$initializeSession: baseProcedure().broadcast((data, raw) => {
+			const event = asSession(raw);
+			const presence = data.presence ?? null;
+			const { session } = event;
+			if (!session) return {};
+			const kind = getSessionKind(session);
+			const participantId = session.user.id;
+			if (typeof event.sessions.reduce((max, other) => {
+				if (other.quit) return max;
+				const otherKind = getSessionKind(other);
+				const otherId = other.user?.id;
+				if (otherKind !== kind || otherId !== participantId) return max;
+				const seq = other.seq.presence;
+				if (typeof seq !== "number") return max;
+				if (typeof max !== "number") return seq;
+				return seq > max ? seq : max;
+			}, null) !== "number") event.presence = presence;
+			return { $userJoined: {
+				connectionId: session.id,
+				user: session.user,
+				session: {
+					kind,
+					operator: session.operator,
+					presence: session.presence ?? presence ?? {},
+					seq: { presence: session.webSocket.state.seq.presence }
+				}
+			} };
+		}),
+		$ping: baseProcedure().self((_data, raw) => {
+			const { platform, session } = asSession(raw);
+			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: baseProcedure().broadcast((data, raw) => {
+			const context = asSession(raw);
+			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;
+			const presenceMaxSize = readLimits()?.presenceMaxSize;
+			if (!!presenceMaxSize && bytes > presenceMaxSize) throw new Error(oneLine`
+                    Large presence. Presence must be at most
+                    ${presenceMaxSize.toLocaleString()} bytes.
+                    Current size: ${bytes.toLocaleString()} bytes
+                `);
+			context.presence = updated;
+			return { $presenceUpdated: {
+				user: session.user,
+				session: {
+					presence: updated,
+					seq: { presence: session.webSocket.state.seq.presence },
+					kind: session.kind,
+					operator: session.operator
+				}
+			} };
+		})
+	});
+};
+// src/createStorageRouter.ts
+const baseProcedureFactory = () => () => {
+	return new PluvProcedure();
+};
+const asStorage = (event) => {
+	return event;
+};
+/** Storage `$` events. These run beside the doc. */
+const createStorageRouter = (params) => {
+	const { limits } = params;
+	const logDebug = params.logDebug ?? (() => void 0);
+	const baseProcedure = baseProcedureFactory();
+	return createInternalPluvRouter({
+		$syncStorage: baseProcedure().self((data, { doc }) => {
+			return { $storageDiff: { update: data.stateVector ? doc.encodeDiff(data.stateVector) : doc.getEncodedState() } };
+		}),
+		$updateStorage: baseProcedure().broadcast((data, raw) => {
+			const { doc } = asStorage(raw);
+			const origin = data.origin;
+			const update = data.update ?? null;
+			if (origin === "$initialized") return {};
+			if (!update) return {};
+			const before = doc.getStateVector();
+			const wasPending = doc.hasPending();
+			doc.applyEncodedState({ update });
+			const integrated = doc.getStateVector() !== before;
+			if (!integrated && (doc.hasPending() || !doc.canDetectPending())) {
+				logDebug("Storage update did not integrate");
+				if (data.resync) return {};
+				return { $storageResync: { stateVector: doc.getStateVector() } };
+			}
+			const state = integrated ? doc.encodeDiff(before) : update;
+			const encodedState = doc.getEncodedState();
+			const storageSize = new TextEncoder().encode(encodedState).length;
+			if (!!limits.storageMaxSize && storageSize > limits.storageMaxSize) throw new Error(oneLine`
+                        Large Storage. Storage must be at most
+                        ${limits.storageMaxSize.toLocaleString()} bytes.
+                        Current size: ${storageSize.toLocaleString()} bytes
+                    `);
+			if (doc.hasPending() && !wasPending) return {
+				$storageUpdated: { state },
+				$storageResync: { stateVector: doc.getStateVector() }
+			};
+			return { $storageUpdated: { state } };
+		})
+	});
+};
+// src/createBaseRouter.ts
+/**
+* Built-in `$` protocol events. Kept separate from `PluvServer` so the protocol
+* can be constructed/tested without a full server instance. This merge only
+* fills `_defs`. `manageSessions` dispatches the session slice. The room
+* dispatches storage events plus the user's router.
+*/
+const createBaseRouter = (params) => {
+	return PluvRouter.merge(createSessionRouter(params), createStorageRouter(params));
+};
+// src/RoomStorage.ts
+var RoomStorage = class {
+	_docFactory;
+	_getContext;
+	_getInitialStorage;
+	_platform;
+	_room;
+	_doc;
+	_storageSeeded = false;
+	constructor(config) {
+		this._docFactory = config.docFactory;
+		this._getContext = config.getContext;
+		this._getInitialStorage = config.getInitialStorage;
+		this._platform = config.platform;
+		this._room = config.room;
+		this._doc = Promise.resolve(this._docFactory.getEmpty());
+	}
+	get doc() {
+		return this._doc;
+	}
+	getEmptyDoc() {
+		return this._docFactory.getEmpty();
+	}
+	get storageSeeded() {
+		return this._storageSeeded;
+	}
+	set storageSeeded(value) {
+		this._storageSeeded = value;
+	}
+	async destroy() {
+		const resolvedDoc = await this._doc;
+		const encodedState = resolvedDoc.getEncodedState();
+		const shouldDestroyStorage = this._storageSeeded && resolvedDoc.isDirty();
+		const refusedEmptyPersist = this._storageSeeded && !shouldDestroyStorage;
+		this._storageSeeded = false;
+		resolvedDoc.destroy();
+		this._doc = Promise.resolve(this._docFactory.getEmpty());
+		return {
+			encodedState,
+			refusedEmptyPersist,
+			shouldDestroyStorage
+		};
+	}
+	initialize() {
+		this._doc = this._loadInitialDoc();
+		return this._doc;
+	}
+	async _loadInitialDoc() {
+		const doc = this._docFactory.getEmpty();
+		const [encodedState, context] = await Promise.all([this._platform.persistence.getStorageState(this._room), this._getContext()]);
+		if (!encodedState) {
+			const loadedState = await this._getInitialStorage({
+				context,
+				room: this._room
+			});
+			if (!!loadedState && !this._docFactory.isEmpty(loadedState)) {
+				doc.applyEncodedState({ update: loadedState });
+				this._storageSeeded = true;
+			}
+		}
+		if (typeof encodedState === "string") {
+			doc.applyEncodedState({ update: encodedState });
+			if (!doc.isEmpty()) this._storageSeeded = true;
+		}
+		doc.rebuildStorage();
+		return doc;
+	}
+};
+// src/StorageChangeLog.ts
+/**
+* Ordered document edits for `onStorageEdits`. The first edit starts the wait.
+* Edits during that wait join the same list. A room with no listener does not
+* construct this.
+*/
+var StorageChangeLog = class {
+	_changes = [];
+	_closed = false;
+	_queue = Promise.resolve();
+	_getContext;
+	_onEdits;
+	_room;
+	_wait;
+	constructor(config) {
+		this._getContext = config.getContext;
+		this._onEdits = config.onEdits;
+		this._room = config.room;
+		this._wait = new ArmedWait(config.intervalMs, config.keepAlive);
+	}
+	push(changes) {
+		if (this._closed || changes.length === 0) return;
+		this._changes.push(...changes);
+		this._arm();
+	}
+	detach() {
+		this._closed = true;
+		this._wait.clear();
+	}
+	/** Send the waiting list now, then one follow-up list if that call writes. */
+	flush() {
+		const run = this._queue.then(() => this._flush());
+		this._queue = run.then(() => void 0, () => void 0);
+		return run;
+	}
+	reopen() {
+		this._closed = false;
+		this._changes = [];
+		this._wait.clear();
+	}
+	_arm() {
+		if (this._closed) return;
+		this._wait.arm(() => this.flush());
+	}
+	async _emit() {
+		if (this._changes.length === 0) return;
+		const changes = this._changes;
+		this._changes = [];
+		try {
+			const context = await this._getContext();
+			await this._onEdits({
+				changes,
+				context,
+				room: this._room
+			});
+		} catch (error) {
+			console.error(error);
+		}
+	}
+	async _flush() {
+		this._wait.clear();
+		await this._emit();
+		this._wait.clear();
+		if (this._changes.length > 0) await this._emit();
+	}
+};
+// src/StorageReservations.ts
+const covers = (doc, version) => {
+	for (const [id, clock] of version) if ((doc.get(id) ?? 0) < clock) return false;
+	return true;
+};
+/**
+* Same-client updates leave in clock order. Updates from different clients keep
+* the order their groups first arrived. Counters from different clients are not
+* comparable.
+*/
+const orderCovered = (ready) => {
+	const groups = /* @__PURE__ */ new Map();
+	for (const item of ready) {
+		const key = item.version.length === 1 ? item.version[0][0] : `\0${item.seq}`;
+		const group = groups.get(key);
+		if (group) group.push(item);
+		else groups.set(key, [item]);
+	}
+	return [...groups.values()].sort((left, right) => Math.min(...left.map((item) => item.seq)) - Math.min(...right.map((item) => item.seq))).flatMap((group) => group.toSorted((left, right) => {
+		const leftClock = left.version[0]?.[1] ?? 0;
+		const rightClock = right.version[0]?.[1] ?? 0;
+		if (left.version.length === 1 && right.version.length === 1 && leftClock !== rightClock) return leftClock - rightClock;
+		return left.seq - right.seq;
+	}).map(({ operator, procedure, update, user }) => ({
+		operator,
+		procedure,
+		update,
+		user
+	})));
+};
+/** Bytes waiting until the document version covers them. Not an edit yet. */
+var StorageReservations = class {
+	_maxBytes;
+	_bytes = 0;
+	_items = [];
+	_seq = 0;
+	/** `0` keeps every waiting update. A positive cap matches the document size limit. */
+	constructor(_maxBytes = 0) {
+		this._maxBytes = _maxBytes;
+	}
+	add(input) {
+		const bytes = input.update.length;
+		if (this._maxBytes > 0 && bytes > this._maxBytes) return;
+		this._seq += 1;
+		this._items.push({
+			...input,
+			seq: this._seq
+		});
+		this._bytes += bytes;
+	}
+	clear() {
+		this._bytes = 0;
+		this._items = [];
+	}
+	holds(update) {
+		return this._items.some((item) => item.update === update);
+	}
+	takeCovered(doc, contained) {
+		const ready = [];
+		const waiting = [];
+		for (const item of this._items) if (covers(doc, item.version) && contained(item.update)) {
+			ready.push(item);
+			this._bytes -= item.update.length;
+		} else waiting.push(item);
+		this._items = waiting;
+		return orderCovered(ready);
+	}
+	/**
+	* Drop the oldest waiting updates until the retained bytes fit. Call this after
+	* the covered ones are admitted. The apply runs between `add` and that
+	* admission, so trimming inside `add` drops an update the apply is about to
+	* make reportable.
+	*/
+	trim() {
+		while (this._maxBytes > 0 && this._bytes > this._maxBytes && this._items.length > 1) {
+			const oldest = this._items.shift();
+			if (!oldest) return;
+			this._bytes -= oldest.update.length;
+		}
+	}
+};
+// src/StorageEdits.ts
+/**
+* Reservations become edits once the document covers them. A write that was
+* never reserved is still reported, with no author, so a replay includes it.
+*/
+var StorageEdits = class {
+	_paused = false;
+	_unsubscribe = null;
+	_log;
+	_reservations;
+	constructor(config) {
+		this._log = new StorageChangeLog(config);
+		this._reservations = new StorageReservations(config.maxBytes ?? 0);
+	}
+	attach(doc) {
+		this.detach();
+		this._log.reopen();
+		this._paused = false;
+		this._unsubscribe = doc.subscribe((notice) => {
+			if (this._paused || !notice.update) return;
+			this.note(doc, notice.update);
+		});
+	}
+	clearReservations() {
+		this._reservations.clear();
+	}
+	detach() {
+		this._reservations.clear();
+		this._unsubscribe?.();
+		this._unsubscribe = null;
+		this._log.detach();
+	}
+	flush() {
+		return this._log.flush();
+	}
+	note(doc, notice) {
+		const version = new Map(doc.readStateVersion(doc.getStateVector()));
+		const admitted = this._reservations.takeCovered(version, (update) => doc.containsUpdate(update));
+		const edits = [...admitted];
+		if (notice && admitted.length === 0 && !this._reservations.holds(notice) && doc.containsUpdate(notice)) edits.push({
+			update: notice,
+			user: null,
+			operator: null,
+			procedure: null
+		});
+		this._reservations.trim();
+		this._log.push(edits);
+	}
+	/** Skip subscription notes while a capture is still collecting its bytes. */
+	pause(paused) {
+		this._paused = paused;
+	}
+	reopen() {
+		this._reservations.clear();
+		this._log.reopen();
+	}
+	reserve(doc, input) {
+		if (!input.update) return;
+		this._reservations.add({
+			...input,
+			version: doc.readUpdateVersion(input.update)
+		});
+	}
+};
+// src/StorageSnapshot.ts
+/**
+* The room's snapshot. The document stays live. This copies it when asked.
+* The session manager owns the clock.
+*/
+var StorageSnapshot = class {
+	_closed = false;
+	_dirty = false;
+	_epoch = 0;
+	_generation = 0;
+	_hold = 0;
+	_pending = [];
+	_release = null;
+	_unsubscribe = null;
+	_untilClean = null;
+	_getContext;
+	_getDoc;
+	_keepAlive;
+	_limits;
+	_onStored;
+	_room;
+	_setStorageState;
+	constructor(config) {
+		this._getContext = config.getContext;
+		this._getDoc = config.getDoc;
+		this._keepAlive = config.keepAlive;
+		this._limits = config.limits;
+		this._onStored = config.onStored;
+		this._room = config.room;
+		this._setStorageState = config.setStorageState;
+	}
+	get closed() {
+		return this._closed;
+	}
+	get dirty() {
+		return this._dirty && !this._closed;
+	}
+	/** Updates still need a `$storageUpdated` frame. A closed room does not retry them. */
+	get hasPending() {
+		return !this._closed && this._pending.length > 0;
+	}
+	get epoch() {
+		return this._epoch;
+	}
+	/** Increments in `seal`. Stays put across `reopen`. */
+	get generation() {
+		return this._generation;
+	}
+	/** The seed snapshot already stored this epoch. A later write still needs a copy. */
+	acknowledge(epoch) {
+		if (this._epoch === epoch) this._markClean();
+	}
+	assertSize(encodedState) {
+		if (!this._exceedsLimit(encodedState)) return;
+		const limit = this._limits.storageMaxSize ?? 0;
+		const storageSize = new TextEncoder().encode(encodedState).length;
+		throw new Error(oneLine`
+            Large Storage. Storage must be at most
+            ${limit.toLocaleString()} bytes.
+            Current size: ${storageSize.toLocaleString()} bytes
+        `);
+	}
+	attach(doc) {
+		this.detach();
+		this._unsubscribe = doc.subscribe((notice) => {
+			if (!notice.update) return;
+			this._epoch += 1;
+			this._markDirty();
+			if (this._hold > 0 || this._closed) return;
+			this._pending.push(notice.update);
+		});
+	}
+	detach() {
+		this._unsubscribe?.();
+		this._unsubscribe = null;
+	}
+	async flush() {
+		if (this._closed) return "closed";
+		if (!this._dirty) return "clean";
+		const doc = await this._getDoc();
+		const context = await this._getContext();
+		if (this._closed) return "closed";
+		if (!this._dirty) return "clean";
+		const stored = await this._store({
+			context,
+			doc,
+			notify: true
+		});
+		if (this._closed) return "closed";
+		if (stored.oversized || !stored.duringNotify && !stored.duringSnapshot) {
+			this._markClean();
+			return "clean";
+		}
+		const follow = await this._store({
+			context,
+			doc,
+			notify: false
+		});
+		if (this._closed) return "closed";
+		if (follow.oversized || !follow.duringSnapshot) {
+			this._markClean();
+			return "clean";
+		}
+		this._markDirty();
+		return "dirty";
+	}
+	/** Doc updates inside `fn` mark the snapshot stale and do not broadcast again. */
+	hold(fn) {
+		this._hold += 1;
+		try {
+			return fn();
+		} finally {
+			this._hold -= 1;
+		}
+	}
+	/** An update made inside `hold` still needs a `$storageUpdated` frame. */
+	queueUpdate(update) {
+		if (this._closed || update.length === 0) return;
+		this._pending.push(update);
+	}
+	/** Drop updates whose `$storageUpdated` frames were delivered. */
+	dropUpdates(updates) {
+		if (updates.length === 0 || this._pending.length === 0) return;
+		const remaining = /* @__PURE__ */ new Map();
+		for (const update of updates) remaining.set(update, (remaining.get(update) ?? 0) + 1);
+		this._pending = this._pending.filter((update) => {
+			const count = remaining.get(update);
+			if (!count) return true;
+			if (count === 1) remaining.delete(update);
+			else remaining.set(update, count - 1);
+			return false;
+		});
+	}
+	/** A copy of the updates that still need a `$storageUpdated` frame. */
+	pendingUpdates() {
+		return [...this._pending];
+	}
+	reopen() {
+		this._closed = false;
+		this._markClean();
+		this._epoch = 0;
+		this._hold = 0;
+		this._pending = [];
+	}
+	async seal() {
+		this._closed = true;
+		this._generation += 1;
+		if (!this._dirty) return;
+		const doc = await this._getDoc();
+		const context = await this._getContext();
+		let notify = true;
+		for (;;) {
+			const stored = await this._store({
+				context,
+				doc,
+				notify
+			});
+			notify = false;
+			if (stored.oversized || !stored.duringNotify && !stored.duringSnapshot) {
+				this._markClean();
+				return;
+			}
+			if (stored.duringSnapshot) continue;
+			const follow = await this._store({
+				context,
+				doc,
+				notify: false
+			});
+			if (follow.oversized || !follow.duringSnapshot) {
+				this._markClean();
+				return;
+			}
+		}
+	}
+	async _store(params) {
+		const { context, doc, notify } = params;
+		const encodedState = doc.getEncodedState();
+		if (this._exceedsLimit(encodedState)) {
+			this._markClean();
+			return {
+				duringNotify: false,
+				duringSnapshot: false,
+				oversized: true
+			};
+		}
+		const epoch = this._epoch;
+		await this._setStorageState(encodedState);
+		const duringSnapshot = this._epoch !== epoch;
+		const notifiedAt = this._epoch;
+		if (notify) this._onStored({
+			context,
+			encodedState,
+			room: this._room
+		});
+		return {
+			duringNotify: this._epoch !== notifiedAt,
+			duringSnapshot,
+			oversized: false
+		};
+	}
+	_arm() {
+		if (this._untilClean) return;
+		let release;
+		const held = new Promise((resolve) => {
+			release = resolve;
+		});
+		this._untilClean = held;
+		this._release = release;
+		this._keepAlive(held);
+	}
+	_exceedsLimit(encodedState) {
+		const storageSize = new TextEncoder().encode(encodedState).length;
+		return !!this._limits.storageMaxSize && storageSize > this._limits.storageMaxSize;
+	}
+	_markClean() {
+		this._dirty = false;
+		this._release?.();
+		this._release = null;
+		this._untilClean = null;
+	}
+	_markDirty() {
+		this._dirty = true;
+		if (this._closed) return;
+		this._arm();
+	}
+};
+// src/IORoom.ts
+/** Clients ignore `$storageUpdated` when `connectionId` is missing. A listener write has no session. */
+const SERVER_STORAGE_CONNECTION_ID = "$server";
+const effectFrame = (type, data, session) => ({
+	connectionId: session.id,
+	data,
+	operator: session.operator,
+	type,
+	user: session.user
+});
+const framesFromRecord = (record, session) => {
+	if (!record) return [];
+	return Object.entries(record).map(([type, data]) => effectFrame(type, data, session));
+};
+var IORoom = class {
+	id;
+	limits;
+	treaty;
+	"~";
+	_teardown = null;
+	_uninitialize = null;
+	_edits;
+	_snapshot;
+	_context;
+	_debug;
+	_listeners;
+	_platform;
+	_roomContext;
+	_router;
+	_secret;
+	_storage;
+	/**
+	* @ignore
+	* @readonly
+	* @deprecated Internal use only. Changes to this will never be marked as breaking.
+	*/
+	get _defs() {
+		return {
+			context: this._context,
+			events: this._router._defs.events,
+			platform: this._platform,
+			treaty: this.treaty
+		};
+	}
+	constructor(id, config) {
+		const { _meta, context, debug, getInitialStorage, limits, onRoomDestroyed, onStorageDestroyed, onStorageEdits, onStorageSnapshot, onMessage, onUserConnected, onUserDisconnected, platform, roomContext, router, secret, treaty } = config;
+		this.id = id;
+		this.limits = limits;
+		this._context = context;
+		this._debug = debug;
+		this._roomContext = roomContext;
+		this._router = router;
+		this._secret = secret;
+		this.treaty = treaty;
+		this._platform = platform.initialize({
+			...!!_meta ? { _meta } : {},
+			roomContext
+		});
+		this._storage = new RoomStorage({
+			docFactory: treaty.storage ?? noop.doc(),
+			getContext: () => this._getContext(),
+			getInitialStorage,
+			platform: this._platform,
+			room: this.id
+		});
+		this._edits = onStorageEdits ? new StorageEdits({
+			getContext: () => this._getContext(),
+			intervalMs: STORAGE_EDITS_INTERVAL_MS,
+			keepAlive: (promise) => {
+				this._platform.keepAlive(promise);
+			},
+			maxBytes: this.limits.storageMaxSize ?? 0,
+			onEdits: (event) => onStorageEdits(event),
+			room: this.id
+		}) : null;
+		this._snapshot = new StorageSnapshot({
+			getContext: () => this._getContext(),
+			getDoc: () => this._doc,
+			keepAlive: (promise) => {
+				this._platform.keepAlive(promise);
+			},
+			limits: this.limits,
+			onStored: (event) => {
+				this._listeners.onStorageSnapshot(event);
+			},
+			room: this.id,
+			setStorageState: (encodedState) => this._platform.persistence.setStorageState(this.id, encodedState)
+		});
+		this._listeners = {
+			onRoomDestroyed: (event) => onRoomDestroyed?.(event),
+			onStorageDestroyed: (event) => onStorageDestroyed?.(event),
+			onStorageSnapshot: (event) => {
+				this._platform.keepAlive(Promise.resolve(onStorageSnapshot?.(event)).catch((error) => {
+					console.error(error);
+				}));
+			},
+			onMessage: (event) => {
+				this._platform.keepAlive(Promise.resolve(onMessage?.(event)).catch((error) => {
+					console.error(error);
+				}));
+			},
+			onUserConnected: (event) => onUserConnected?.(event),
+			onUserDisconnected: (event) => onUserDisconnected?.(event)
+		};
+		this["~"] = {
+			applyPresencePatch: this._applyPresencePatch.bind(this),
+			applyStorageProcedure: this._applyStorageProcedure.bind(this),
+			commitLoadedStorage: this._commitLoadedStorage.bind(this),
+			close: this._close.bind(this),
+			destroy: this._destroyRoom.bind(this),
+			flushSnapshot: async () => {
+				const status = await this._snapshot.flush();
+				return {
+					broadcast: this._snapshot.pendingUpdates().map((update) => ({
+						connectionId: SERVER_STORAGE_CONNECTION_ID,
+						data: { state: update },
+						operator: null,
+						type: "$storageUpdated",
+						user: null
+					})),
+					status
+				};
+			},
+			initializeStorage: this._initializeStorage.bind(this),
+			logDebug: this._logDebug.bind(this),
+			message: this._message.bind(this),
+			register: this._register.bind(this),
+			dropStorageUpdates: this._dropStorageUpdates.bind(this),
+			queueStorageFrames: this._queueStorageFrames.bind(this),
+			storageDirty: () => this._snapshot.dirty || this._snapshot.hasPending,
+			userConnected: this._userConnected.bind(this),
+			whenReady: () => this._initialized
+		};
+		this._initialize();
+	}
+	/**
+	* @internal Opens the stored document and applies a treaty presence procedure.
+	*/
+	async _applyPresencePatch(params) {
+		const { name, data, session } = params;
+		const procedures = this.treaty._defs.procedures.presence;
+		if (!procedures || !Object.hasOwn(procedures, name)) throw new Error(`Unknown presence procedure "${name}"`);
+		const procedure = procedures[name];
+		const doc = await this._doc;
+		const applied = procedure.apply(data, {
+			user: session.user,
+			operator: session.operator,
+			presence: session.presence,
+			doc
+		});
+		if (isThenable(applied)) return deferredResult(Promise.resolve(applied));
+		return applied;
+	}
+	async _applyStorageProcedure(params) {
+		if (!await this._initialized || this._snapshot.closed) return this._releaseStorage(emptyRoomEffects(), params.actor);
+		const generation = this._snapshot.generation;
+		const { name, data, actor } = params;
+		const procedures = this.treaty._defs.procedures.storage;
+		if (!procedures || !Object.hasOwn(procedures, name)) throw new Error(`Unknown storage procedure "${name}"`);
+		const procedure = procedures[name];
+		if (procedure.prepared && procedure.load) {
+			const loaded = procedure.load(data, {
+				user: actor.user,
+				operator: actor.operator,
+				presence: actor.presence
+			}).then((result) => ({
+				actor,
+				data: result.input,
+				generation,
+				name,
+				prepared: result.prepared
+			}));
+			this._platform.keepAlive(loaded.then(() => void 0, () => void 0));
+			return deferredResult(loaded);
+		}
+		return this._commitLoadedStorage({
+			actor,
+			data,
+			generation,
+			name,
+			prepared: void 0
+		});
+	}
+	async _commitLoadedStorage(loaded, releasePending = true) {
+		const { actor, data, name, prepared } = loaded;
+		const procedure = this.treaty._defs.procedures.storage?.[name];
+		if (!procedure) throw new Error(`Unknown storage procedure "${name}"`);
+		const doc = await this._doc;
+		if (loaded.generation !== this._snapshot.generation) throw new Error("The room closed before this storage write");
+		this._edits?.pause(true);
+		let update;
+		try {
+			update = this._snapshot.hold(() => doc.captureUpdate(() => {
+				doc.transact(() => {
+					procedure.apply(data, {
+						user: actor.user,
+						operator: actor.operator,
+						presence: actor.presence,
+						doc
+					}, prepared);
+				}, actor.id);
+			}));
+		} finally {
+			this._edits?.pause(false);
+		}
+		if (update) {
+			this._edits?.reserve(doc, {
+				operator: actor.operator,
+				procedure: name,
+				update,
+				user: actor.user
+			});
+			this._edits?.note(doc);
+		}
+		this._snapshot.assertSize(doc.getEncodedState());
+		if (releasePending && update) this._snapshot.queueUpdate(update);
+		if (!update) return releasePending ? this._releaseStorage(emptyRoomEffects(), actor) : {
+			...emptyRoomEffects(),
+			connectionId: actor.id,
+			storageDirty: this._snapshot.dirty
+		};
+		if (releasePending) return this._releaseStorage(emptyRoomEffects(), actor);
+		return {
+			...emptyRoomEffects(),
+			broadcast: [effectFrame("$storageUpdated", { state: update }, actor)],
+			connectionId: actor.id,
+			storageDirty: true
+		};
+	}
+	async _close(session) {
+		if (!await this._initialized) return {
+			...emptyRoomEffects(),
+			connectionId: session.id
+		};
+		await this._emitDisconnected(session);
+		return this._releaseStorage({
+			...emptyRoomEffects(),
+			broadcast: [effectFrame("$exit", {
+				operator: session.operator,
+				sessionId: session.id,
+				user: session.user
+			}, session)],
+			closes: [session.id]
+		}, session);
+	}
+	async _destroyRoom() {
+		if (!this._uninitialize) return;
+		await (await this._uninitialize).bind(this)();
+	}
+	get _doc() {
+		if (!this._uninitialize) return this._storage.doc;
+		return this._uninitialize.then(() => this._storage.doc);
+	}
+	async _emitDisconnected(session) {
+		try {
+			const [doc, context] = await Promise.all([this._doc, this._getContext()]);
+			const encodedState = doc.getEncodedState();
+			await Promise.resolve(this._listeners.onUserDisconnected({
+				context,
+				encodedState,
+				kind: session.kind,
+				operator: session.operator,
+				room: this.id,
+				user: session.user
+			}));
+		} catch (error) {
+			console.error(error);
+		}
+	}
+	async _getAuthorizedUser(token, options) {
+		const secret = resolveIOSecret(this._secret, options);
+		if (!token) return null;
+		if (!secret) throw new Error("`secret` was not provided");
+		const payload = await authorize({
+			platform: this._platform,
+			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;
+		}
+		const user = parsePluvSchema(this.treaty.user, payload.user);
+		switch (payload.kind) {
+			case "operator": try {
+				return {
+					kind: "operator",
+					operator: parseOperatorUser(payload.operator),
+					user
+				};
+			} catch {
+				this._logDebug(`${colors.blue("Operator token fails validation:")} ${token}`);
+				return null;
+			}
+			case "user": try {
+				return {
+					kind: "user",
+					operator: null,
+					user
+				};
+			} catch {
+				this._logDebug(`${colors.blue("Token fails validation:")} ${token}`);
+				return null;
+			}
+			default: return assertExhaustive(payload.kind);
+		}
+	}
+	/** User context for session procedures. `.config({ context })` runs here. */
+	async _getContext() {
+		const context = this._context;
+		if (typeof context === "function") return await Promise.resolve(context(this._roomContext));
+		return await Promise.resolve(context);
+	}
+	_getProcedure(message) {
+		return this._router._defs.events[message.type] ?? null;
+	}
+	_initialize() {
+		const promise = (async () => {
+			this._logDebug(colors.blue(`Initializing room: ${this.id}`));
+			if (!!this._uninitialize) {
+				await (await this._uninitialize).bind(this)();
+				this._uninitialize = null;
+			}
+			await this._storage.initialize();
+			const doc = await this._storage.doc;
+			this._snapshot.reopen();
+			this._snapshot.attach(doc);
+			this._edits?.reopen();
+			this._edits?.attach(doc);
+			const uninitialize = async () => {
+				if (this._teardown) return this._teardown;
+				this._teardown = (async () => {
+					await this._edits?.flush();
+					this._edits?.clearReservations();
+					await this._snapshot.seal();
+					await this._edits?.flush();
+					this._snapshot.detach();
+					this._edits?.detach();
+					const context = await this._getContext();
+					const { encodedState, refusedEmptyPersist, shouldDestroyStorage } = await this._storage.destroy();
+					if (refusedEmptyPersist) this._logDebug(colors.blue(`Refusing to persist an unwritten document for room: ${this.id}`));
+					await Promise.resolve(this._listeners.onRoomDestroyed({
+						..."_meta" in this._platform && !!this._platform._meta ? { _meta: this._platform._meta } : {},
+						context,
+						room: this.id
+					}));
+					if (shouldDestroyStorage) {
+						await Promise.resolve(this._listeners.onStorageDestroyed({
+							..."_meta" in this._platform && !!this._platform._meta ? { _meta: this._platform._meta } : {},
+							context,
+							encodedState,
+							room: this.id
+						}));
+						await this._platform.persistence.deleteStorageState(this.id);
+					}
+					this._uninitialize = null;
+				})();
+				try {
+					await this._teardown;
+				} finally {
+					this._teardown = null;
+				}
+			};
+			return { uninitialize };
+		})();
+		this._uninitialize = promise.then((result) => result.uninitialize);
+	}
+	get _initialized() {
+		if (!this._uninitialize) return Promise.resolve(false);
+		return this._uninitialize.then(() => true);
+	}
+	async _initializeStorage(params) {
+		if (!await this._initialized) return {
+			changeKind: "empty",
+			state: null,
+			storageDirty: false
+		};
+		const { input } = params;
+		const doc = await this._doc;
+		const context = await this._getContext();
+		const update = input.update ?? null;
+		const stateVector = input.stateVector ?? null;
+		const stateForClient = (encodedState) => {
+			if (!stateVector) return encodedState;
+			return doc.encodeDiff(stateVector);
+		};
+		if (this._storage.storageSeeded) return {
+			changeKind: "unchanged",
+			state: stateVector ? doc.encodeDiff(stateVector) : doc.getEncodedState(),
+			storageDirty: this._snapshot.dirty
+		};
+		if (update) {
+			this._edits?.pause(true);
+			let encodedState;
+			try {
+				this._edits?.reserve(doc, {
+					operator: params.actor.operator,
+					procedure: null,
+					update,
+					user: params.actor.user
+				});
+				encodedState = this._snapshot.hold(() => doc.applyEncodedState({ update }).getEncodedState());
+			} finally {
+				this._edits?.pause(false);
+			}
+			this._edits?.note(doc);
+			const storageSize = new TextEncoder().encode(encodedState).length;
+			if (!!this.limits.storageMaxSize && storageSize > this.limits.storageMaxSize) throw new Error("Storage has exceeded the size limit");
+			this._storage.storageSeeded = true;
+			const epoch = this._snapshot.epoch;
+			if (await this._platform.persistence.setStorageState(this.id, encodedState).then(() => true).catch((error) => {
+				this._logDebug(error);
+				return false;
+			})) {
+				this._snapshot.acknowledge(epoch);
+				this._listeners.onStorageSnapshot({
+					context,
+					encodedState,
+					room: this.id
+				});
+			}
+			return {
+				changeKind: "initialized",
+				state: stateForClient(encodedState),
+				storageDirty: this._snapshot.dirty
+			};
+		}
+		return {
+			changeKind: "empty",
+			state: stateForClient(doc.getEncodedState()),
+			storageDirty: this._snapshot.dirty
+		};
+	}
+	_logDebug(...data) {
+		if (this._debug) console.log(...data);
+	}
+	async _message(session, event) {
+		if (!await this._initialized) return this._releaseStorage(emptyRoomEffects(), session);
+		const context = await this._getContext();
+		this._listeners.onMessage({
+			..."_meta" in this._platform && !!this._platform._meta ? { _meta: this._platform._meta } : {},
+			context,
+			message: event,
+			kind: session.kind,
+			operator: session.operator,
+			room: this.id,
+			user: session.user
+		});
+		const procedure = this._getProcedure(event);
+		if (!procedure) {
+			if (event.type.startsWith("$")) return this._releaseStorage(emptyRoomEffects(), session);
+			return this._releaseStorage({
+				...emptyRoomEffects(),
+				broadcast: [effectFrame(event.type, event.data, session)]
+			}, session);
+		}
+		let inputs;
+		try {
+			inputs = procedure.config.input ? parsePluvSchema(procedure.config.input, event.data) : event.data;
+		} catch (error) {
+			return this._releaseStorage({
+				...emptyRoomEffects(),
+				error
+			}, session);
+		}
+		const attachments = [];
+		let presence = session.presence;
+		const doc = await this._doc;
+		const storageEvent = event.type === "$syncStorage" || event.type === "$updateStorage";
+		if (storageEvent && this._snapshot.closed) return this._releaseStorage(emptyRoomEffects(), session);
+		let releaseNotice = false;
+		const wide = this._resolverContext({
+			attachments,
+			context,
+			doc,
+			getPresence: () => presence,
+			session,
+			setPresence: (value) => {
+				presence = value;
+			}
+		});
+		const resolverContext = storageEvent ? wide : this._userContext(wide);
+		const finish = (broadcast, self) => this._releaseStorage({
+			...emptyRoomEffects(),
+			attachments,
+			broadcast: framesFromRecord(broadcast, session),
+			self: framesFromRecord(self, session)
+		}, session);
+		try {
+			if (this._edits && event.type === "$updateStorage") {
+				const data = inputs;
+				const incoming = data.update ?? null;
+				if (incoming && data.origin !== "$initialized") {
+					this._edits.reserve(doc, {
+						operator: session.operator,
+						procedure: typeof data.procedure === "string" ? data.procedure : null,
+						update: incoming,
+						user: session.user
+					});
+					this._edits.pause(true);
+					releaseNotice = true;
+				}
+			}
+			const invoked = invokeProcedureResolvers({
+				broadcast: () => storageEvent ? this._snapshot.hold(() => procedure.config.broadcast?.(inputs, resolverContext)) : procedure.config.broadcast?.(inputs, resolverContext),
+				self: () => procedure.config.self?.(inputs, resolverContext)
+			});
+			if (!invoked.ok) return this._releaseStorage({
+				...emptyRoomEffects(),
+				attachments,
+				error: invoked.error
+			}, session);
+			const { broadcast: broadcastResult, self: selfResult } = invoked;
+			if (!storageEvent && (isThenable(broadcastResult) || isThenable(selfResult))) return deferredResult(Promise.all([broadcastResult, selfResult]).then(([broadcast, self]) => finish(broadcast, self)).catch((error) => this._releaseStorage({
+				...emptyRoomEffects(),
+				attachments,
+				error
+			}, session)));
+			const [broadcast, self] = await Promise.all([broadcastResult, selfResult]);
+			return finish(broadcast, self);
+		} catch (error) {
+			return this._releaseStorage({
+				...emptyRoomEffects(),
+				attachments,
+				error
+			}, session);
+		} finally {
+			if (releaseNotice) {
+				this._edits?.pause(false);
+				this._edits?.note(doc);
+			}
+		}
+	}
+	async _register(...options) {
+		const { token: tokenOption, ...initRest } = options[0] ?? {};
+		const token = tokenOption ?? null;
+		const registerConfig = {
+			...this._platform.normalizeInitContext(initRest),
+			token
+		};
+		if (this._teardown) await this._teardown;
+		if (!await this._initialized) {
+			this._initialize();
+			await this._initialized;
+		}
+		const identity = await this._getAuthorizedUser(token, registerConfig);
+		if (!identity) {
+			this._logDebug(colors.blue("Authorization failed for connection"));
+			return {
+				encodedState: null,
+				error: /* @__PURE__ */ new Error("Not authorized"),
+				kind: null,
+				operator: null,
+				user: null
+			};
+		}
+		const doc = await this._doc;
+		return {
+			encodedState: doc.isEmpty() ? null : doc.getEncodedState(),
+			error: null,
+			kind: identity.kind,
+			operator: identity.operator,
+			user: identity.user
+		};
+	}
+	_resolverContext(params) {
+		const { attachments, context, doc, getPresence, session, setPresence } = params;
+		const storage = this._storage;
+		const time = (/* @__PURE__ */ new Date()).getTime();
+		return {
+			connectionId: session.id,
+			context,
+			doc,
+			kind: session.kind,
+			operator: session.operator,
+			platform: this._platform,
+			get presence() {
+				return getPresence();
+			},
+			persistence: this._platform.persistence,
+			set presence(presence) {
+				const next = presence ?? null;
+				setPresence(next);
+				const attachment = {
+					presence: next,
+					seq: session.seq.presence,
+					sessionId: session.id
+				};
+				const index = attachments.findIndex((item) => item.sessionId === session.id);
+				if (index === -1) attachments.push(attachment);
+				else attachments[index] = attachment;
+			},
+			room: this.id,
+			session: {
+				id: session.id,
+				kind: session.kind,
+				operator: session.operator,
+				presence: session.presence,
+				quit: session.quit,
+				room: this.id,
+				seq: session.seq,
+				timers: { ping: session.lastPing },
+				user: session.user
+			},
+			sessions: [],
+			get storageSeeded() {
+				return storage.storageSeeded;
+			},
+			set storageSeeded(value) {
+				storage.storageSeeded = value;
+			},
+			user: session.user,
+			time
+		};
+	}
+	async _dropStorageUpdates(frames) {
+		const updates = [];
+		for (const frame of frames) {
+			if (frame.type !== "$storageUpdated") continue;
+			const state = frame.data?.state;
+			if (typeof state !== "string" || state.length === 0) continue;
+			updates.push(state);
+		}
+		this._snapshot.dropUpdates(updates);
+	}
+	/** Keeps frames from a failed send on the pending list. Ones already queued stay once. */
+	_queueStorageFrames(frames) {
+		const pending = new Set(this._snapshot.pendingUpdates());
+		for (const frame of frames) {
+			if (frame.type !== "$storageUpdated") continue;
+			const state = frame.data?.state;
+			if (typeof state !== "string" || state.length === 0 || pending.has(state)) continue;
+			this._snapshot.queueUpdate(state);
+			pending.add(state);
+		}
+	}
+	_releaseStorage(effects, session) {
+		const updates = this._snapshot.pendingUpdates();
+		const broadcast = updates.length ? [...effects.broadcast, ...updates.map((update) => effectFrame("$storageUpdated", { state: update }, session))] : effects.broadcast;
+		return {
+			...effects,
+			broadcast,
+			connectionId: session.id,
+			storageDirty: this._snapshot.dirty || broadcast.some((frame) => frame.type === "$storageUpdated")
+		};
+	}
+	async _userConnected(params) {
+		const { encodedState, id, kind, operator, user } = params;
+		const context = await this._getContext();
+		try {
+			await Promise.resolve(this._listeners.onUserConnected({
+				context,
+				encodedState,
+				kind,
+				operator,
+				room: this.id,
+				user
+			}));
+		} catch (error) {
+			console.error(error);
+		}
+		return this._releaseStorage(emptyRoomEffects(), {
+			id,
+			operator,
+			user
+		});
+	}
+	_userContext(event) {
+		return {
+			connectionId: event.connectionId,
+			context: event.context,
+			doc: event.doc,
+			kind: event.kind,
+			operator: event.operator,
+			get presence() {
+				return event.presence;
+			},
+			set presence(value) {
+				event.presence = value;
+			},
+			room: event.room,
+			time: event.time,
+			user: event.user
+		};
+	}
+};
+// src/version.generated.ts
+const version = "0.0.0-canary-20261027014949";
+// src/PluvServer.ts
+var PluvServer = class {
+	version = version;
+	_config;
+	_docFactory;
+	_listeners;
+	_onGetOperator;
+	_onStorageEdits;
+	/**
+	* @description The `createIO()` instance this server was built from.
+	*/
+	get io() {
+		return this._config.io;
+	}
+	/**
+	* @ignore
+	* @readonly
+	* @deprecated Internal use only. Changes to this will never be marked as breaking.
+	*/
+	get _defs() {
+		return {
+			context: this._config.context,
+			events: this._router._defs.events,
+			platform: this._config.platform(),
+			treaty: this._config.treaty
+		};
+	}
+	/**
+	* `_router` fills `_defs` with the session slice, the storage slice, and the
+	* user's router. `createRoom` receives `_docRouter`: storage events plus the
+	* user's router. `manageSessions` dispatches session events.
+	*/
+	get _baseRouter() {
+		return createBaseRouter({
+			limits: this._config.limits,
+			logDebug: (...data) => this._logDebug(...data),
+			onStorageSnapshot: (event) => this._listeners.onStorageSnapshot(event)
+		});
+	}
+	get _router() {
+		return this._config.router ? PluvRouter.merge(this._baseRouter, this._config.router) : this._baseRouter;
+	}
+	get _docRouter() {
+		const storage = createStorageRouter({
+			limits: this._config.limits,
+			logDebug: (...data) => this._logDebug(...data),
+			onStorageSnapshot: (event) => this._listeners.onStorageSnapshot(event)
+		});
+		return this._config.router ? PluvRouter.merge(storage, this._config.router) : storage;
+	}
+	constructor(options) {
+		this._config = {
+			debug: false,
+			router: new PluvRouter({}),
+			...options
+		};
+		const { onGetOperator } = options;
+		const { onRoomDestroyed, onRoomMessage, onStorageDestroyed, onStorageEdits, onStorageSnapshot, onUserConnected, onUserDisconnected } = options;
+		this._onGetOperator = onGetOperator ?? null;
+		this._onStorageEdits = onStorageEdits ?? null;
+		this._docFactory = this._config.treaty.storage ?? noop.doc();
+		this._listeners = {
+			onRoomDestroyed: (event) => onRoomDestroyed?.(event),
+			onRoomMessage: (event) => onRoomMessage?.(event),
+			onStorageDestroyed: (event) => onStorageDestroyed?.(event),
+			onStorageEdits: (event) => onStorageEdits?.(event),
+			onStorageSnapshot: (event) => onStorageSnapshot?.(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 (!/^[a-z0-9](?:[a-z0-9-_]*[a-z0-9])?$/i.test(room)) throw new Error("Unsupported room name");
+		const roomContext = platformRoomContext;
+		const listeners = this._listeners;
+		const logDebug = this._logDebug.bind(this);
+		const newRoom = new IORoom(room, {
+			...!!_meta ? { _meta } : {},
+			context: this._config.context,
+			debug: debug ?? this._config.debug,
+			getInitialStorage: this._getInitialStorage,
+			limits: this._config.limits,
+			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));
+			},
+			onStorageSnapshot(event) {
+				return listeners.onStorageSnapshot(event);
+			},
+			onStorageEdits: this._onStorageEdits ? (event) => listeners.onStorageEdits(event) : void 0,
+			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));
+			},
+			secret: this._config.secret,
+			treaty: this._config.treaty,
+			platform,
+			roomContext,
+			router: this._docRouter
+		});
+		this._logDebug(`${colors.blue("Created room:")} ${room}`);
+		return newRoom;
+	}
+	async createToken(params) {
+		return await this._config.io.createToken(params, { onGetOperator: this._onGetOperator });
+	}
+	_getInitialStorage = (...args) => {
+		const getInitialStorage = this._config.getInitialStorage;
+		if (typeof getInitialStorage !== "function") return null;
+		return getInitialStorage(...args);
+	};
+	_logDebug(...data) {
+		if (this._config.debug) console.log(...data);
+	}
+};
+// src/PluvIO.ts
+var PluvIO = class {
+	version = version;
+	_context = {};
+	_debug;
+	_limits;
+	_platform;
+	_secret;
+	_treaty;
+	get procedure() {
+		return new PluvProcedure();
+	}
+	constructor(options) {
+		const { context, debug = false, limits, platform, secret, treaty } = options;
+		this._debug = debug;
+		this._limits = {
+			dangerouslyAllowHighPresenceFanout: false,
+			maxConnections: 256,
+			presenceMaxSize: 512,
+			storageMaxSize: MAX_STORAGE_SIZE_BYTES,
+			userIdMaxLength: 128,
+			userMaxSize: 512,
+			...limits
+		};
+		this._platform = platform;
+		this._secret = secret;
+		this._treaty = treaty;
+		if (context) this._context = context;
+		assertPresenceFanoutBudget(this._limits);
+	}
+	async createToken(params, options) {
+		const platform = this._platform();
+		const token = params;
+		const { maxAge: _maxAge, room: _room, ...rest } = token;
+		const initRest = isOperatorToken(token) ? (() => {
+			const { operator: _operator, kind: _kind, ...init } = rest;
+			return init;
+		})() : (() => {
+			const { user: _user, kind: _kind, ...init } = rest;
+			return init;
+		})();
+		const initContext = platform.normalizeInitContext(initRest);
+		const encodeParams = await this._resolveEncodeParams({
+			initContext,
+			onGetOperator: options?.onGetOperator ?? null,
+			token: params
+		});
+		const secret = resolveIOSecret(this._secret, encodeParams);
+		const ioAuthorize = {
+			user: this._treaty.user,
+			secret
+		};
+		if (platform._createToken) return await platform._createToken({
+			...encodeParams,
+			authorize: ioAuthorize
+		});
+		if (!secret) throw new Error("`secret` was not provided");
+		return await authorize({
+			platform,
+			secret
+		}).encode(encodeParams);
+	}
+	async _resolveEncodeParams(params) {
+		const { initContext, onGetOperator, token } = params;
+		switch (token.kind) {
+			case "operator": {
+				if (!onGetOperator) throw new Error("`onGetOperator` must be set on `io.server()`; mint operator tokens with `ioServer.createToken`");
+				const operator = parseOperatorUser(token.operator);
+				if (typeof token.operator.email !== "string" || token.operator.email.length === 0) throw new Error("Invalid operator email");
+				this._assertIdLength(operator.id, "operator");
+				const derived = await onGetOperator({
+					operator: {
+						...operator,
+						email: token.operator.email
+					},
+					room: token.room
+				});
+				if (!derived) throw new Error("`onGetOperator` returned null");
+				const parsed = parsePluvSchema(this._treaty.user, derived);
+				this._assertUserLimits({
+					operator,
+					user: parsed
+				});
+				return {
+					...token,
+					...initContext,
+					kind: "operator",
+					operator,
+					user: parsed
+				};
+			}
+			case "user":
+			case void 0: {
+				const parsed = parsePluvSchema(this._treaty.user, token.user);
+				this._assertUserLimits({ user: parsed });
+				return {
+					...token,
+					...initContext,
+					kind: "user",
+					user: parsed
+				};
+			}
+			default: return assertExhaustive(token);
+		}
+	}
+	_assertIdLength(id, label) {
+		if (!this._limits.userIdMaxLength || id.length <= this._limits.userIdMaxLength) return;
+		throw new Error(oneLine`
+            createToken was called with a long ${label} id. ID must be at
+            most ${this._limits.userIdMaxLength.toLocaleString()} characters.
+            Current length: ${id.length.toLocaleString()}
+        `);
+	}
+	_assertUserLimits(params) {
+		const { operator, user } = params;
+		this._assertIdLength(user.id, "user");
+		const bytes = new TextEncoder().encode(JSON.stringify(user)).length + (operator ? new TextEncoder().encode(JSON.stringify(operator)).length : 0);
+		if (!this._limits.userMaxSize || bytes <= this._limits.userMaxSize) return;
+		throw new Error(oneLine`
+            createToken called with large payload. ${operator ? "User and operator together must" : "User must"} be at most
+            ${this._limits.userMaxSize.toLocaleString()} bytes. Current size:
+            ${bytes.toLocaleString()} bytes
+        `);
+	}
+	mergeRouters(...routers) {
+		return PluvRouter.merge(...routers);
+	}
+	router(events) {
+		return new PluvRouter(events);
+	}
+	server(...config) {
+		return new PluvServer({
+			...config[0] ?? {},
+			context: this._context,
+			debug: this._debug,
+			io: this,
+			limits: this._limits,
+			platform: this._platform,
+			secret: this._secret,
+			treaty: this._treaty
+		});
+	}
+};
+// src/createIO.ts
+const createIO = () => ({ platform: (platform) => ({ config: (params) => {
+	const { context, debug, limits, secret, treaty } = params;
+	return new PluvIO({
+		context,
+		debug,
+		limits,
+		platform,
+		secret,
+		treaty
+	});
+} }) });
+// src/internal.ts
+/**
+* Maintainer / test-only surface. Not part of the public API — shape and
+* contents may change without a semver bump. Prefer public exports for apps.
+*/
+const __internal = {
+	assertPresenceFanoutBudget,
+	createBaseRouter,
+	createInternalPluvRouter,
+	getMyConnectionIds,
+	getRoomStatsFromSessions,
+	groupLiveUsers,
+	isServerOriginEvent,
+	listLiveUsers,
+	pageLiveUsers,
+	resolveListUsersLimit,
+	resolveMaxConnections,
+	ROOM_STATS_THROTTLE_MS: 150,
+	SERVER_ORIGIN_EVENTS,
+	throttle
+};
+// src/ExclusiveUntil.ts
+/**
+* Runs tasks one at a time while `known` is false.
+* Once `known` returns true, tasks run immediately.
+* A task already running here cannot call `run`; that waits for itself.
+*/
+var ExclusiveUntil = class {
+	known;
+	_tail = Promise.resolve();
+	constructor(known) {
+		this.known = known;
+	}
+	async run(task) {
+		if (this.known()) return task();
+		const previous = this._tail;
+		let release;
+		this._tail = new Promise((resolve) => {
+			release = resolve;
+		});
+		await previous;
+		if (this.known()) {
+			release();
+			return task();
+		}
+		try {
+			return await task();
+		} finally {
+			release();
+		}
+	}
+};
+// src/JoinQueue.ts
+/**
+* Runs async tasks one at a time.
+* A task already running here cannot wait on `join`; that waits for itself.
+* `finish` is how a task waits for a promise and then comes back.
+*/
+var JoinQueue = class {
+	_tail = Promise.resolve();
+	/**
+	* Runs `task` on this queue. `{ value }` is passed to `finish` before the
+	* task releases. `{ pending }` is awaited after it releases, and `finish`
+	* runs on the next join. `{ suspended: true }` releases the queue and does
+	* not run `finish`.
+	*/
+	async finish(task, finish) {
+		const deferred = { pending: null };
+		await this.join(async () => {
+			const result = await task();
+			if ("suspended" in result) return;
+			if ("pending" in result) {
+				deferred.pending = result.pending;
+				return;
+			}
+			await finish(result.value);
+		});
+		if (!deferred.pending) return;
+		const value = await deferred.pending;
+		await this.join(() => finish(value));
+	}
+	join(task) {
+		const run = this._tail.then(task, task);
+		this._tail = run.then(() => void 0, () => void 0);
+		return run;
+	}
+};
+// src/RoomSessions.ts
+var RoomSessions = class {
+	_platform;
+	_participantSessions = {
+		operator: /* @__PURE__ */ new Map(),
+		user: /* @__PURE__ */ new Map()
+	};
+	_sessions = /* @__PURE__ */ new Map();
+	constructor(config) {
+		this._platform = config.platform;
+	}
+	all() {
+		return this._sessions;
+	}
+	addUserSession(userId, sessionId) {
+		return this.addParticipantSession({
+			id: userId,
+			kind: "user",
+			sessionId
+		});
+	}
+	addParticipantSession(params) {
+		const { id, kind, sessionId } = params;
+		const sessions = this._sessionsForKind(kind);
+		const updated = (sessions.get(id) ?? /* @__PURE__ */ new Set()).add(sessionId);
+		sessions.set(id, updated);
+		return updated;
+	}
+	delete(sessionId) {
+		return this._sessions.delete(sessionId);
+	}
+	deleteConnection(sessionId) {
+		const webSocket = this._sessions.get(sessionId) ?? null;
+		if (!webSocket) return null;
+		webSocket.state = {
+			...webSocket.state,
+			quit: true
+		};
+		this._sessions.delete(sessionId);
+		return webSocket;
+	}
+	get(sessionId) {
+		return this._sessions.get(sessionId);
+	}
+	getLatestPresence(id, kind = "user") {
+		const sessionIds = Array.from(this._sessionsForKind(kind).get(id)?.values() ?? []);
+		if (!sessionIds.length) return {
+			presence: null,
+			seq: 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 seq = session.seq.presence;
+			const sessionKind = getSessionKind(session);
+			const participantId = session.user?.id;
+			if (sessionKind !== kind || participantId !== id) return state;
+			if (typeof state.seq !== "number") return {
+				presence,
+				seq
+			};
+			if (typeof seq !== "number") return state;
+			return seq > state.seq ? {
+				presence,
+				seq
+			} : state;
+		}, {
+			presence: null,
+			seq: null
+		});
+	}
+	getQuitters() {
+		const currentTime = (/* @__PURE__ */ new Date()).getTime();
+		return Array.from(this._sessions.values()).filter((pluvWs) => !this._isLive(pluvWs, currentTime));
+	}
+	getSession(webSocket) {
+		const pluvWs = this.resolve(webSocket);
+		if (!pluvWs) throw new Error("Session could not be found");
+		return this.toSession(pluvWs);
+	}
+	getSessions() {
+		return Array.from(this._sessions.values()).map((pluvWs) => this.toSession(pluvWs));
+	}
+	getLiveSessions(currentTime = Date.now()) {
+		return Array.from(this._sessions.values()).filter((pluvWs) => this._isLive(pluvWs, currentTime)).map((pluvWs) => this.toSession(pluvWs));
+	}
+	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) => {
+			return this._isLive(pluvWs, currentTime) ? count + 1 : count;
+		}, 0);
+	}
+	has(sessionId) {
+		return this._sessions.has(sessionId);
+	}
+	removeUserSession(userId, sessionId) {
+		return this.removeParticipantSession({
+			id: userId,
+			kind: "user",
+			sessionId
+		});
+	}
+	removeParticipantSession(params) {
+		const { id, kind, sessionId } = params;
+		const sessions = this._sessionsForKind(kind);
+		const set = sessions.get(id);
+		if (!set) return null;
+		set.delete(sessionId);
+		if (!!set.size) return set;
+		sessions.delete(id);
+		return set;
+	}
+	resolve(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;
+	}
+	set(sessionId, webSocket) {
+		this._sessions.set(sessionId, webSocket);
+		return this;
+	}
+	setPresence(params) {
+		const { presence, seq: requested, sessionId } = params;
+		const pluvWs = this._sessions.get(sessionId) ?? null;
+		if (!pluvWs) return;
+		if (requested !== void 0 && (pluvWs.session.seq.presence ?? null) !== requested) return;
+		const wsSession = pluvWs.session;
+		const kind = getSessionKind(wsSession);
+		const participantId = wsSession.user?.id;
+		const sessionIds = participantId ? /* @__PURE__ */ new Set([...this._sessionsForKind(kind).get(participantId) ?? [], sessionId]) : /* @__PURE__ */ new Set([sessionId]);
+		const currentMax = Array.from(sessionIds).reduce((max, sId) => {
+			const seq = this._sessions.get(sId)?.session.seq.presence ?? null;
+			if (typeof seq !== "number") return max;
+			if (typeof max !== "number") return seq;
+			return seq > max ? seq : max;
+		}, null);
+		const next = typeof currentMax === "number" ? currentMax + 1 : 1;
+		sessionIds.forEach((sId) => {
+			const session = this._sessions.get(sId)?.session;
+			if (!session) return;
+			const prevState = session.webSocket.state;
+			this._platform.setSerializedState(session.webSocket, {
+				...prevState,
+				presence,
+				seq: {
+					...prevState.seq,
+					presence: next
+				}
+			});
+		});
+	}
+	toSession(pluvWs) {
+		return pluvWs.session;
+	}
+	values() {
+		return this._sessions.values();
+	}
+	_sessionsForKind(kind) {
+		switch (kind) {
+			case "operator": return this._participantSessions.operator;
+			case "user": return this._participantSessions.user;
+			default: return assertExhaustive(kind);
+		}
+	}
+	_isLive(pluvWs, currentTime) {
+		if (pluvWs.state.quit) return false;
+		return currentTime - (this._platform.getLastPing(pluvWs) ?? pluvWs.state.timers.ping) <= PING_TIMEOUT_MS;
+	}
+};
+// src/RoomSessionManager/createHostTreatyProcedureProxy.ts
+const PROMISE_TRAP_KEYS = /* @__PURE__ */ new Set([
+	"then",
+	"catch",
+	"finally"
+]);
+const createHostTreatyProcedureProxy = (invoke) => {
+	return new Proxy(invoke, { get(target, prop, receiver) {
+		if (typeof prop !== "string" || PROMISE_TRAP_KEYS.has(prop)) return Reflect.get(target, prop, receiver);
+		return (data) => target(prop, data);
+	} });
+};
+// src/RoomSessionManager/readTreatySchema.ts
+const readTreatySchema = (treaty) => {
+	const procedures = treaty.toProceduresJson();
+	return {
+		user: treaty.toUserJson(),
+		presence: treaty.presence ? {
+			schema: treaty.toPresenceJson(),
+			procedures: procedures.presence
+		} : null,
+		storage: treaty.storage ? {
+			schema: treaty.toStorageJson(),
+			procedures: procedures.storage
+		} : null
+	};
+};
+// src/RoomSessionManager/resolveHostTreatyProcedureSenderId.ts
+const resolveHostTreatyProcedureSenderId = (actor) => {
+	const senderId = actor != null && typeof actor === "object" ? actor.senderId : void 0;
+	if (typeof senderId !== "string") throw new Error("Host treaty invoke expected { senderId: string }");
+	return senderId;
+};
+// src/RoomSessionManager/RoomSessionManager.ts
+const isLoadedStorage = (value) => !("broadcast" in value);
+/**
+* Session manager for one room. `createRoom` returns the room.
+* `manageSessions` attaches the sockets.
+*/
+var RoomSessionManager = class {
+	_room;
+	broadcast;
+	__experimental_presence;
+	__experimental_storage;
+	_platform;
+	_sessions;
+	_sessionRouter;
+	_roomStats;
+	_queue = new JoinQueue();
+	_limits = new ExclusiveUntil(() => this._room.limits !== null);
+	_closing = 0;
+	_connecting = 0;
+	_registering = 0;
+	_storageSnapshotRun = null;
+	_commitGate = new CommitGate();
+	_retry = null;
+	_lastGarbageCollectMs = -60001;
+	/** Procedure frames whose delivery failed. This isolate outlives the facet. */
+	_unsent = [];
+	_unsentId = 0;
+	_treatySchema;
+	constructor(_room, platform) {
+		this._room = _room;
+		this._platform = platform;
+		this._sessions = new RoomSessions({ platform: this._platform });
+		this._sessionRouter = createSessionRouter({ limits: () => this._room.limits });
+		this._roomStats = throttle(() => {
+			this._emitRoomStats();
+		}, { wait: 150 });
+		this.broadcast = this._createBroadcast();
+		this.__experimental_presence = this._createPresence();
+		this.__experimental_storage = this._createStorage();
+		this._hydrate();
+		this._platform.pubSub.subscribe(this._room.id, async (payload) => {
+			await this._onPublished(payload);
+		});
+	}
+	get id() {
+		return this._room.id;
+	}
+	getTreatySchema() {
+		this._treatySchema ??= readTreatySchema(this._room.treaty);
+		return structuredClone(this._treatySchema);
+	}
+	async register(webSocket, ...options) {
+		const sessionId = this._platform.getSessionId(webSocket);
+		if (typeof sessionId === "string" && this._sessions.has(sessionId)) return;
+		await this._limits.run(async () => {
+			const limits = this._room.limits;
+			const maxConnections = limits ? resolveMaxConnections(limits) : null;
+			const rejectMaxConnections = () => {
+				const rejected = this._platform.convertWebSocket(webSocket, { room: this._room.id });
+				const limit = maxConnections ?? 0;
+				rejected.handleError({
+					error: /* @__PURE__ */ new Error(`Room is at maxConnections (${limit.toLocaleString()}).`),
+					room: this._room.id
+				});
+				rejected.close(4e3, "Room is at maxConnections");
+			};
+			if (maxConnections !== null && this._sessions.getSize() + this._registering >= maxConnections) {
+				rejectMaxConnections();
+				return;
+			}
+			this._registering += 1;
+			let reserved = true;
+			const releaseReservation = () => {
+				if (!reserved) return;
+				reserved = false;
+				this._registering -= 1;
+			};
+			await this._queue.finish(async () => {
+				try {
+					const result = await this._room["~"].register(...options);
+					if (result.error || !result.user || !result.kind) {
+						const rejected = this._platform.convertWebSocket(webSocket, { room: this._room.id });
+						rejected.handleError({
+							error: result.error ?? /* @__PURE__ */ new Error("Not authorized"),
+							room: this._room.id
+						});
+						rejected.close(3e3, "WebSocket unauthorized.");
+						return { value: null };
+					}
+					const pluvWs = this._platform.convertWebSocket(webSocket, { room: this._room.id });
+					const participantId = result.user.id;
+					const latest = this._sessions.getLatestPresence(participantId, result.kind);
+					const prevState = pluvWs.state;
+					pluvWs.user = result.user;
+					this._platform.setSerializedState(pluvWs, {
+						...prevState,
+						kind: result.kind,
+						operator: result.operator,
+						presence: latest.presence,
+						seq: {
+							...prevState.seq,
+							presence: latest.seq
+						}
+					});
+					this._sessions.addParticipantSession({
+						id: participantId,
+						kind: result.kind,
+						sessionId: pluvWs.sessionId
+					});
+					this._room["~"].logDebug(`${colors.blue(`Registering connection for room ${this._room.id}:`)} ${pluvWs.sessionId}`);
+					await this._platform.acceptWebSocket(pluvWs);
+					this._sessions.set(pluvWs.sessionId, pluvWs);
+					releaseReservation();
+					await this._platform.persistence.addUser(this._room.id, pluvWs.sessionId, result.user);
+					const registered = this._sessions.toSession(pluvWs);
+					const stats = getRoomStatsFromSessions(this._sessions.getLiveSessions());
+					await this._writeFrames([{
+						connectionId: registered.id,
+						data: {
+							session: {
+								kind: result.kind,
+								operator: result.operator,
+								presence: registered.presence,
+								seq: { presence: registered.seq.presence }
+							},
+							sessionId: registered.id,
+							state: result.encodedState,
+							stats
+						},
+						operator: result.operator,
+						type: "$registered",
+						user: result.user
+					}], "self");
+					const { encodedState, kind, operator, user } = result;
+					if (!kind || !user) return { value: null };
+					this._connecting += 1;
+					return { pending: this._room["~"].userConnected({
+						encodedState,
+						id: pluvWs.sessionId,
+						kind,
+						operator,
+						user
+					}).then((effects) => ({
+						effects,
+						socket: pluvWs
+					}), (error) => {
+						console.error(error);
+						return {
+							effects: null,
+							socket: pluvWs
+						};
+					}) };
+				} catch (error) {
+					releaseReservation();
+					throw error;
+				}
+			}, async (connected) => {
+				try {
+					if (!connected?.effects) return;
+					await this._applyEffects(connected.effects, connected.socket);
+					this._roomStats.schedule();
+					this._room["~"].logDebug(oneLine`
+                            ${colors.blue(`Registered connection for room ${this._room.id}:`)}
+                            ${connected.socket.sessionId}
+                        `);
+					this._room["~"].logDebug(`${colors.blue(`Room ${this._room.id} size:`)} ${this._sessions.getSize()}`);
+				} finally {
+					releaseReservation();
+					if (connected) {
+						this._connecting -= 1;
+						await this._destroyEmptyRoom();
+					}
+				}
+			});
+		});
+	}
+	applyFrames(effects, senderId) {
+		return this._queue.join(async () => {
+			await this._applyEffects(effects, this._socket(senderId));
+		});
+	}
+	/** Writes sockets only. The facet drops storage after `deliverFrames` returns. */
+	writeFrames(effects, senderId) {
+		return this._queue.join(async () => {
+			await this._applyEffects(effects, this._socket(senderId), false);
+		});
+	}
+	applyPresence(params) {
+		const socket = this._sessions.get(params.senderId) ?? null;
+		if (!socket) return Promise.resolve();
+		return this._queue.join(async () => {
+			const context = this._sessionContext(socket);
+			const broadcastResult = await this._sessionRouter._defs.events.$updatePresence.config.broadcast?.({
+				presence: params.patch,
+				procedure: params.name
+			}, context);
+			await this._deliverRecord(broadcastResult, socket, "broadcast");
+		});
+	}
+	onMessage(webSocket) {
+		if (!this._sessions.resolve(webSocket)) return async () => void 0;
+		return this._onSocketMessage(webSocket);
+	}
+	onClose(webSocket) {
+		return async (event) => {
+			const socket = this._sessions.resolve(webSocket);
+			if (!socket) return;
+			if (!this._sessions.has(socket.sessionId)) return;
+			await this._disconnect(socket, event.code, event.reason, false);
+		};
+	}
+	onError(webSocket) {
+		return async () => {
+			const socket = this._sessions.resolve(webSocket);
+			if (!socket) return;
+			if (!this._sessions.has(socket.sessionId)) return;
+			await this._disconnect(socket, 1011, "", false);
+		};
+	}
+	async garbageCollect() {
+		this._lastGarbageCollectMs = Date.now();
+		const quitting = await this._queue.join(async () => Array.from(this._sessions.values()).filter((socket) => !this._isLiveSocket(socket)));
+		if (!quitting.length) {
+			if (this._sessions.getSize() === 0) this._roomStats.cancel();
+			else this._roomStats.schedule();
+			return;
+		}
+		await this._unregisterSockets({
+			code: 1e3,
+			reason: "Ping timed out.",
+			sockets: quitting,
+			closeSocket: true,
+			sync: true
+		});
+	}
+	async evict(sessionId) {
+		const socket = this._sessions.get(sessionId);
+		if (!socket) return;
+		socket.state.quit = true;
+		await this._evictSockets({
+			code: 1e3,
+			reason: "",
+			sockets: [socket]
+		});
+	}
+	async evictAll() {
+		const sockets = Array.from(this._sessions.values());
+		sockets.forEach((socket) => {
+			socket.state.quit = true;
+		});
+		await this._evictSockets({
+			code: 1e3,
+			reason: "",
+			sockets
+		});
+	}
+	getSize() {
+		return this._sessions.getSize();
+	}
+	noteStorageDirty() {
+		if (this._storageSnapshotRun) return;
+		const run = this._snapshotUntilClean();
+		this._storageSnapshotRun = run;
+		this._platform.keepAlive(run);
+		run.finally(() => {
+			if (this._storageSnapshotRun === run) this._storageSnapshotRun = null;
+		});
+	}
+	retryUnsent(effects) {
+		this._unsentId += 1;
+		this._unsent.push({
+			effects,
+			id: this._unsentId
+		});
+		if (this._retry) return;
+		const run = this._deliverUnsent();
+		this._retry = run;
+		this._platform.keepAlive(run);
+		run.finally(() => {
+			if (this._retry === run) this._retry = null;
+		});
+	}
+	listUsers(options = {}) {
+		return pageLiveUsers(this._sessions.getLiveSessions(), options);
+	}
+	_socket(senderId) {
+		return this._sessions.get(senderId) ?? null;
+	}
+	async _applyEffects(effects, sender, dropStorage = true) {
+		this._noteStorage(effects);
+		for (const attachment of effects.attachments) this._sessions.setPresence(attachment);
+		if (effects.error) {
+			const storageFrames = effects.broadcast.filter((frame) => frame.type === "$storageUpdated");
+			if (storageFrames.length) {
+				await this._writeFrames(storageFrames, "broadcast");
+				if (dropStorage) await this._room["~"].dropStorageUpdates(storageFrames);
+			}
+			sender?.handleError({
+				error: effects.error,
+				room: this._room.id,
+				...sender ? { session: this._sessions.toSession(sender) } : {}
+			});
+			return;
+		}
+		await this._writeFrames(effects.broadcast, "broadcast");
+		if (dropStorage) {
+			const storageFrames = effects.broadcast.filter((frame) => frame.type === "$storageUpdated");
+			if (storageFrames.length) await this._room["~"].dropStorageUpdates(storageFrames);
+		}
+		await this._writeFrames(effects.self, "self");
+	}
+	async _collectPong() {
+		if (Date.now() - this._lastGarbageCollectMs > 6e4) await this.garbageCollect();
+	}
+	_createBroadcast() {
+		const send = (event, data, senderId) => {
+			if (typeof senderId !== "string") throw new Error("room.broadcast of a user event requires a senderId");
+			const socket = this._sessions.get(senderId) ?? null;
+			const session = socket ? this._sessions.toSession(socket) : null;
+			return this._publish({
+				connectionId: senderId,
+				data,
+				operator: session ? getSessionOperator(session) : null,
+				type: event,
+				user: session?.user ?? null
+			});
+		};
+		return new Proxy(send, { get(fn, prop) {
+			return (data, senderId) => fn(prop, data, senderId);
+		} });
+	}
+	_createPresence() {
+		return (actor) => {
+			const senderId = resolveHostTreatyProcedureSenderId(actor);
+			const invoke = async (name, data) => {
+				const socket = this._sessions.get(senderId) ?? null;
+				if (!socket) throw new Error(`Unknown senderId: ${senderId}`);
+				await this._queue.finish(async () => {
+					const patch = await this._room["~"].applyPresencePatch({
+						name,
+						data,
+						session: this._toSnapshot(socket)
+					});
+					if (isDeferredResult(patch)) return { pending: deferredResultPromise(patch) };
+					if (isSuspended(patch)) {
+						if ("error" in patch && isErrorMessage(patch.error)) socket.handleError({
+							error: patch.error,
+							room: this._room.id,
+							session: this._sessions.toSession(socket)
+						});
+						return { suspended: true };
+					}
+					return { value: patch };
+				}, async (patch) => {
+					const context = this._sessionContext(socket);
+					const broadcastResult = await this._sessionRouter._defs.events.$updatePresence.config.broadcast?.({
+						presence: patch,
+						procedure: name
+					}, context);
+					await this._deliverRecord(broadcastResult, socket, "broadcast");
+				});
+			};
+			return createHostTreatyProcedureProxy(invoke);
+		};
+	}
+	_createStorage() {
+		return (actor) => {
+			const senderId = resolveHostTreatyProcedureSenderId(actor);
+			const invoke = async (name, data) => {
+				const socket = this._sessions.get(senderId) ?? null;
+				if (!socket) throw new Error(`Unknown senderId: ${senderId}`);
+				let finishCommit = () => void 0;
+				await this._queue.finish(async () => {
+					try {
+						const effects = await this._room["~"].applyStorageProcedure({
+							name,
+							data,
+							actor: this._toSnapshot(socket)
+						});
+						if (!isDeferredResult(effects)) return { value: effects };
+						const loaded = deferredResultPromise(effects);
+						const turn = this._commitGate.reserve();
+						finishCommit = turn.finish;
+						return { pending: turn.previous.then(() => loaded, () => loaded).then((value) => value, (error) => {
+							turn.finish();
+							throw error;
+						}) };
+					} catch (error) {
+						finishCommit();
+						await this._retainStorage();
+						throw error;
+					}
+				}, async (loaded) => {
+					try {
+						const effects = isLoadedStorage(loaded) ? await this._room["~"].commitLoadedStorage(loaded) : loaded;
+						this._noteStorage(effects);
+						await this._writeFrames(effects.broadcast, "broadcast");
+						await this._room["~"].dropStorageUpdates(effects.broadcast);
+					} catch (error) {
+						await this._retainStorage();
+						throw error;
+					} finally {
+						finishCommit();
+					}
+				});
+			};
+			return createHostTreatyProcedureProxy(invoke);
+		};
+	}
+	async _deliverRecord(record, socket, mode) {
+		if (!record) return;
+		const session = this._sessions.toSession(socket);
+		const frames = Object.entries(record).map(([type, data]) => ({
+			connectionId: session.id,
+			data,
+			operator: getSessionOperator(session),
+			type,
+			user: session.user
+		}));
+		await this._writeFrames(frames, mode);
+	}
+	async _destroyEmptyRoom() {
+		if (this._sessions.all().size !== 0) return;
+		if (this._connecting !== 0 || this._registering !== 0) {
+			this._queue.join(() => this._destroyIdleRoom());
+			return;
+		}
+		await this._destroyIdleRoom();
+	}
+	async _destroyIdleRoom() {
+		if (this._sessions.all().size !== 0) return;
+		if (this._connecting !== 0 || this._registering !== 0) return;
+		if (this._closing !== 0) return;
+		try {
+			await this._room["~"].destroy();
+		} catch (error) {
+			console.error(error);
+		}
+	}
+	async _disconnect(socket, code, reason, closeSocket) {
+		await this._unregisterSockets({
+			code,
+			reason,
+			sockets: [socket],
+			closeSocket,
+			sync: false
+		});
+	}
+	async _emitRoomStats() {
+		const stats = getRoomStatsFromSessions(this._sessions.getLiveSessions());
+		await this._publish({
+			connectionId: null,
+			data: stats,
+			operator: null,
+			type: "$roomStats",
+			user: null
+		});
+	}
+	async _emitSyncState() {
+		const connectionIds = await this._platform.persistence.getUsers(this._room.id).then((map) => Object.keys(map));
+		await this._publish({
+			connectionId: null,
+			data: { connectionIds },
+			operator: null,
+			type: "$syncStateReceived",
+			user: null
+		});
+	}
+	async _evictSockets(params) {
+		const { code, reason, sockets } = params;
+		const closing = sockets.filter((socket) => this._sessions.has(socket.sessionId));
+		if (!closing.length) return;
+		await this._unregisterSockets({
+			code,
+			reason,
+			sockets: closing,
+			closeSocket: true,
+			sync: false
+		});
+	}
+	_hydrate() {
+		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._room.id });
+			if (!pluvWs.user) return;
+			this._sessions.set(sessionId, pluvWs);
+			const session = pluvWs.session;
+			this._sessions.addParticipantSession({
+				id: session.user.id,
+				kind: getSessionKind(session),
+				sessionId
+			});
+		});
+	}
+	_isLiveSocket(socket, now = Date.now()) {
+		if (socket.state.quit) return false;
+		return now - (this._platform.getLastPing(socket) ?? socket.state.timers.ping) <= PING_TIMEOUT_MS;
+	}
+	_noteStorage(effects) {
+		if (!effects.storageDirty) return;
+		this.noteStorageDirty();
+	}
+	/** A failed send leaves the queued update for the snapshot loop. */
+	async _retainStorage() {
+		if (await this._room["~"].storageDirty()) this.noteStorageDirty();
+	}
+	async _onPublished(payload) {
+		const { options = {}, ...message } = payload;
+		const frame = {
+			connectionId: message.connectionId,
+			data: message.data,
+			operator: message.operator,
+			type: message.type,
+			user: message.user
+		};
+		switch (options.type) {
+			case "self":
+				await this._writeFrames([frame], "self");
+				return;
+			case "broadcast": {
+				const targets = options.sessionIds ? options.sessionIds.map((sessionId) => this._sessions.get(sessionId) ?? null).filter((socket) => !!socket) : Array.from(this._sessions.all().values());
+				await Promise.allSettled(targets.map(async (socket) => {
+					await Promise.resolve(socket.sendMessage({
+						...frame,
+						room: this._room.id
+					}));
+				}));
+				return;
+			}
+			case void 0: {
+				const targets = Array.from(this._sessions.all().values());
+				await Promise.allSettled(targets.map(async (socket) => {
+					await Promise.resolve(socket.sendMessage({
+						...frame,
+						room: this._room.id
+					}));
+				}));
+				return;
+			}
+			default: assertExhaustive(options);
+		}
+	}
+	_onSocketMessage(webSocket) {
+		return async (event) => {
+			const socket = this._sessions.resolve(webSocket);
+			if (!socket) throw new Error("Could not get session");
+			if (socket.state.quit) {
+				await this._disconnect(socket, 1011, "WebSocket broken.", true);
+				return;
+			}
+			const message = this._parseMessage(event);
+			if (!message) return;
+			const sessionEvent = this._sessionRouter.eventNames.has(message.type);
+			if (!sessionEvent && !await this._room["~"].whenReady()) return;
+			if (sessionEvent) {
+				if (message.type === "$initializeSession") {
+					await this._openSession(socket, message);
+					return;
+				}
+				await this._runSessionProcedure(socket, message);
+				return;
+			}
+			await this._queue.finish(async () => {
+				const effects = await this._room["~"].message(this._toSnapshot(socket), message);
+				if (isDeferredResult(effects)) return { pending: deferredResultPromise(effects) };
+				if (isSuspended(effects)) {
+					if ("error" in effects && isErrorMessage(effects.error)) socket.handleError({
+						error: new Error(effects.error.message),
+						room: this._room.id,
+						session: this._sessions.toSession(socket)
+					});
+					return { suspended: true };
+				}
+				return { value: effects };
+			}, (effects) => this._applyEffects(effects, socket));
+		};
+	}
+	async _openSession(socket, message) {
+		const procedure = this._sessionRouter._defs.events.$initializeSession;
+		const session = this._sessions.toSession(socket);
+		try {
+			const inputs = this._readInputs(procedure, message);
+			const context = this._sessionContext(socket);
+			const broadcast = await procedure.config.broadcast?.(inputs, context);
+			await this._queue.join(async () => {
+				const { storageDirty, ...received } = await this._room["~"].initializeStorage({
+					input: inputs ?? {},
+					actor: this._toSnapshot(socket)
+				});
+				if (storageDirty) this.noteStorageDirty();
+				await this._deliverRecord(broadcast, socket, "broadcast");
+				await this._deliverRecord({ $storageReceived: received }, socket, "self");
+			});
+		} catch (error) {
+			socket.handleError({
+				error,
+				room: this._room.id,
+				session
+			});
+		}
+	}
+	_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;
+		}
+	}
+	async _publish(message) {
+		if (typeof message.connectionId !== "string" && !isServerOriginEvent(message.type)) return;
+		await this._platform.pubSub.publish(this._room.id, {
+			...message,
+			room: this._room.id
+		});
+	}
+	_readInputs(procedure, message) {
+		if (!procedure?.config.input) return message.data;
+		return parsePluvSchema(procedure.config.input, message.data);
+	}
+	async _removeSocket(socket) {
+		const session = this._sessions.toSession(socket);
+		const kind = getSessionKind(session);
+		const participantId = session.user?.id;
+		this._sessions.deleteConnection(socket.sessionId);
+		if (participantId) this._sessions.removeParticipantSession({
+			id: participantId,
+			kind,
+			sessionId: socket.sessionId
+		});
+		await this._platform.persistence.deleteUser(this._room.id, socket.sessionId).catch(() => null);
+	}
+	async _runSessionProcedure(socket, message) {
+		const procedure = this._sessionRouter._defs.events[message.type];
+		if (!procedure) return;
+		const session = this._sessions.toSession(socket);
+		let inputs;
+		try {
+			inputs = this._readInputs(procedure, message);
+		} catch (error) {
+			socket.handleError({
+				error,
+				room: this._room.id,
+				session
+			});
+			return;
+		}
+		try {
+			const context = this._sessionContext(socket);
+			const invoked = invokeProcedureResolvers({
+				broadcast: () => procedure.config.broadcast?.(inputs, context),
+				self: () => procedure.config.self?.(inputs, context)
+			});
+			if (!invoked.ok) {
+				socket.handleError({
+					error: invoked.error,
+					room: this._room.id,
+					session
+				});
+				return;
+			}
+			const [broadcast, self] = await Promise.all([invoked.broadcast, invoked.self]);
+			await this._deliverRecord(broadcast, socket, "broadcast");
+			await this._deliverRecord(self, socket, "self");
+		} catch (error) {
+			socket.handleError({
+				error,
+				room: this._room.id,
+				session
+			});
+		}
+	}
+	/** Sends procedure frames that `deliverFrames` did not. A failed send stays in this promise and retries after the snapshot interval. */
+	async _deliverUnsent() {
+		while (this._unsent.length) try {
+			await this._queue.join(async () => {
+				const pending = this._unsent.slice();
+				for (const item of pending) {
+					const sender = item.effects.connectionId ? this._sessions.get(item.effects.connectionId) ?? null : null;
+					await this._applyEffects(item.effects, sender);
+					this._unsent = this._unsent.filter((held) => held.id !== item.id);
+				}
+			});
+		} catch (error) {
+			console.error(error);
+			await new Promise((resolve) => {
+				setTimeout(resolve, STORAGE_SNAPSHOT_INTERVAL_MS);
+			});
+		}
+	}
+	/** One promise. Wait, ask the room for a snapshot, and repeat until that snapshot is current. */
+	async _snapshotUntilClean() {
+		for (;;) {
+			await new Promise((resolve) => {
+				setTimeout(resolve, STORAGE_SNAPSHOT_INTERVAL_MS);
+			});
+			try {
+				const status = await this._queue.join(async () => {
+					const flushed = await this._room["~"].flushSnapshot();
+					if (flushed.broadcast.length) {
+						await this._writeFrames(flushed.broadcast, "broadcast");
+						await this._room["~"].dropStorageUpdates(flushed.broadcast);
+					}
+					return flushed.status;
+				});
+				if (status === "closed") return;
+				if (status === "dirty" || await this._room["~"].storageDirty()) continue;
+			} catch (error) {
+				console.error(error);
+				if (await this._room["~"].storageDirty()) continue;
+				return;
+			}
+			await Promise.resolve();
+			if (await this._room["~"].storageDirty()) continue;
+			return;
+		}
+	}
+	_sessionContext(socket) {
+		const sessions = this._sessions;
+		const session = sessions.toSession(socket);
+		const time = (/* @__PURE__ */ new Date()).getTime();
+		return {
+			connectionId: session.id,
+			kind: getSessionKind(session),
+			operator: getSessionOperator(session),
+			platform: this._platform,
+			get presence() {
+				return session.webSocket.state.presence ?? session.presence ?? null;
+			},
+			set presence(presence) {
+				sessions.setPresence({
+					presence: presence ?? null,
+					sessionId: session.id
+				});
+			},
+			room: this._room.id,
+			session,
+			sessions: this._sessions.getLiveSessions(),
+			time,
+			user: session.user
+		};
+	}
+	_toSnapshot(socket) {
+		const session = this._sessions.toSession(socket);
+		return {
+			id: session.id,
+			kind: getSessionKind(session),
+			lastPing: this._platform.getLastPing(socket) ?? socket.state.timers.ping,
+			operator: getSessionOperator(session),
+			presence: session.presence,
+			quit: socket.state.quit,
+			seq: { presence: session.seq.presence },
+			user: session.user
+		};
+	}
+	/**
+	* Removes each socket on the queue, then runs `onUserDisconnected` after that
+	* join so the listener can await the session manager. `$exit` is written on
+	* a later join. Destroy waits until every unregister in progress has sent `$exit`.
+	*/
+	async _unregisterSockets(params) {
+		const { code, reason, sockets, closeSocket, sync } = params;
+		if (!sockets.length) return;
+		this._closing += 1;
+		try {
+			for (const socket of sockets) {
+				const snapshot = await this._queue.join(async () => {
+					if (!this._sessions.has(socket.sessionId)) return null;
+					const next = this._toSnapshot(socket);
+					this._room["~"].logDebug(`${colors.blue(`Unregistering connection for room ${this._room.id}:`)} ${next.id}`);
+					await this._removeSocket(socket);
+					return next;
+				});
+				if (!snapshot) continue;
+				let effects = null;
+				try {
+					effects = await this._room["~"].close(snapshot);
+				} finally {
+					if (closeSocket) socket.close(code, reason);
+				}
+				if (!effects) continue;
+				const produced = effects;
+				this._noteStorage(produced);
+				await this._queue.join(async () => {
+					await this._writeFrames(produced.broadcast, "broadcast");
+					await this._room["~"].dropStorageUpdates(produced.broadcast);
+					this._room["~"].logDebug(`${colors.blue(`Unregistered connection for room ${this._room.id}:`)} ${snapshot.id}`);
+				});
+			}
+		} finally {
+			this._closing -= 1;
+			await this._queue.join(async () => {
+				if (sync) await this._emitSyncState();
+				await this._destroyEmptyRoom();
+				if (this._sessions.getSize() === 0) this._roomStats.cancel();
+				else this._roomStats.schedule();
+			});
+		}
+	}
+	async _writeFrames(frames, mode) {
+		if (mode === "self") {
+			await Promise.all(frames.map(async (frame) => {
+				const socket = frame.connectionId ? this._sessions.get(frame.connectionId) ?? null : null;
+				if (!socket) return;
+				await Promise.resolve(socket.sendMessage({
+					...frame,
+					room: this._room.id
+				}));
+				if (frame.type === "$pong") await this._collectPong();
+			}));
+			return;
+		}
+		await Promise.allSettled(Array.from(this._sessions.all().values()).flatMap((socket) => frames.map((frame) => Promise.resolve(socket.sendMessage({
+			...frame,
+			room: this._room.id
+		})))));
+	}
+};
+// src/manageSessions.ts
+function manageSessions(room, platform) {
+	const full = room;
+	return new RoomSessionManager(full, platform ?? full._defs.platform);
+}
+export { AbstractPersistence, AbstractPlatform, AbstractPubSub, AbstractWebSocket, CommitGate, DEFAULT_MAX_CONNECTIONS, LIST_USERS_DEFAULT_LIMIT, LIST_USERS_MAX_LIMIT, PluvIO, PluvProcedure, PluvRouter, PluvServer, __internal, authorize, createIO, deferredResult, deferredResultPromise, isDeferredResult, isErrorMessage, isSuspended, manageSessions, parsePluvSchema };
+
+//# sourceMappingURL=index.mjs.map