atom.io 0.45.5 → 0.46.1

package/dist/realtime-server/index.js

@@ -1,8 +1,8 @@
 import { IMPLICIT, OWN_OP, Subject, actUponStore, editRelationsInStore, findInStore, findRelationsInStore, getFromStore, getInternalRelationsFromStore, getJsonToken, getUpdateToken, isRootStore, operateOnStore, setIntoStore, subscribeToState, subscribeToTransaction } from "atom.io/internal";
-import { atomFamily, join, mutableAtom, selectorFamily } from "atom.io";
+import { Realm, atomFamily, join, mutableAtom } from "atom.io";
 import { parseJson, stringifyJson } from "atom.io/json";
 import { UList } from "atom.io/transceivers/u-list";
-import { castSocket, employSocket, isRoomKey, isSocketKey, isUserKey, mutexAtoms, ownersOfRooms, roomKeysAtom, usersInRooms } from "atom.io/realtime";
+import { castSocket, employSocket, isRoomKey, isSocketKey, isUserKey, mutexAtoms, ownersOfRooms, roomKeysAtom, usersInRooms, visibleUsersInRoomsSelector } from "atom.io/realtime";
 import { spawn } from "node:child_process";
 
 //#region src/realtime-server/continuity/continuity-store.ts
@@ -215,6 +215,7 @@ function prepareToProvideContinuity({ socket, store = IMPLICIT.STORE }) {
 var CustomSocket = class {
 	listeners;
 	globalListeners;
+	globalListenersOutgoing;
 	handleEvent(...args) {
 		const [event, ...rest] = args;
 		for (const listener of this.globalListeners) listener(event, ...rest);
@@ -224,9 +225,13 @@ var CustomSocket = class {
 	id = `no_id_retrieved`;
 	emit;
 	constructor(emit) {
-		this.emit = emit;
+		this.emit = (...args) => {
+			for (const listener of this.globalListenersOutgoing) listener(...args);
+			return emit(...args);
+		};
 		this.listeners = /* @__PURE__ */ new Map();
 		this.globalListeners = /* @__PURE__ */ new Set();
+		this.globalListenersOutgoing = /* @__PURE__ */ new Set();
 	}
 	on(event, listener) {
 		const listeners = this.listeners.get(event);
@@ -238,6 +243,10 @@ var CustomSocket = class {
 		this.globalListeners.add(listener);
 		return this;
 	}
+	onAnyOutgoing(listener) {
+		this.globalListenersOutgoing.add(listener);
+		return this;
+	}
 	off(event, listener) {
 		const listeners = this.listeners.get(event);
 		if (listeners) if (listener) listeners.delete(listener);
@@ -520,77 +529,6 @@ var ParentSocket = class extends CustomSocket {
 	}
 };
 
-//#endregion
-//#region src/realtime-server/realtime-family-provider.ts
-function realtimeAtomFamilyProvider({ socket, userKey, store = IMPLICIT.STORE }) {
-	return function familyProvider(family, index) {
-		const coreSubscriptions = /* @__PURE__ */ new Set();
-		const clearCoreSubscriptions = () => {
-			for (const unsub of coreSubscriptions) unsub();
-			coreSubscriptions.clear();
-		};
-		const familyMemberSubscriptionsWanted = /* @__PURE__ */ new Set();
-		const familyMemberSubscriptions = /* @__PURE__ */ new Map();
-		const clearFamilySubscriptions = () => {
-			for (const unsub of familyMemberSubscriptions.values()) unsub();
-			familyMemberSubscriptions.clear();
-		};
-		const fillUnsubRequest = (key) => {
-			const unsubUnsub = familyMemberSubscriptions.get(`${key}:unsub`);
-			if (unsubUnsub) {
-				unsubUnsub();
-				familyMemberSubscriptions.delete(`${key}:unsub`);
-			}
-			const unsub = familyMemberSubscriptions.get(key);
-			if (unsub) {
-				unsub();
-				familyMemberSubscriptions.delete(key);
-			}
-		};
-		const exposeFamilyMembers = (subKey) => {
-			const token = findInStore(store, family, subKey);
-			getFromStore(store, token);
-			socket.emit(`serve:${token.key}`, getFromStore(store, token));
-			familyMemberSubscriptions.set(token.key, subscribeToState(store, token, `expose-family:${family.key}:${socket.id}`, ({ newValue }) => {
-				socket.emit(`serve:${token.key}`, newValue);
-			}));
-			familyMemberSubscriptions.set(`${token.key}:unsub`, employSocket(socket, `unsub:${token.key}`, () => {
-				store.logger.info(`🙈`, `user`, userKey, `unsubscribed from state "${token.key}"`);
-				fillUnsubRequest(token.key);
-			}));
-		};
-		const isAvailable$1 = (exposedSubKeys, subKey) => {
-			for (const exposedSubKey of exposedSubKeys) if (stringifyJson(exposedSubKey) === stringifyJson(subKey)) return true;
-			return false;
-		};
-		const start = () => {
-			store.logger.info(`👀`, `user`, userKey, `can subscribe to family "${family.key}"`);
-			coreSubscriptions.add(employSocket(socket, `sub:${family.key}`, (subKey) => {
-				if (isAvailable$1(getFromStore(store, index), subKey)) {
-					store.logger.info(`👀`, `user`, userKey, `is approved for a subscription to`, subKey, `in family "${family.key}"`);
-					exposeFamilyMembers(subKey);
-				} else {
-					store.logger.info(`❌`, `user`, userKey, `is denied for a subscription to`, subKey, `in family "${family.key}"`);
-					familyMemberSubscriptionsWanted.add(stringifyJson(subKey));
-					socket.emit(`unavailable:${family.key}`, subKey);
-				}
-			}));
-			coreSubscriptions.add(subscribeToState(store, index, `expose-family:${family.key}:${socket.id}`, ({ newValue: newExposedSubKeys }) => {
-				store.logger.info(`👀`, `user`, userKey, `has the following keys available for family "${family.key}"`, newExposedSubKeys);
-				for (const subKey of newExposedSubKeys) if (familyMemberSubscriptionsWanted.has(stringifyJson(subKey))) {
-					store.logger.info(`👀`, `user`, userKey, `is retroactively approved for a subscription to`, subKey, `in family "${family.key}"`);
-					exposeFamilyMembers(subKey);
-				}
-			}));
-		};
-		start();
-		return () => {
-			clearCoreSubscriptions();
-			clearFamilySubscriptions();
-		};
-	};
-}
-
 //#endregion
 //#region src/realtime-server/realtime-mutable-family-provider.ts
 const isAvailable = (exposedSubKeys, subKey) => {
@@ -696,90 +634,7 @@ function realtimeMutableProvider({ socket, userKey, store = IMPLICIT.STORE }) {
 }
 
 //#endregion
-//#region src/realtime-server/realtime-state-provider.ts
-function isReadableToken(input) {
-	return typeof input === `object` && input !== null && `key` in input && `type` in input;
-}
-function realtimeStateProvider({ socket, userKey, store = IMPLICIT.STORE }) {
-	store.logger.info(`🔌`, `user`, userKey, `initialized state provider`);
-	return function stateProvider(clientToken, serverData = clientToken) {
-		const isStatic = !isReadableToken(serverData);
-		const subscriptions = /* @__PURE__ */ new Set();
-		const clearSubscriptions = () => {
-			for (const unsub of subscriptions) unsub();
-			subscriptions.clear();
-		};
-		const start = () => {
-			if (isStatic) store.logger.info(`👀`, `user`, userKey, `will be served`, serverData, `as "${clientToken.key}"`);
-			else store.logger.info(`👀`, `user`, userKey, `can subscribe to state "${serverData.key}" as "${clientToken.key}"`);
-			subscriptions.add(employSocket(socket, `sub:${clientToken.key}`, () => {
-				if (isStatic) {
-					store.logger.info(`👀`, `user`, userKey, `requests`, `"${clientToken.key}"`);
-					socket.emit(`serve:${clientToken.key}`, serverData);
-				} else {
-					store.logger.info(`👀`, `user`, userKey, `subscribes to state "${serverData.key}"`, clientToken === serverData ? `directly` : `as "${clientToken.key}"`);
-					clearSubscriptions();
-					socket.emit(`serve:${clientToken.key}`, getFromStore(store, serverData));
-					subscriptions.add(subscribeToState(store, serverData, `expose-single:${socket.id}`, ({ newValue }) => {
-						socket.emit(`serve:${clientToken.key}`, newValue);
-					}));
-					subscriptions.add(employSocket(socket, `unsub:${serverData.key}`, () => {
-						store.logger.info(`🙈`, `user`, userKey, `unsubscribes from state "${serverData.key}", served`, clientToken === serverData ? `directly` : `as "${clientToken.key}"`);
-						clearSubscriptions();
-						start();
-					}));
-				}
-			}));
-		};
-		start();
-		return clearSubscriptions;
-	};
-}
-
-//#endregion
-//#region src/realtime-server/realtime-server-stores/provide-identity.ts
-function provideIdentity({ store = IMPLICIT.STORE, socket, userKey }) {
-	const unsub = realtimeStateProvider({
-		socket,
-		store,
-		userKey
-	})({
-		key: `myUserKey`,
-		type: `atom`
-	}, userKey);
-	socket.on(`disconnect`, () => {
-		unsub();
-	});
-}
-
-//#endregion
-//#region src/realtime-server/realtime-server-stores/server-user-store.ts
-const socketAtoms = atomFamily({
-	key: `sockets`,
-	default: null
-});
-const socketKeysAtom = mutableAtom({
-	key: `socketsIndex`,
-	class: UList
-});
-const userKeysAtom = mutableAtom({
-	key: `usersIndex`,
-	class: UList
-});
-const usersOfSockets = join({
-	key: `usersOfSockets`,
-	between: [`user`, `socket`],
-	cardinality: `1:1`,
-	isAType: isUserKey,
-	isBType: isSocketKey
-});
-const selfListSelectors = selectorFamily({
-	key: `selfList`,
-	get: (userKey) => () => [userKey]
-});
-
-//#endregion
-//#region src/realtime-server/realtime-server-stores/provide-rooms.ts
+//#region src/realtime-server/provide-rooms.ts
 const ROOMS = globalThis.ATOM_IO_REALTIME_SERVER_ROOMS ?? (globalThis.ATOM_IO_REALTIME_SERVER_ROOMS = /* @__PURE__ */ new Map());
 const roomMeta = { count: 0 };
 function spawnRoom({ store, socket, userKey, resolveRoomScript }) {
@@ -888,33 +743,31 @@ function destroyRoom({ store, socket, userKey }) {
 		store.logger.info(`📡`, `socket`, socket.id ?? `[ID MISSING?!]`, `👤 ${userKey} failed to delete room ${roomKey}; room owner is ${owner}`);
 	};
 }
-function provideRooms({ store = IMPLICIT.STORE, socket, resolveRoomScript, roomNames }) {
-	const socketKey = `socket::${socket.id}`;
-	const userKey = getFromStore(store, findRelationsInStore(store, usersOfSockets, socketKey).userKeyOfSocket);
+function provideRooms({ store = IMPLICIT.STORE, socket, resolveRoomScript, roomNames, userKey }) {
 	const roomSocket = castSocket(socket, createRoomSocketGuard(roomNames));
-	const exposeMutable = realtimeMutableProvider({
+	const unsubFromRoomKeys = realtimeMutableProvider({
 		socket,
 		store,
 		userKey
-	});
+	})(roomKeysAtom);
+	const usersInRoomsAtoms = getInternalRelationsFromStore(store, usersInRooms);
+	const [, usersInRoomsAtomsUsersOnly] = getInternalRelationsFromStore(store, usersInRooms, `split`);
+	const usersWhoseRoomsCanBeSeenSelector = findInStore(store, visibleUsersInRoomsSelector, userKey);
+	const ownersOfRoomsAtoms = getInternalRelationsFromStore(store, ownersOfRooms);
 	const exposeMutableFamily = realtimeMutableFamilyProvider({
 		socket,
 		store,
 		userKey
 	});
-	exposeMutable(roomKeysAtom);
-	const [, usersInRoomsAtoms] = getInternalRelationsFromStore(store, usersInRooms, `split`);
-	const usersWhoseRoomsCanBeSeenSelector = findInStore(store, selfListSelectors, userKey);
-	exposeMutableFamily(usersInRoomsAtoms, usersWhoseRoomsCanBeSeenSelector);
-	const [ownersOfRoomsAtoms] = getInternalRelationsFromStore(store, ownersOfRooms, `split`);
-	exposeMutableFamily(ownersOfRoomsAtoms, usersWhoseRoomsCanBeSeenSelector);
+	const unsubFromUsersInRooms = exposeMutableFamily(usersInRoomsAtoms, usersWhoseRoomsCanBeSeenSelector);
+	const unsubFromOwnersOfRooms = exposeMutableFamily(ownersOfRoomsAtoms, usersWhoseRoomsCanBeSeenSelector);
 	const enterRoom = provideEnterAndExit({
 		store,
 		socket,
 		roomSocket,
 		userKey
 	});
-	const userRoomSet = getFromStore(store, usersInRoomsAtoms, userKey);
+	const userRoomSet = getFromStore(store, usersInRoomsAtomsUsersOnly, userKey);
 	for (const userRoomKey of userRoomSet) {
 		enterRoom(userRoomKey);
 		break;
@@ -930,12 +783,11 @@ function provideRooms({ store = IMPLICIT.STORE, socket, resolveRoomScript, roomN
 		socket,
 		userKey
 	}));
-	socket.on(`disconnect`, () => {
-		store.logger.info(`📡`, `socket`, socket.id ?? `[ID MISSING?!]`, `👤 ${userKey} disconnects`);
-		editRelationsInStore(store, usersOfSockets, (rel) => rel.delete(socketKey));
-		setIntoStore(store, userKeysAtom, (keys) => (keys.delete(userKey), keys));
-		setIntoStore(store, socketKeysAtom, (keys) => (keys.delete(socketKey), keys));
-	});
+	return () => {
+		unsubFromRoomKeys();
+		unsubFromUsersInRooms();
+		unsubFromOwnersOfRooms();
+	};
 }
 const roomKeySchema = { "~standard": {
 	version: 1,
@@ -968,10 +820,123 @@ function createRoomSocketGuard(roomNames) {
 	};
 }
 
+//#endregion
+//#region src/realtime-server/realtime-family-provider.ts
+function realtimeAtomFamilyProvider({ socket, userKey, store = IMPLICIT.STORE }) {
+	return function familyProvider(family, index) {
+		const coreSubscriptions = /* @__PURE__ */ new Set();
+		const clearCoreSubscriptions = () => {
+			for (const unsub of coreSubscriptions) unsub();
+			coreSubscriptions.clear();
+		};
+		const familyMemberSubscriptionsWanted = /* @__PURE__ */ new Set();
+		const familyMemberSubscriptions = /* @__PURE__ */ new Map();
+		const clearFamilySubscriptions = () => {
+			for (const unsub of familyMemberSubscriptions.values()) unsub();
+			familyMemberSubscriptions.clear();
+		};
+		const fillUnsubRequest = (key) => {
+			const unsubUnsub = familyMemberSubscriptions.get(`${key}:unsub`);
+			if (unsubUnsub) {
+				unsubUnsub();
+				familyMemberSubscriptions.delete(`${key}:unsub`);
+			}
+			const unsub = familyMemberSubscriptions.get(key);
+			if (unsub) {
+				unsub();
+				familyMemberSubscriptions.delete(key);
+			}
+		};
+		const exposeFamilyMembers = (subKey) => {
+			const token = findInStore(store, family, subKey);
+			getFromStore(store, token);
+			socket.emit(`serve:${token.key}`, getFromStore(store, token));
+			familyMemberSubscriptions.set(token.key, subscribeToState(store, token, `expose-family:${family.key}:${socket.id}`, ({ newValue }) => {
+				socket.emit(`serve:${token.key}`, newValue);
+			}));
+			familyMemberSubscriptions.set(`${token.key}:unsub`, employSocket(socket, `unsub:${token.key}`, () => {
+				store.logger.info(`🙈`, `user`, userKey, `unsubscribed from state "${token.key}"`);
+				fillUnsubRequest(token.key);
+			}));
+		};
+		const isAvailable$1 = (exposedSubKeys, subKey) => {
+			for (const exposedSubKey of exposedSubKeys) if (stringifyJson(exposedSubKey) === stringifyJson(subKey)) return true;
+			return false;
+		};
+		const start = () => {
+			store.logger.info(`👀`, `user`, userKey, `can subscribe to family "${family.key}"`);
+			coreSubscriptions.add(employSocket(socket, `sub:${family.key}`, (subKey) => {
+				if (isAvailable$1(getFromStore(store, index), subKey)) {
+					store.logger.info(`👀`, `user`, userKey, `is approved for a subscription to`, subKey, `in family "${family.key}"`);
+					exposeFamilyMembers(subKey);
+				} else {
+					store.logger.info(`❌`, `user`, userKey, `is denied for a subscription to`, subKey, `in family "${family.key}"`);
+					familyMemberSubscriptionsWanted.add(stringifyJson(subKey));
+					socket.emit(`unavailable:${family.key}`, subKey);
+				}
+			}));
+			coreSubscriptions.add(subscribeToState(store, index, `expose-family:${family.key}:${socket.id}`, ({ newValue: newExposedSubKeys }) => {
+				store.logger.info(`👀`, `user`, userKey, `has the following keys available for family "${family.key}"`, newExposedSubKeys);
+				for (const subKey of newExposedSubKeys) if (familyMemberSubscriptionsWanted.has(stringifyJson(subKey))) {
+					store.logger.info(`👀`, `user`, userKey, `is retroactively approved for a subscription to`, subKey, `in family "${family.key}"`);
+					exposeFamilyMembers(subKey);
+				}
+			}));
+		};
+		start();
+		return () => {
+			clearCoreSubscriptions();
+			clearFamilySubscriptions();
+		};
+	};
+}
+
+//#endregion
+//#region src/realtime-server/realtime-state-provider.ts
+function isReadableToken(input) {
+	return typeof input === `object` && input !== null && `key` in input && `type` in input;
+}
+function realtimeStateProvider({ socket, userKey, store = IMPLICIT.STORE }) {
+	store.logger.info(`🔌`, `user`, userKey, `initialized state provider`);
+	return function stateProvider(clientToken, serverData = clientToken) {
+		const isStatic = !isReadableToken(serverData);
+		const subscriptions = /* @__PURE__ */ new Set();
+		const clearSubscriptions = () => {
+			for (const unsub of subscriptions) unsub();
+			subscriptions.clear();
+		};
+		const start = () => {
+			if (isStatic) store.logger.info(`👀`, `user`, userKey, `will be served`, serverData, `as "${clientToken.key}"`);
+			else store.logger.info(`👀`, `user`, userKey, `can subscribe to state "${serverData.key}" as "${clientToken.key}"`);
+			subscriptions.add(employSocket(socket, `sub:${clientToken.key}`, () => {
+				if (isStatic) {
+					store.logger.info(`👀`, `user`, userKey, `requests`, `"${clientToken.key}"`);
+					socket.emit(`serve:${clientToken.key}`, serverData);
+				} else {
+					store.logger.info(`👀`, `user`, userKey, `subscribes to state "${serverData.key}"`, clientToken === serverData ? `directly` : `as "${clientToken.key}"`);
+					clearSubscriptions();
+					socket.emit(`serve:${clientToken.key}`, getFromStore(store, serverData));
+					subscriptions.add(subscribeToState(store, serverData, `expose-single:${socket.id}`, ({ newValue }) => {
+						socket.emit(`serve:${clientToken.key}`, newValue);
+					}));
+					subscriptions.add(employSocket(socket, `unsub:${serverData.key}`, () => {
+						store.logger.info(`🙈`, `user`, userKey, `unsubscribes from state "${serverData.key}", served`, clientToken === serverData ? `directly` : `as "${clientToken.key}"`);
+						clearSubscriptions();
+						start();
+					}));
+				}
+			}));
+		};
+		start();
+		return clearSubscriptions;
+	};
+}
+
 //#endregion
 //#region src/realtime-server/realtime-state-receiver.ts
-function realtimeStateReceiver({ socket, store = IMPLICIT.STORE }) {
-	return function stateReceiver(clientToken, serverToken = clientToken) {
+function realtimeStateReceiver({ socket, userKey, store = IMPLICIT.STORE }) {
+	return function stateReceiver(schema, clientToken, serverToken = clientToken) {
+		const socketKey = `socket::${socket.id}`;
 		const mutexAtom = findInStore(store, mutexAtoms, serverToken.key);
 		const subscriptions = /* @__PURE__ */ new Set();
 		const clearSubscriptions = () => {
@@ -980,8 +945,13 @@ function realtimeStateReceiver({ socket, store = IMPLICIT.STORE }) {
 		};
 		const permitPublish = () => {
 			clearSubscriptions();
-			subscriptions.add(employSocket(socket, `pub:${clientToken.key}`, (newValue) => {
-				setIntoStore(store, serverToken, newValue);
+			subscriptions.add(employSocket(socket, `pub:${clientToken.key}`, async (newValue) => {
+				const parsed = await schema[`~standard`].validate(newValue);
+				if (parsed.issues) {
+					store.logger.error(`❌`, `user`, userKey, `attempted to publish invalid value`, newValue, `to state "${serverToken.key}"`);
+					return;
+				}
+				setIntoStore(store, serverToken, parsed.value);
 			}));
 			subscriptions.add(employSocket(socket, `unclaim:${clientToken.key}`, () => {
 				setIntoStore(store, mutexAtom, false);
@@ -993,7 +963,7 @@ function realtimeStateReceiver({ socket, store = IMPLICIT.STORE }) {
 			subscriptions.add(employSocket(socket, `claim:${clientToken.key}`, () => {
 				if (getFromStore(store, mutexAtom)) {
 					clearSubscriptions();
-					subscriptions.add(subscribeToState(store, mutexAtom, socket.id, () => {
+					subscriptions.add(subscribeToState(store, mutexAtom, socketKey, () => {
 						if (getFromStore(store, mutexAtom) === false) {
 							operateOnStore(OWN_OP, store, mutexAtom, true);
 							permitPublish();
@@ -1014,5 +984,75 @@ function realtimeStateReceiver({ socket, store = IMPLICIT.STORE }) {
 }
 
 //#endregion
-export { ChildSocket, CustomSocket, ParentSocket, ROOMS, SubjectSocket, destroyRoom, prepareToProvideContinuity, provideEnterAndExit, provideIdentity, provideRooms, realtimeAtomFamilyProvider, realtimeMutableFamilyProvider, realtimeMutableProvider, realtimeStateProvider, realtimeStateReceiver, roomMeta, selfListSelectors, socketAtoms, socketKeysAtom, spawnRoom, userKeysAtom, usersOfSockets };
+//#region src/realtime-server/server-socket-state.ts
+const socketAtoms = atomFamily({
+	key: `sockets`,
+	default: null
+});
+const socketKeysAtom = mutableAtom({
+	key: `socketsIndex`,
+	class: UList
+});
+const userKeysAtom = mutableAtom({
+	key: `usersIndex`,
+	class: UList
+});
+const usersOfSockets = join({
+	key: `usersOfSockets`,
+	between: [`user`, `socket`],
+	cardinality: `1:1`,
+	isAType: isUserKey,
+	isBType: isSocketKey
+});
+
+//#endregion
+//#region src/realtime-server/server-config.ts
+function realtime(server, auth, onConnect, store = IMPLICIT.STORE) {
+	const socketRealm = new Realm(store);
+	server.use((socket, next) => {
+		const result = auth(socket.handshake);
+		if (result instanceof Error) {
+			next(result);
+			return;
+		}
+		const userClaim = socketRealm.allocate(`root`, result);
+		const socketClaim = socketRealm.allocate(`root`, `socket::${socket.id}`);
+		setIntoStore(store, findInStore(store, socketAtoms, socketClaim), socket);
+		editRelationsInStore(store, usersOfSockets, (relations) => {
+			relations.set(userClaim, socketClaim);
+		});
+		setIntoStore(store, userKeysAtom, (index) => index.add(userClaim));
+		setIntoStore(store, socketKeysAtom, (index) => index.add(socketClaim));
+		next();
+	}).on(`connection`, (socket) => {
+		const socketKey = `socket::${socket.id}`;
+		const userKeyState = findRelationsInStore(store, usersOfSockets, socketKey).userKeyOfSocket;
+		const userKey = getFromStore(store, userKeyState);
+		const serverConfig = {
+			store,
+			socket,
+			userKey
+		};
+		const unsubFromMyUserKey = realtimeStateProvider(serverConfig)({
+			key: `myUserKey`,
+			type: `atom`
+		}, userKey);
+		const disposeServices = onConnect(serverConfig);
+		socket.on(`disconnect`, () => {
+			store.logger.info(`📡`, `socket`, socketKey, `👤 ${userKey} disconnects`);
+			disposeServices();
+			unsubFromMyUserKey();
+			editRelationsInStore(store, usersOfSockets, (rel) => rel.delete(socketKey));
+			setIntoStore(store, userKeysAtom, (keys) => (keys.delete(userKey), keys));
+			setIntoStore(store, socketKeysAtom, (keys) => (keys.delete(socketKey), keys));
+		});
+	});
+	const disposeAll = async () => {
+		await server.close();
+	};
+	return disposeAll;
+}
+
+//#endregion
+export { ChildSocket, CustomSocket, ParentSocket, ROOMS, SubjectSocket, destroyRoom, prepareToProvideContinuity, provideEnterAndExit, provideRooms, realtime, realtimeAtomFamilyProvider, realtimeMutableFamilyProvider, realtimeMutableProvider, realtimeStateProvider, realtimeStateReceiver, roomMeta, socketAtoms, socketKeysAtom, spawnRoom, userKeysAtom, usersOfSockets };
 //# sourceMappingURL=index.js.map