atom.io 0.46.0 → 0.46.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atom.io",
-  "version": "0.46.0",
+  "version": "0.46.1",
   "description": "Composable and testable reactive data library.",
   "homepage": "https://atom.io.fyi",
   "sideEffects": false,

package/src/realtime/cast-socket.ts

@@ -61,6 +61,7 @@ export function castSocket<T extends TypedSocket>(
 				})
 			})
 		},
+		onAnyOutgoing: socket.onAnyOutgoing.bind(socket),
 		off: socket.off.bind(socket),
 		offAny: socket.offAny.bind(socket),
 		emit: socket.emit.bind(socket),

package/src/realtime/shared-room-store.ts

@@ -1,6 +1,7 @@
 import type {
 	JoinToken,
 	MutableAtomToken,
+	PureSelectorFamilyToken,
 	ReadonlyPureSelectorFamilyToken,
 } from "atom.io"
 import { getInternalRelations, join, mutableAtom, selectorFamily } from "atom.io"
@@ -41,6 +42,20 @@ export const usersInRooms: JoinToken<`room`, RoomKey, `user`, UserKey, `1:n`> =
 		isBType: isUserKey,
 	})
 
+export const visibleUsersInRoomsSelector: PureSelectorFamilyToken<
+	(RoomKey | UserKey)[],
+	UserKey
+> = selectorFamily({
+	key: `selfList`,
+	get:
+		(userKey) =>
+		({ get }) => {
+			const [, roomsOfUsersAtoms] = getInternalRelations(usersInRooms, `split`)
+			const rooms = get(roomsOfUsersAtoms, userKey)
+			return [userKey, ...rooms]
+		},
+})
+
 export const ownersOfRooms: JoinToken<`user`, UserKey, `room`, RoomKey, `1:n`> =
 	join({
 		key: `ownersOfRooms`,

package/src/realtime/socket-interface.ts

@@ -28,11 +28,12 @@ export type EventEmitter<EmitEvents extends EventsMap = EventsMap> = <
 
 export type TypedSocket<
 	ListenEvents extends EventsMap = EventsMap,
-	EmitEvents extends EventsMap = EventsMap,
+	EmitEvents extends EventsMap = never,
 > = {
 	id: string | undefined
 	on: ParticularEventListener<ListenEvents>
 	onAny: (listener: AllEventsListener<ListenEvents>) => void
+	onAnyOutgoing: (listener: AllEventsListener<EmitEvents>) => void
 	off: ParticularEventListener<ListenEvents>
 	offAny: (listener: AllEventsListener<ListenEvents>) => void
 	emit: EventEmitter<EmitEvents>
@@ -44,6 +45,9 @@ export type Socket = {
 	onAny: (
 		listener: (event: string, ...args: Json.Serializable[]) => void,
 	) => void
+	onAnyOutgoing: (
+		listener: (event: string, ...args: Json.Serializable[]) => void,
+	) => void
 	off: (event: string, listener: (...args: Json.Serializable[]) => void) => void
 	offAny: (
 		listener: (event: string, ...args: Json.Serializable[]) => void,

package/src/realtime-server/index.ts

@@ -1,9 +1,10 @@
 export * from "./continuity/provide-continuity"
 export * from "./ipc-sockets"
+export * from "./provide-rooms"
 export * from "./realtime-family-provider"
 export * from "./realtime-mutable-family-provider"
 export * from "./realtime-mutable-provider"
-export * from "./realtime-server-stores"
 export * from "./realtime-state-provider"
 export * from "./realtime-state-receiver"
-export type * from "./server-config"
+export * from "./server-config"
+export * from "./server-socket-state"

package/src/realtime-server/ipc-sockets/custom-socket.ts

@@ -20,6 +20,9 @@ export abstract class CustomSocket<I extends Events, O extends Events>
 {
 	protected listeners: Map<keyof O, Set<(...args: Json.Array) => void>>
 	protected globalListeners: Set<(event: string, ...args: Json.Array) => void>
+	protected globalListenersOutgoing: Set<
+		(event: string, ...args: Json.Array) => void
+	>
 	protected handleEvent<K extends string & keyof I>(
 		...args: EventPayload<I, K>
 	): void {
@@ -36,7 +39,7 @@ export abstract class CustomSocket<I extends Events, O extends Events>
 	}
 
 	public id = `no_id_retrieved`
-	public emit: <Event extends keyof I>(
+	public emit: <Event extends string & keyof I>(
 		event: Event,
 		...args: I[Event]
 	) => CustomSocket<I, O>
@@ -47,9 +50,15 @@ export abstract class CustomSocket<I extends Events, O extends Events>
 			...args: I[Event]
 		) => CustomSocket<I, O>,
 	) {
-		this.emit = emit
+		this.emit = (...args) => {
+			for (const listener of this.globalListenersOutgoing) {
+				listener(...args)
+			}
+			return emit(...args)
+		}
 		this.listeners = new Map()
 		this.globalListeners = new Set()
+		this.globalListenersOutgoing = new Set()
 	}
 
 	public on<Event extends keyof O>(
@@ -70,6 +79,13 @@ export abstract class CustomSocket<I extends Events, O extends Events>
 		return this
 	}
 
+	public onAnyOutgoing(
+		listener: (event: string, ...args: Json.Array) => void,
+	): this {
+		this.globalListenersOutgoing.add(listener)
+		return this
+	}
+
 	public off<Event extends keyof O>(
 		event: Event,
 		listener?: (...args: O[Event]) => void,

package/src/realtime-server/ipc-sockets/parent-socket.ts

@@ -190,7 +190,7 @@ export class ParentSocket<
 				relay.in.next(data)
 			})
 			relay.out.subscribe(`socket`, (data) => {
-				this.emit(...(data as [string, ...I[keyof I]]))
+				this.emit(...(data as [string, ...I[string & keyof I]]))
 			})
 		})
 

package/src/realtime-server/{realtime-server-stores/provide-rooms.ts → provide-rooms.ts}

@@ -19,7 +19,6 @@ import type {
 	RoomSocketInterface,
 	Socket,
 	SocketGuard,
-	SocketKey,
 	StandardSchemaV1,
 	TypedSocket,
 	UserKey,
@@ -30,18 +29,13 @@ import {
 	ownersOfRooms,
 	roomKeysAtom,
 	usersInRooms,
+	visibleUsersInRoomsSelector,
 } from "atom.io/realtime"
 
-import { ChildSocket } from "../ipc-sockets"
-import { realtimeMutableFamilyProvider } from "../realtime-mutable-family-provider"
-import { realtimeMutableProvider } from "../realtime-mutable-provider"
-import type { ServerConfig } from "../server-config"
-import {
-	selfListSelectors,
-	socketKeysAtom,
-	userKeysAtom,
-	usersOfSockets,
-} from "./server-user-store"
+import { ChildSocket } from "./ipc-sockets"
+import { realtimeMutableFamilyProvider } from "./realtime-mutable-family-provider"
+import { realtimeMutableProvider } from "./realtime-mutable-provider"
+import type { ServerConfig } from "./server-config"
 
 export type RoomMap = Map<
 	string,
@@ -240,74 +234,55 @@ export function provideRooms<RoomNames extends string>({
 	socket,
 	resolveRoomScript,
 	roomNames,
-}: ProvideRoomsConfig<RoomNames> & ServerConfig): void {
-	const socketKey = `socket::${socket.id}` satisfies SocketKey
-	const userKey = getFromStore(
-		store,
-		findRelationsInStore(store, usersOfSockets, socketKey).userKeyOfSocket,
-	)!
-	// const roomSocket = socket as TypedSocket<RoomSocketInterface<RoomNames>, {}>
-	const roomSocket = castSocket<TypedSocket<RoomSocketInterface<RoomNames>, {}>>(
-		socket,
-		createRoomSocketGuard(roomNames),
-	)
-
+	userKey,
+}: ProvideRoomsConfig<RoomNames> & ServerConfig): () => void {
+	const roomSocket = castSocket<
+		TypedSocket<RoomSocketInterface<RoomNames>, never>
+	>(socket, createRoomSocketGuard(roomNames))
 	const exposeMutable = realtimeMutableProvider({ socket, store, userKey })
-	const exposeMutableFamily = realtimeMutableFamilyProvider({
-		socket,
-		store,
-		userKey,
-	})
-
-	exposeMutable(roomKeysAtom)
-
-	const [, usersInRoomsAtoms] = getInternalRelationsFromStore(
+	const unsubFromRoomKeys = exposeMutable(roomKeysAtom)
+	const usersInRoomsAtoms = getInternalRelationsFromStore(store, usersInRooms)
+	const [, usersInRoomsAtomsUsersOnly] = getInternalRelationsFromStore(
 		store,
 		usersInRooms,
 		`split`,
 	)
 	const usersWhoseRoomsCanBeSeenSelector = findInStore(
 		store,
-		selfListSelectors,
+		visibleUsersInRoomsSelector,
 		userKey,
 	)
-	exposeMutableFamily(usersInRoomsAtoms, usersWhoseRoomsCanBeSeenSelector)
-	// const usersOfSocketsAtoms = getInternalRelationsFromStore(
-	// 	store,
-	// 	usersOfSockets,
-	// )
-	// exposeMutableFamily(usersOfSocketsAtoms, socketKeysAtom)
-	const [ownersOfRoomsAtoms] = getInternalRelationsFromStore(
+	const ownersOfRoomsAtoms = getInternalRelationsFromStore(store, ownersOfRooms)
+	const exposeMutableFamily = realtimeMutableFamilyProvider({
+		socket,
 		store,
-		ownersOfRooms,
-		`split`,
+		userKey,
+	})
+	const unsubFromUsersInRooms = exposeMutableFamily(
+		usersInRoomsAtoms,
+		usersWhoseRoomsCanBeSeenSelector,
+	)
+	const unsubFromOwnersOfRooms = exposeMutableFamily(
+		ownersOfRoomsAtoms,
+		usersWhoseRoomsCanBeSeenSelector,
 	)
-	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
 	}
-
 	roomSocket.on(
 		`createRoom`,
 		spawnRoom({ store, socket, userKey, resolveRoomScript }),
 	)
 	roomSocket.on(`deleteRoom`, destroyRoom({ store, 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: StandardSchemaV1<Json.Array, [RoomKey]> = {

package/src/realtime-server/realtime-state-provider.ts

@@ -21,9 +21,11 @@ export function realtimeStateProvider({
 	store = IMPLICIT.STORE,
 }: ServerConfig) {
 	store.logger.info(`🔌`, `user`, userKey, `initialized state provider`)
-	return function stateProvider<J extends Json.Serializable>(
-		clientToken: AtomIO.WritableToken<J>,
-		serverData: AtomIO.ReadableToken<NoInfer<J>> | NoInfer<J> = clientToken,
+	return function stateProvider<C extends Json.Serializable, S extends C>(
+		clientToken: AtomIO.WritableToken<C>,
+		serverData:
+			| AtomIO.ReadableToken<S>
+			| S = clientToken as AtomIO.ReadableToken<S>,
 	): () => void {
 		const isStatic = !isReadableToken(serverData)
 

package/src/realtime-server/realtime-state-receiver.ts

@@ -9,6 +9,7 @@ import {
 	subscribeToState,
 } from "atom.io/internal"
 import type { Json } from "atom.io/json"
+import type { SocketKey, StandardSchemaV1 } from "atom.io/realtime"
 import { employSocket, mutexAtoms } from "atom.io/realtime"
 
 import type { ServerConfig } from "."
@@ -16,12 +17,15 @@ import type { ServerConfig } from "."
 export type StateReceiver = ReturnType<typeof realtimeStateReceiver>
 export function realtimeStateReceiver({
 	socket,
+	userKey,
 	store = IMPLICIT.STORE,
 }: ServerConfig) {
 	return function stateReceiver<S extends Json.Serializable, C extends S>(
+		schema: StandardSchemaV1<unknown, C>,
 		clientToken: WritableToken<C>,
 		serverToken: WritableToken<S> = clientToken,
 	): () => void {
+		const socketKey = `socket::${socket.id}` satisfies SocketKey
 		const mutexAtom = findInStore(store, mutexAtoms, serverToken.key)
 
 		const subscriptions = new Set<() => void>()
@@ -33,8 +37,20 @@ export function realtimeStateReceiver({
 		const permitPublish = () => {
 			clearSubscriptions()
 			subscriptions.add(
-				employSocket(socket, `pub:${clientToken.key}`, (newValue) => {
-					setIntoStore(store, serverToken, newValue as C)
+				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(
@@ -52,7 +68,7 @@ export function realtimeStateReceiver({
 					if (getFromStore(store, mutexAtom)) {
 						clearSubscriptions()
 						subscriptions.add(
-							subscribeToState(store, mutexAtom, socket.id!, () => {
+							subscribeToState(store, mutexAtom, socketKey, () => {
 								const currentValue = getFromStore(store, mutexAtom)
 								if (currentValue === false) {
 									operateOnStore(OWN_OP, store, mutexAtom, true)

package/src/realtime-server/server-config.ts

@@ -1,8 +1,119 @@
+import type { IncomingHttpHeaders } from "node:http"
+import type { ParsedUrlQuery } from "node:querystring"
+
+import { Realm } from "atom.io"
 import type { RootStore } from "atom.io/internal"
-import type { Socket, UserKey } from "atom.io/realtime"
+import {
+	editRelationsInStore,
+	findInStore,
+	findRelationsInStore,
+	getFromStore,
+	IMPLICIT,
+	setIntoStore,
+} from "atom.io/internal"
+import type { Socket, SocketKey, UserKey } from "atom.io/realtime"
+import type { Server } from "socket.io"
+
+import { realtimeStateProvider } from "./realtime-state-provider"
+import type { SocketSystemHierarchy } from "./server-socket-state"
+import {
+	socketAtoms,
+	socketKeysAtom,
+	userKeysAtom,
+	usersOfSockets,
+} from "./server-socket-state"
 
 export type ServerConfig = {
 	socket: Socket
 	userKey: UserKey
 	store?: RootStore
 }
+
+/** Socket Handshake details--taken from socket.io */
+export type Handshake = {
+	/** The headers sent as part of the handshake */
+	headers: IncomingHttpHeaders
+	/** The date of creation (as string) */
+	time: string
+	/** The ip of the client */
+	address: string
+	/** Whether the connection is cross-domain */
+	xdomain: boolean
+	/** Whether the connection is secure */
+	secure: boolean
+	/** The date of creation (as unix timestamp) */
+	issued: number
+	/** The request URL string */
+	url: string
+	/** The query object */
+	query: ParsedUrlQuery
+	/** The auth object */
+	auth: {
+		[key: string]: any
+	}
+}
+
+export function realtime(
+	server: Server,
+	auth: (handshake: Handshake) => Error | UserKey,
+	onConnect: (config: ServerConfig) => () => void,
+	store: RootStore = IMPLICIT.STORE,
+): () => Promise<void> {
+	const socketRealm = new Realm<SocketSystemHierarchy>(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}`)
+			const socketState = findInStore(store, socketAtoms, socketClaim)
+			setIntoStore(store, socketState, 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}` satisfies SocketKey
+			const userKeyState = findRelationsInStore(
+				store,
+				usersOfSockets,
+				socketKey,
+			).userKeyOfSocket
+			const userKey = getFromStore(store, userKeyState)!
+			const serverConfig: ServerConfig = { store, socket, userKey }
+			const provideState = realtimeStateProvider(serverConfig)
+			const unsubFromMyUserKey = provideState(
+				{ 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
+}

package/src/realtime-server/{realtime-server-stores/server-user-store.ts → server-socket-state.ts}

@@ -2,10 +2,9 @@ import type {
 	Hierarchy,
 	JoinToken,
 	MutableAtomToken,
-	PureSelectorFamilyToken,
 	RegularAtomFamilyToken,
 } from "atom.io"
-import { atomFamily, join, mutableAtom, selectorFamily } from "atom.io"
+import { atomFamily, join, mutableAtom } from "atom.io"
 import type { RoomKey, Socket, SocketKey, UserKey } from "atom.io/realtime"
 import { isSocketKey, isUserKey } from "atom.io/realtime"
 import { UList } from "atom.io/transceivers/u-list"
@@ -46,9 +45,3 @@ export const usersOfSockets: JoinToken<
 	isAType: isUserKey,
 	isBType: isSocketKey,
 })
-
-export const selfListSelectors: PureSelectorFamilyToken<UserKey[], UserKey> =
-	selectorFamily({
-		key: `selfList`,
-		get: (userKey) => () => [userKey],
-	})

package/src/realtime-testing/setup-realtime-test.tsx

@@ -5,19 +5,10 @@ import type { RenderResult } from "@testing-library/react"
 import { prettyDOM, render } from "@testing-library/react"
 import * as AtomIO from "atom.io"
 import type { Store } from "atom.io/internal"
-import {
-	clearStore,
-	editRelationsInStore,
-	findInStore,
-	findRelationsInStore,
-	getFromStore,
-	IMPLICIT,
-	setIntoStore,
-} from "atom.io/internal"
+import { clearStore, IMPLICIT } from "atom.io/internal"
 import { toEntries } from "atom.io/json"
 import * as AR from "atom.io/react"
-import type * as RT from "atom.io/realtime"
-import * as RTC from "atom.io/realtime-client"
+import * as RT from "atom.io/realtime"
 import * as RTR from "atom.io/realtime-react"
 import * as RTS from "atom.io/realtime-server"
 import { UList } from "atom.io/transceivers/u-list"
@@ -64,7 +55,7 @@ function prefixLogger(store: Store, prefix: string) {
 export type TestSetupOptions = {
 	immortal?: { server?: boolean }
 	server: (tools: {
-		socket: SocketIO.Socket
+		socket: RT.Socket
 		silo: AtomIO.Silo
 		userKey: RT.UserKey
 		enableLogging: () => void
@@ -124,8 +115,6 @@ export const setupRealtimeTestServer = (
 		},
 		IMPLICIT.STORE,
 	)
-	// prefixLogger(silo.store, `server`)
-	const socketRealm = new AtomIO.Realm<RTS.SocketSystemHierarchy>(silo.store)
 
 	const httpServer = http.createServer((_, res) => res.end(`Hello World!`))
 	const address = httpServer.listen().address()
@@ -133,76 +122,42 @@ export const setupRealtimeTestServer = (
 		typeof address === `string` ? null : address === null ? null : address.port
 	if (port === null) throw new Error(`Could not determine port for test server`)
 
-	const server = new SocketIO.Server(httpServer).use((socket, next) => {
-		const { token, username } = socket.handshake.auth
-		if (token === `test` && socket.id) {
-			const userClaim = socketRealm.allocate(`root`, username as RT.UserKey)
-			const socketClaim = socketRealm.allocate(`root`, `socket::${socket.id}`)
-			const socketState = findInStore(silo.store, RTS.socketAtoms, socketClaim)
-			setIntoStore(silo.store, socketState, socket)
-			editRelationsInStore(silo.store, RTS.usersOfSockets, (relations) => {
-				relations.set(userClaim, socketClaim)
-			})
-			setIntoStore(silo.store, RTS.userKeysAtom, (index) => index.add(userClaim))
-			setIntoStore(silo.store, RTS.socketKeysAtom, (index) =>
-				index.add(socketClaim),
-			)
-			next()
-		} else {
-			next(new Error(`Authentication error`))
-		}
-	})
-
-	const socketServices = new Set<() => void>()
-	const disposeAllSocketServices = () => {
-		for (const disposeService of socketServices) disposeService()
-	}
-
-	server.on(`connection`, (socket: SocketIO.Socket) => {
-		const userKeyState = findRelationsInStore(
-			silo.store,
-			RTS.usersOfSockets,
-			`socket::${socket.id}`,
-		).userKeyOfSocket
-		const userKey = getFromStore(silo.store, userKeyState)!
-		function enableLogging() {
-			prefixLogger(silo.store, `server`)
-			socket.onAny((event, ...args) => {
-				console.log(`🛰 `, userKey, event, ...args)
-			})
-			socket.onAnyOutgoing((event, ...args) => {
-				console.log(`🛰  >>`, userKey, event, ...args)
-			})
-			socket.on(`disconnect`, () => {
-				console.log(`${userKey} disconnected`)
+	const server = new SocketIO.Server(httpServer)
+	const dispose = RTS.realtime(
+		server,
+		(handshake) => {
+			const { token, username } = handshake.auth
+			if (RT.isUserKey(username) && token === `test`) {
+				return username
+			}
+			return new Error(`Authentication error`)
+		},
+		(config) => {
+			const { socket, userKey } = config
+			function enableLogging() {
+				prefixLogger(silo.store, `server`)
+				socket.onAny((event, ...args) => {
+					console.log(`🛰 `, userKey, event, ...args)
+				})
+				socket.onAnyOutgoing((event, ...args) => {
+					console.log(`🛰  >>`, userKey, event, ...args)
+				})
+				socket.on(`disconnect`, () => {
+					console.log(`${userKey} disconnected`)
+				})
+			}
+			const disposeServices = options.server({
+				socket: config.socket,
+				userKey: config.userKey,
+				enableLogging,
+				silo,
 			})
-		}
-		const disposeServices = options.server({
-			socket,
-			enableLogging,
-			silo,
-			userKey,
-		})
-		if (disposeServices) {
-			socketServices.add(disposeServices)
-			socket.on(`disconnect`, disposeServices)
-		}
-	})
-
-	const dispose = async () => {
-		disposeAllSocketServices()
-		await server.close()
-
-		// const roomKeys = getFromStore(silo.store, RT.roomIndex)
-		// for (const roomKey of roomKeys) {
-		// 	const roomState = findInStore(silo.store, RTS.roomSelectors, roomKey)
-		// 	const room = getFromStore(silo.store, roomState)
-		// 	if (room && !(room instanceof Promise)) {
-		// 		room.process.kill()
-		// 	}
-		// } // ❗ POSSIBLY STILL NEEDED
-		silo.store.valueMap.clear()
-	}
+			return () => {
+				disposeServices?.()
+			}
+		},
+		silo.store,
+	)
 
 	return {
 		name: `SERVER`,

package/src/realtime-server/realtime-server-stores/index.ts

@@ -1,3 +0,0 @@
-export * from "./provide-identity"
-export * from "./provide-rooms"
-export * from "./server-user-store"

package/src/realtime-server/realtime-server-stores/provide-identity.ts

@@ -1,18 +0,0 @@
-import { IMPLICIT } from "atom.io/internal"
-
-import { realtimeStateProvider } from "../realtime-state-provider"
-import type { ServerConfig } from "../server-config"
-
-export function provideIdentity({
-	store = IMPLICIT.STORE,
-	socket,
-	userKey,
-}: ServerConfig): void {
-	const provideState = realtimeStateProvider({ socket, store, userKey })
-
-	const unsub = provideState({ key: `myUserKey`, type: `atom` }, userKey)
-
-	socket.on(`disconnect`, () => {
-		unsub()
-	})
-}