atom.io 0.44.5 → 0.44.7

package/src/internal/join/get-internal-relations-from-store.ts

@@ -5,16 +5,12 @@ import type { RootStore } from "../transaction"
 import { getJoin } from "./get-join"
 
 export function getInternalRelationsFromStore<
-	AName extends string,
-	BName extends string,
+	A extends string,
+	B extends string,
 >(
-	token: JoinToken<any, AName, any, BName, any>,
+	token: JoinToken<any, A, any, B, any>,
 	store: RootStore,
-): MutableAtomFamilyToken<UList<AName> | UList<BName>, string> {
+): MutableAtomFamilyToken<UList<A> | UList<B>, A | B> {
 	const myJoin = getJoin(token, store)
-	const family = myJoin.relatedKeysAtoms as MutableAtomFamilyToken<
-		UList<AName> | UList<BName>,
-		string
-	>
-	return family
+	return myJoin.relatedKeysAtoms
 }

package/src/internal/join/join-internal.ts

@@ -72,7 +72,7 @@ export class Join<
 	public options: JoinOptions<AName, A, BName, B, Cardinality>
 	public relations: Junction<AName, A, BName, B>
 	public states: JoinStateFamilies<AName, A, BName, B, Cardinality>
-	public relatedKeysAtoms: MutableAtomFamilyToken<UList<string>, string>
+	public relatedKeysAtoms: MutableAtomFamilyToken<UList<A> | UList<B>, A | B>
 
 	public transact(
 		toolkit: WriterToolkit,
@@ -120,7 +120,10 @@ export class Join<
 			},
 			[`join`, `relations`],
 		)
-		this.relatedKeysAtoms = relatedKeysAtoms
+		this.relatedKeysAtoms = relatedKeysAtoms as MutableAtomFamilyToken<
+			UList<A> | UList<B>,
+			A | B
+		>
 
 		const replaceRelationsSafely: Write<
 			(a: string, newRelationsOfA: string[]) => void

package/src/realtime/index.ts

@@ -1,5 +1,6 @@
 export * from "./employ-socket"
 export * from "./mutex-store"
 export * from "./realtime-continuity"
+export * from "./realtime-key-types"
 export * from "./shared-room-store"
 export type * from "./socket-interface"

package/src/realtime/realtime-continuity.ts

@@ -12,7 +12,8 @@ import {
 	setEpochNumberOfContinuity,
 } from "atom.io/internal"
 import type { Canonical } from "atom.io/json"
-import type { UserKey } from "atom.io/realtime-server"
+
+import type { UserKey } from "./realtime-key-types"
 
 /* eslint-disable no-console */
 

package/src/realtime/realtime-key-types.ts

@@ -0,0 +1,11 @@
+export type SocketKey = `socket::${string}`
+export const isSocketKey = (key: string): key is SocketKey =>
+	key.startsWith(`socket::`)
+
+export type UserKey = `user::${string}`
+export const isUserKey = (key: string): key is UserKey =>
+	key.startsWith(`user::`)
+
+export type RoomKey = `room::${string}`
+export const isRoomKey = (key: string): key is RoomKey =>
+	key.startsWith(`room::`)

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

@@ -6,14 +6,21 @@ import type {
 import { getInternalRelations, join, mutableAtom, selectorFamily } from "atom.io"
 import { UList } from "atom.io/transceivers/u-list"
 
-export const usersInThisRoomIndex: MutableAtomToken<UList<string>> = mutableAtom<
-	UList<string>
->({
-	key: `usersInRoomIndex`,
-	class: UList,
-})
+import {
+	isRoomKey,
+	isUserKey,
+	type RoomKey,
+	type UserKey,
+} from "./realtime-key-types"
+
+export type RoomSocketInterface<RoomNames extends string> = {
+	createRoom: (roomName: RoomNames) => void
+	joinRoom: (roomKey: string) => void
+	[leaveRoom: `leaveRoom:${string}`]: () => void
+	[deleteRoom: `deleteRoom:${string}`]: () => void
+}
 
-export const roomIndex: MutableAtomToken<UList<string>> = mutableAtom<
+export const roomKeysAtom: MutableAtomToken<UList<string>> = mutableAtom<
 	UList<string>
 >({
 	key: `roomIndex`,
@@ -26,19 +33,19 @@ export type UserInRoomMeta = {
 export const DEFAULT_USER_IN_ROOM_META: UserInRoomMeta = {
 	enteredAtEpoch: 0,
 }
-export const usersInRooms: JoinToken<`room`, string, `user`, string, `1:n`> =
+export const usersInRooms: JoinToken<`room`, RoomKey, `user`, UserKey, `1:n`> =
 	join({
 		key: `usersInRooms`,
 		between: [`room`, `user`],
 		cardinality: `1:n`,
-		isAType: (input): input is string => typeof input === `string`,
-		isBType: (input): input is string => typeof input === `string`,
+		isAType: isRoomKey,
+		isBType: isUserKey,
 	})
 
 export const usersInMyRoomView: ReadonlyPureSelectorFamilyToken<
-	MutableAtomToken<UList<string>>[],
-	string
-> = selectorFamily<MutableAtomToken<UList<string>>[], string>({
+	MutableAtomToken<UList<UserKey>>[],
+	UserKey
+> = selectorFamily<MutableAtomToken<UList<UserKey>>[], UserKey>({
 	key: `usersInMyRoomView`,
 	get:
 		(myUsername) =>

package/src/realtime-client/continuity/register-and-attempt-confirmed-update.ts

@@ -9,8 +9,8 @@ import {
 } from "atom.io/internal"
 import type { Socket } from "atom.io/realtime"
 import {
-	confirmedUpdateQueue,
-	optimisticUpdateQueue,
+	confirmedUpdateQueueAtom,
+	optimisticUpdateQueueAtom,
 } from "atom.io/realtime-client"
 
 export const useRegisterAndAttemptConfirmedUpdate =
@@ -42,7 +42,7 @@ export const useRegisterAndAttemptConfirmedUpdate =
 				continuityKey,
 				`reconciling updates`,
 			)
-			setIntoStore(store, optimisticUpdateQueue, (queue) => {
+			setIntoStore(store, optimisticUpdateQueueAtom, (queue) => {
 				queue.shift()
 				return queue
 			})
@@ -172,7 +172,7 @@ export const useRegisterAndAttemptConfirmedUpdate =
 						`pushing confirmed update to queue`,
 						confirmed,
 					)
-					setIntoStore(store, confirmedUpdateQueue, (queue) => {
+					setIntoStore(store, confirmedUpdateQueueAtom, (queue) => {
 						queue.push(confirmed)
 						queue.sort((a, b) => a.epoch - b.epoch)
 						return queue
@@ -229,7 +229,7 @@ export const useRegisterAndAttemptConfirmedUpdate =
 						continuityKey,
 						`pushing confirmed update #${confirmed.epoch} to queue`,
 					)
-					setIntoStore(store, confirmedUpdateQueue, (queue) => {
+					setIntoStore(store, confirmedUpdateQueueAtom, (queue) => {
 						queue.push(confirmed)
 						queue.sort((a, b) => a.epoch - b.epoch)
 						return queue

package/src/realtime-client/realtime-client-stores/client-main-store.ts

@@ -1,20 +1,16 @@
 import * as AtomIO from "atom.io"
+import type { SocketKey, UserKey } from "atom.io/realtime"
 import { storageSync } from "atom.io/web"
 
-export const myIdState__INTERNAL: AtomIO.RegularAtomToken<string | undefined> =
-	AtomIO.atom<string | undefined>({
-		key: `mySocketId__INTERNAL`,
+export const mySocketKeyAtom: AtomIO.RegularAtomToken<SocketKey | undefined> =
+	AtomIO.atom<SocketKey | undefined>({
+		key: `mySocketKey`,
 		default: undefined,
 	})
-export const myIdState: AtomIO.ReadonlyPureSelectorToken<string | undefined> =
-	AtomIO.selector<string | undefined>({
-		key: `mySocketId`,
-		get: ({ get }) => get(myIdState__INTERNAL),
-	})
 
-export const myUsernameState: AtomIO.RegularAtomToken<string | null> =
-	AtomIO.atom<string | null>({
-		key: `myName`,
+export const myUserKeyAtom: AtomIO.RegularAtomToken<UserKey | null> =
+	AtomIO.atom<UserKey | null>({
+		key: `myUserKey`,
 		default: null,
-		effects: [storageSync(globalThis.localStorage, JSON, `myUsername`)],
+		effects: [storageSync(globalThis.localStorage, JSON, `myUserKey`)],
 	})

package/src/realtime-client/realtime-client-stores/client-sync-store.ts

@@ -1,15 +1,15 @@
 import * as AtomIO from "atom.io"
 
-export const optimisticUpdateQueue: AtomIO.RegularAtomToken<
+export const optimisticUpdateQueueAtom: AtomIO.RegularAtomToken<
 	AtomIO.TransactionOutcomeEvent<any>[]
 > = AtomIO.atom<AtomIO.TransactionOutcomeEvent<any>[]>({
-	key: `updateQueue`,
+	key: `optimisticUpdateQueue`,
 	default: () => [],
 })
 
-export const confirmedUpdateQueue: AtomIO.RegularAtomToken<
+export const confirmedUpdateQueueAtom: AtomIO.RegularAtomToken<
 	AtomIO.TransactionOutcomeEvent<any>[]
 > = AtomIO.atom<AtomIO.TransactionOutcomeEvent<any>[]>({
-	key: `serverConfirmedUpdateQueue`,
+	key: `confirmedUpdateQueue`,
 	default: () => [],
 })

package/src/realtime-client/sync-continuity.ts

@@ -10,8 +10,8 @@ import {
 import type { Json } from "atom.io/json"
 import type { ContinuityToken } from "atom.io/realtime"
 import {
-	confirmedUpdateQueue,
-	optimisticUpdateQueue,
+	confirmedUpdateQueueAtom,
+	optimisticUpdateQueueAtom,
 } from "atom.io/realtime-client"
 import type { Socket } from "socket.io-client"
 
@@ -25,8 +25,8 @@ export function syncContinuity(
 	continuity: ContinuityToken,
 ): () => void {
 	const continuityKey = continuity.key
-	const optimisticUpdates = getFromStore(store, optimisticUpdateQueue)
-	const confirmedUpdates = getFromStore(store, confirmedUpdateQueue)
+	const optimisticUpdates = getFromStore(store, optimisticUpdateQueueAtom)
+	const confirmedUpdates = getFromStore(store, confirmedUpdateQueueAtom)
 
 	const initializeContinuity = (epoch: number, payload: Json.Array) => {
 		socket.off(`continuity-init:${continuityKey}`, initializeContinuity)
@@ -83,7 +83,7 @@ export function syncContinuity(
 						continuityKey,
 						`enqueuing new optimistic update`,
 					)
-					setIntoStore(store, optimisticUpdateQueue, (queue) => {
+					setIntoStore(store, optimisticUpdateQueueAtom, (queue) => {
 						queue.push(clientUpdate)
 						queue.sort((a, b) => a.epoch - b.epoch)
 						return queue
@@ -95,7 +95,7 @@ export function syncContinuity(
 						continuityKey,
 						`replacing existing optimistic update at index ${optimisticUpdateIndex}`,
 					)
-					setIntoStore(store, optimisticUpdateQueue, (queue) => {
+					setIntoStore(store, optimisticUpdateQueueAtom, (queue) => {
 						queue[optimisticUpdateIndex] = clientUpdate
 						return queue
 					})

package/src/realtime-react/realtime-context.tsx

@@ -1,4 +1,5 @@
 import { useI } from "atom.io/react"
+import type { RoomSocketInterface } from "atom.io/realtime/shared-room-store"
 import * as RTC from "atom.io/realtime-client"
 import * as React from "react"
 import type { Socket } from "socket.io-client"
@@ -26,19 +27,27 @@ export const RealtimeProvider: React.FC<{
 	const services = React.useRef(
 		new Map<string, RealtimeServiceCounter>(),
 	).current
-	const setMyId = useI(RTC.myIdState__INTERNAL)
+	const setMySocketKey = useI(RTC.mySocketKeyAtom)
 	React.useEffect(() => {
-		setMyId(socket?.id)
+		setMySocketKey(socket?.id ? `socket::${socket.id}` : undefined)
 		socket?.on(`connect`, () => {
-			setMyId(socket.id)
+			setMySocketKey(socket?.id ? `socket::${socket.id}` : undefined)
 		})
 		socket?.on(`disconnect`, () => {
-			setMyId(undefined)
+			setMySocketKey(undefined)
 		})
-	}, [socket, setMyId])
+	}, [socket, setMySocketKey])
 	return (
 		<RealtimeContext.Provider value={{ socket, services }}>
 			{children}
 		</RealtimeContext.Provider>
 	)
 }
+
+export function useRealtimeRooms<RoomNames extends string>(): Socket<
+	{},
+	RoomSocketInterface<RoomNames>
+> {
+	const { socket } = React.useContext(RealtimeContext)
+	return socket as Socket<{}, RoomSocketInterface<RoomNames>>
+}

package/src/realtime-server/continuity/continuity-store.ts

@@ -4,8 +4,7 @@ import type {
 	TransactionSubEvent,
 } from "atom.io"
 import { atomFamily } from "atom.io"
-
-import type { UserKey } from "../realtime-server-stores"
+import type { UserKey } from "atom.io/realtime"
 
 export function redactTransactionUpdateContent(
 	visibleStateKeys: string[],

package/src/realtime-server/continuity/provide-continuity.ts

@@ -1,8 +1,8 @@
 import { getFromStore, IMPLICIT } from "atom.io/internal"
 import type { Json } from "atom.io/json"
-import type { ContinuityToken } from "atom.io/realtime"
+import type { ContinuityToken, UserKey } from "atom.io/realtime"
 
-import type { ServerConfig, UserKey } from ".."
+import type { ServerConfig } from ".."
 import { unacknowledgedUpdatesAtoms } from "./continuity-store"
 import { provideOutcomes } from "./provide-outcomes"
 import { providePerspectives } from "./provide-perspectives"

package/src/realtime-server/continuity/provide-outcomes.ts

@@ -7,9 +7,8 @@ import {
 	subscribeToTransaction,
 } from "atom.io/internal"
 import type { Json } from "atom.io/json"
-import type { ContinuityToken, Socket } from "atom.io/realtime"
+import type { ContinuityToken, Socket, UserKey } from "atom.io/realtime"
 
-import type { UserKey } from ".."
 import {
 	redactTransactionUpdateContent,
 	unacknowledgedUpdatesAtoms,

package/src/realtime-server/continuity/provide-perspectives.ts

@@ -5,9 +5,7 @@ import {
 	getJsonToken,
 	subscribeToState,
 } from "atom.io/internal"
-import type { ContinuityToken, Socket } from "atom.io/realtime"
-
-import type { UserKey } from "../realtime-server-stores"
+import type { ContinuityToken, Socket, UserKey } from "atom.io/realtime"
 
 export function providePerspectives(
 	store: Store,

package/src/realtime-server/continuity/provide-startup-payloads.ts

@@ -6,11 +6,9 @@ import {
 	isRootStore,
 } from "atom.io/internal"
 import type { Json } from "atom.io/json"
-import type { ContinuityToken, Socket } from "atom.io/realtime"
+import type { ContinuityToken, Socket, UserKey } from "atom.io/realtime"
 import { employSocket } from "atom.io/realtime"
 
-import type { UserKey } from ".."
-
 export function provideStartupPayloads(
 	store: Store,
 	socket: Socket,

package/src/realtime-server/continuity/track-acknowledgements.ts

@@ -1,9 +1,8 @@
 import type { Store } from "atom.io/internal"
 import { getFromStore, setIntoStore } from "atom.io/internal"
-import type { ContinuityToken, Socket } from "atom.io/realtime"
+import type { ContinuityToken, Socket, UserKey } from "atom.io/realtime"
 import { employSocket } from "atom.io/realtime"
 
-import type { UserKey } from "../realtime-server-stores"
 import { unacknowledgedUpdatesAtoms } from "./continuity-store"
 
 export function trackAcknowledgements(

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

@@ -3,9 +3,9 @@ import type { Readable, Writable } from "node:stream"
 import { Subject } from "atom.io/internal"
 import type { Json } from "atom.io/json"
 import { parseJson, stringifyJson } from "atom.io/json"
+import type { UserKey } from "atom.io/realtime"
 import { UList } from "atom.io/transceivers/u-list"
 
-import type { UserKey } from "../realtime-server-stores"
 import type { StderrLog } from "./child-socket"
 import type { EventBuffer, EventPayload, Events } from "./custom-socket"
 import { CustomSocket } from "./custom-socket"

package/src/realtime-server/realtime-mutable-family-provider.ts

@@ -14,6 +14,18 @@ import { employSocket } from "atom.io/realtime"
 
 import type { ServerConfig } from "."
 
+const isAvailable = <K extends Canonical>(
+	exposedSubKeys: Iterable<K>,
+	subKey: K,
+): boolean => {
+	for (const exposedSubKey of exposedSubKeys) {
+		if (stringifyJson(exposedSubKey) === stringifyJson(subKey)) {
+			return true
+		}
+	}
+	return false
+}
+
 export type MutableFamilyProvider = ReturnType<
 	typeof realtimeMutableFamilyProvider
 >
@@ -78,15 +90,6 @@ export function realtimeMutableFamilyProvider({
 			)
 		}
 
-		const isAvailable = (exposedSubKeys: Iterable<K>, subKey: K): boolean => {
-			for (const exposedSubKey of exposedSubKeys) {
-				if (stringifyJson(exposedSubKey) === stringifyJson(subKey)) {
-					return true
-				}
-			}
-			return false
-		}
-
 		const start = () => {
 			coreSubscriptions.add(
 				employSocket(socket, `sub:${family.key}`, (subKey: K) => {

package/src/realtime-server/realtime-server-stores/server-room-external-store.ts

@@ -2,23 +2,50 @@ import type { ChildProcessWithoutNullStreams } from "node:child_process"
 import { spawn } from "node:child_process"
 
 import type { Store } from "atom.io/internal"
-import { editRelationsInStore, setIntoStore } from "atom.io/internal"
+import {
+	editRelationsInStore,
+	findInStore,
+	findRelationsInStore,
+	getFromStore,
+	getInternalRelationsFromStore,
+	IMPLICIT,
+	setIntoStore,
+} from "atom.io/internal"
 import type { Json } from "atom.io/json"
-import type { Socket } from "atom.io/realtime"
-import { roomIndex, usersInRooms } from "atom.io/realtime"
+import type { RoomKey, Socket, SocketKey, UserKey } from "atom.io/realtime"
+import { roomKeysAtom, usersInRooms } 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"
 
-export const ROOMS: Map<
+export type RoomMap = Map<
 	string,
 	ChildSocket<any, any, ChildProcessWithoutNullStreams>
-> = new Map()
+>
+
+declare global {
+	var ATOM_IO_REALTIME_SERVER_ROOMS: RoomMap
+}
+
+export const ROOMS: RoomMap =
+	globalThis.ATOM_IO_REALTIME_SERVER_ROOMS ??
+	(globalThis.ATOM_IO_REALTIME_SERVER_ROOMS = new Map())
+
+export const roomMeta: { count: number } = { count: 0 }
 
 export async function spawnRoom(
-	roomId: string,
+	store: Store,
+	roomKey: RoomKey,
 	command: string,
 	args: string[],
-	store: Store,
 ): Promise<ChildSocket<any, any>> {
 	const child = await new Promise<ChildProcessWithoutNullStreams>((resolve) => {
 		const room = spawn(command, args, { env: process.env })
@@ -30,22 +57,22 @@ export async function spawnRoom(
 		}
 		room.stdout.on(`data`, resolver)
 	})
-	const roomSocket = new ChildSocket(child, roomId)
-	ROOMS.set(roomId, roomSocket)
-	setIntoStore(store, roomIndex, (index) => (index.add(roomId), index))
+	const roomSocket = new ChildSocket(child, roomKey)
+	ROOMS.set(roomKey, roomSocket)
+	setIntoStore(store, roomKeysAtom, (index) => (index.add(roomKey), index))
 
 	roomSocket.on(`close`, () => {
-		destroyRoom(roomId, store)
+		destroyRoom(store, roomKey)
 	})
 
 	return roomSocket
 }
 
 export function joinRoom(
-	roomId: string,
-	userId: string,
-	socket: Socket,
 	store: Store,
+	roomKey: RoomKey,
+	userKey: UserKey,
+	socket: Socket,
 ): {
 	leave: () => void
 	roomSocket: ChildSocket<any, any, ChildProcessWithoutNullStreams>
@@ -63,22 +90,22 @@ export function joinRoom(
 	editRelationsInStore(
 		usersInRooms,
 		(relations) => {
-			relations.set({ room: roomId, user: userId })
+			relations.set({ room: roomKey, user: userKey })
 		},
 		store,
 	)
-	const roomSocket = ROOMS.get(roomId)
+	const roomSocket = ROOMS.get(roomKey)
 	if (!roomSocket) {
-		store.logger.error(`❌`, `unknown`, roomId, `no room found with this id`)
+		store.logger.error(`❌`, `unknown`, roomKey, `no room found with this id`)
 		return null
 	}
 	roomSocket.onAny((...payload) => {
 		socket.emit(...payload)
 	})
-	roomSocket.emit(`user-joins`, userId)
+	roomSocket.emit(`user-joins`, userKey)
 
 	toRoom = (payload) => {
-		roomSocket.emit(`user::${userId}`, ...payload)
+		roomSocket.emit(`user::${userKey}`, ...payload)
 	}
 	while (roomQueue.length > 0) {
 		const payload = roomQueue.shift()
@@ -88,34 +115,107 @@ export function joinRoom(
 	const leave = () => {
 		socket.offAny(forward)
 		toRoom([`user-leaves`])
-		leaveRoom(roomId, userId, store)
+		leaveRoom(store, roomKey, userKey)
 	}
 
 	return { leave, roomSocket }
 }
 
-export function leaveRoom(roomId: string, userId: string, store: Store): void {
+export function leaveRoom(
+	store: Store,
+	roomKey: RoomKey,
+	userKey: UserKey,
+): void {
 	editRelationsInStore(
 		usersInRooms,
 		(relations) => {
-			relations.delete({ room: roomId, user: userId })
+			relations.delete({ room: roomKey, user: userKey })
 		},
 		store,
 	)
 }
 
-export function destroyRoom(roomId: string, store: Store): void {
+export function destroyRoom(store: Store, roomKey: RoomKey): void {
+	setIntoStore(store, roomKeysAtom, (s) => (s.delete(roomKey), s))
 	editRelationsInStore(
 		usersInRooms,
 		(relations) => {
-			relations.delete({ room: roomId })
+			relations.delete({ room: roomKey })
 		},
 		store,
 	)
-	setIntoStore(store, roomIndex, (s) => (s.delete(roomId), s))
-	const room = ROOMS.get(roomId)
+	const room = ROOMS.get(roomKey)
 	if (room) {
 		room.emit(`exit`)
-		ROOMS.delete(roomId)
+		ROOMS.delete(roomKey)
 	}
 }
+
+export function provideRooms<RoomNames extends string>(
+	{ store = IMPLICIT.STORE, socket }: ServerConfig,
+	resolveRoomScript: (path: string) => [string, string[]],
+): void {
+	const socketKey = `socket::${socket.id}` satisfies SocketKey
+	const userKey = getFromStore(
+		store,
+		findRelationsInStore(usersOfSockets, socketKey, store).userKeyOfSocket,
+	)!
+
+	const exposeMutable = realtimeMutableProvider({ socket, store })
+	const exposeMutableFamily = realtimeMutableFamilyProvider({
+		socket,
+		store,
+	})
+
+	exposeMutable(roomKeysAtom)
+
+	const usersInRoomsAtoms = getInternalRelationsFromStore(usersInRooms, store)
+	const usersWhoseRoomsCanBeSeenSelector = findInStore(
+		store,
+		selfListSelectors,
+		userKey,
+	)
+	exposeMutableFamily(usersInRoomsAtoms, usersWhoseRoomsCanBeSeenSelector)
+	const usersOfSocketsAtoms = getInternalRelationsFromStore(
+		usersOfSockets,
+		store,
+	)
+	exposeMutableFamily(usersOfSocketsAtoms, socketKeysAtom)
+
+	socket.on(`createRoom`, async (roomName: RoomNames) => {
+		// logger.info(`[${shortId}]:${username}`, `creating room "${roomId}"`)
+		const roomId = `room::${roomMeta.count++}` satisfies RoomKey
+		await spawnRoom(store, roomId, ...resolveRoomScript(roomName))
+		socket.on(`deleteRoom:${roomId}`, () => {
+			// logger.info(`[${shortId}]:${username}`, `deleting room "${roomId}"`)
+			destroyRoom(store, roomId)
+		})
+	})
+
+	socket.on(`joinRoom`, (roomKey: RoomKey) => {
+		// logger.info(`[${shortId}]:${username}`, `joining room "${roomId}"`)
+		const { leave } = joinRoom(store, roomKey, userKey, socket)!
+		socket.on(`leaveRoom:${roomKey}`, leave)
+	})
+
+	socket.on(`disconnect`, () => {
+		editRelationsInStore(
+			usersOfSockets,
+			(relations) => relations.delete(socketKey),
+			store,
+		)
+		if (userKey) {
+			setIntoStore(
+				store,
+				userKeysAtom,
+				(index) => (index.delete(userKey), index),
+			)
+		}
+		setIntoStore(
+			store,
+			socketKeysAtom,
+			(index) => (index.delete(socketKey), index),
+		)
+		// logger.info(`${socket.id} disconnected`)
+	})
+}