atom.io 0.40.7 → 0.40.9

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

@@ -0,0 +1,50 @@
+import { getFromStore, IMPLICIT } from "atom.io/internal"
+import type { Json } from "atom.io/json"
+import type { ContinuityToken } from "atom.io/realtime"
+
+import type { ServerConfig, UserKey } from ".."
+import { unacknowledgedUpdatesAtoms } from "./continuity-store"
+import { provideOutcomes } from "./provide-outcomes"
+import { providePerspectives } from "./provide-perspectives"
+import { provideStartupPayloads } from "./provide-startup-payloads"
+import { receiveActionRequests } from "./receive-action-requests"
+import { trackAcknowledgements } from "./track-acknowledgements"
+
+export type ProvideContinuity = (
+	continuity: ContinuityToken,
+	userKey: UserKey,
+) => () => void
+export function prepareToProvideContinuity({
+	socket,
+	store = IMPLICIT.STORE,
+}: ServerConfig): ProvideContinuity {
+	return function syncRealtimeContinuity(continuity, userKey) {
+		const continuityKey = continuity.key
+
+		const unacknowledgedUpdates = getFromStore(
+			store,
+			unacknowledgedUpdatesAtoms,
+			userKey,
+		)
+		for (const unacknowledgedUpdate of unacknowledgedUpdates) {
+			socket.emit(
+				`tx-new:${continuityKey}`,
+				unacknowledgedUpdate as Json.Serializable,
+			)
+		}
+
+		const subscriptions = new Set<() => void>()
+		const clearSubscriptions = () => {
+			for (const unsubscribe of subscriptions) unsubscribe()
+			subscriptions.clear()
+		}
+
+		subscriptions.add(providePerspectives(store, socket, continuity, userKey))
+		subscriptions.add(provideOutcomes(store, socket, continuity, userKey))
+		subscriptions.add(provideStartupPayloads(store, socket, continuity, userKey))
+		subscriptions.add(receiveActionRequests(store, socket, continuity, userKey))
+		subscriptions.add(trackAcknowledgements(store, socket, continuity, userKey))
+
+		return clearSubscriptions
+	}
+}

package/src/realtime-server/continuity/{subscribe-to-continuity-actions.ts → provide-outcomes.ts}

@@ -7,29 +7,29 @@ import {
 	subscribeToTransaction,
 } from "atom.io/internal"
 import type { Json } from "atom.io/json"
-import type { ContinuityToken } from "atom.io/realtime"
+import type { ContinuityToken, Socket } from "atom.io/realtime"
 
-import type { Socket, UserKey } from ".."
+import type { UserKey } from ".."
 import {
 	redactTransactionUpdateContent,
-	userUnacknowledgedQueues,
+	unacknowledgedUpdatesAtoms,
 } from "./continuity-store"
 
-export function subscribeToContinuityActions(
+export function provideOutcomes(
 	store: Store,
+	socket: Socket,
 	continuity: ContinuityToken,
 	userKey: UserKey,
-	socket: Socket | null,
-): (() => void)[] {
+): () => void {
 	const continuityKey = continuity.key
-	const unsubscribeFunctions: (() => void)[] = []
+	const unsubscribeFunctions = new Set<() => void>()
 
 	for (const transaction of continuity.actions) {
 		const unsubscribeFromTransaction = subscribeToTransaction(
 			store,
 			transaction,
 			`sync-continuity:${continuityKey}:${userKey}`,
-			(update) => {
+			(outcomes) => {
 				try {
 					const visibleKeys = continuity.globals
 						.map((atom) => {
@@ -59,13 +59,13 @@ export function subscribeToContinuityActions(
 						)
 					const redactedUpdates = redactTransactionUpdateContent(
 						visibleKeys,
-						update.subEvents,
+						outcomes.subEvents,
 					)
 					const redactedUpdate = {
-						...update,
+						...outcomes,
 						updates: redactedUpdates,
 					}
-					setIntoStore(store, userUnacknowledgedQueues, userKey, (updates) => {
+					setIntoStore(store, unacknowledgedUpdatesAtoms, userKey, (updates) => {
 						if (redactedUpdate) {
 							updates.push(redactedUpdate)
 							updates.sort((a, b) => a.epoch - b.epoch)
@@ -81,7 +81,7 @@ export function subscribeToContinuityActions(
 						return updates
 					})
 
-					socket?.emit(
+					socket.emit(
 						`tx-new:${continuityKey}`,
 						redactedUpdate as Json.Serializable,
 					)
@@ -98,7 +98,9 @@ export function subscribeToContinuityActions(
 				}
 			},
 		)
-		unsubscribeFunctions.push(unsubscribeFromTransaction)
+		unsubscribeFunctions.add(unsubscribeFromTransaction)
+	}
+	return () => {
+		for (const unsubscribe of unsubscribeFunctions) unsubscribe()
 	}
-	return unsubscribeFunctions
 }

package/src/realtime-server/continuity/{subscribe-to-continuity-perpectives.ts → provide-perspectives.ts}

@@ -5,19 +5,18 @@ import {
 	getJsonToken,
 	subscribeToState,
 } from "atom.io/internal"
-import type { ContinuityToken } from "atom.io/realtime"
+import type { ContinuityToken, Socket } from "atom.io/realtime"
 
-import type { Socket } from ".."
 import type { UserKey } from "../realtime-server-stores"
 
-export function subscribeToContinuityPerspectives(
+export function providePerspectives(
 	store: Store,
+	socket: Socket,
 	continuity: ContinuityToken,
 	userKey: UserKey,
-	socket: Socket | null,
-): (() => void)[] {
+): () => void {
 	const continuityKey = continuity.key
-	const unsubFns: (() => void)[] = []
+	const unsubFns = new Set<() => void>()
 	for (const perspective of continuity.perspectives) {
 		const { viewAtoms } = perspective
 		const userViewState = findInStore(store, viewAtoms, userKey)
@@ -47,14 +46,16 @@ export function subscribeToContinuityPerspectives(
 					{ oldKeys, newKeys, revealed, concealed },
 				)
 				if (revealed.length > 0) {
-					socket?.emit(`reveal:${continuityKey}`, revealed)
+					socket.emit(`reveal:${continuityKey}`, revealed)
 				}
 				if (concealed && concealed.length > 0) {
-					socket?.emit(`conceal:${continuityKey}`, concealed)
+					socket.emit(`conceal:${continuityKey}`, concealed)
 				}
 			},
 		)
-		unsubFns.push(unsubscribeFromUserView)
+		unsubFns.add(unsubscribeFromUserView)
+	}
+	return () => {
+		for (const unsubscribe of unsubFns) unsubscribe()
 	}
-	return unsubFns
 }

package/src/realtime-server/continuity/{prepare-to-send-initial-payload.ts → provide-startup-payloads.ts}

@@ -6,18 +6,19 @@ import {
 	isRootStore,
 } from "atom.io/internal"
 import type { Json } from "atom.io/json"
-import type { ContinuityToken } from "atom.io/realtime"
+import type { ContinuityToken, Socket } from "atom.io/realtime"
+import { employSocket } from "atom.io/realtime"
 
-import type { Socket, UserKey } from ".."
+import type { UserKey } from ".."
 
-export function prepareToSendInitialPayload(
+export function provideStartupPayloads(
 	store: Store,
+	socket: Socket,
 	continuity: ContinuityToken,
 	userKey: UserKey,
-	socket: Socket | null,
 ): () => void {
 	const continuityKey = continuity.key
-	return function sendInitialPayload(): void {
+	function sendInitialPayload(): void {
 		const initialPayload: Json.Serializable[] = []
 		for (const atom of continuity.globals) {
 			const resourceToken =
@@ -49,6 +50,7 @@ export function prepareToSendInitialPayload(
 			? (store.transactionMeta.epoch.get(continuityKey) ?? null)
 			: null
 
-		socket?.emit(`continuity-init:${continuityKey}`, epoch, initialPayload)
+		socket.emit(`continuity-init:${continuityKey}`, epoch, initialPayload)
 	}
+	return employSocket(socket, `get:${continuityKey}`, sendInitialPayload)
 }

package/src/realtime-server/continuity/receive-action-requests.ts

@@ -0,0 +1,66 @@
+import type { TransactionOutcomeEvent, TransactionToken } from "atom.io"
+import type { Store } from "atom.io/internal"
+import { actUponStore } from "atom.io/internal"
+import type { Json, JsonIO } from "atom.io/json"
+import type { ContinuityToken, Socket } from "atom.io/realtime"
+import { employSocket } from "atom.io/realtime"
+
+export function receiveActionRequests(
+	store: Store,
+	socket: Socket,
+	continuity: ContinuityToken,
+	userKey: string,
+): () => void {
+	const continuityKey = continuity.key
+
+	return employSocket(
+		socket,
+		`tx-run:${continuityKey}`,
+		function serveTransactionRequest(
+			txOutcome: Json.Serializable &
+				Pick<
+					TransactionOutcomeEvent<TransactionToken<JsonIO>>,
+					`id` | `params` | `token`
+				>,
+		) {
+			store.logger.info(`🛎️`, `continuity`, continuityKey, `received`, txOutcome)
+			const transactionKey = txOutcome.token.key
+			const updateId = txOutcome.id
+			const performanceKey = `tx-run:${transactionKey}:${updateId}`
+			const performanceKeyStart = `${performanceKey}:start`
+			const performanceKeyEnd = `${performanceKey}:end`
+			performance.mark(performanceKeyStart)
+			try {
+				actUponStore(
+					store,
+					{ type: `transaction`, key: transactionKey },
+					updateId,
+				)(...txOutcome.params)
+			} catch (thrown) {
+				if (thrown instanceof Error) {
+					store.logger.error(
+						`❌`,
+						`continuity`,
+						continuityKey,
+						`failed to run transaction ${transactionKey} from ${userKey} with update ${updateId}`,
+						thrown.message,
+					)
+				}
+			}
+			performance.mark(performanceKeyEnd)
+			const metric = performance.measure(
+				performanceKey,
+				performanceKeyStart,
+				performanceKeyEnd,
+			)
+			store.logger.info(
+				`🚀`,
+				`transaction`,
+				transactionKey,
+				updateId,
+				userKey,
+				metric.duration,
+			)
+		},
+	)
+}

package/src/realtime-server/continuity/{prepare-to-track-client-acknowledgement.ts → track-acknowledgements.ts}

@@ -1,19 +1,24 @@
 import type { Store } from "atom.io/internal"
-import { setIntoStore } from "atom.io/internal"
-import type { ContinuityToken } from "atom.io/realtime"
+import { getFromStore, setIntoStore } from "atom.io/internal"
+import type { ContinuityToken, Socket } from "atom.io/realtime"
+import { employSocket } from "atom.io/realtime"
 
 import type { UserKey } from "../realtime-server-stores"
-import type { ContinuitySyncTransactionUpdate } from "./continuity-store"
-import { userUnacknowledgedQueues } from "./continuity-store"
+import { unacknowledgedUpdatesAtoms } from "./continuity-store"
 
-export function prepareToTrackClientAcknowledgement(
+export function trackAcknowledgements(
 	store: Store,
+	socket: Socket,
 	continuity: ContinuityToken,
 	userKey: UserKey,
-	userUnacknowledgedUpdates: ContinuitySyncTransactionUpdate[],
-): (epoch: number) => void {
+): () => void {
 	const continuityKey = continuity.key
-	return function trackClientAcknowledgement(epoch) {
+	const userUnacknowledgedUpdates = getFromStore(
+		store,
+		unacknowledgedUpdatesAtoms,
+		userKey,
+	)
+	function trackClientAcknowledgement(epoch: number): void {
 		store.logger.info(
 			`👍`,
 			`continuity`,
@@ -22,7 +27,7 @@ export function prepareToTrackClientAcknowledgement(
 		)
 		const isUnacknowledged = userUnacknowledgedUpdates[0]?.epoch === epoch
 		if (isUnacknowledged) {
-			setIntoStore(store, userUnacknowledgedQueues, userKey, (updates) => {
+			setIntoStore(store, unacknowledgedUpdatesAtoms, userKey, (updates) => {
 				updates.shift()
 				store.logger.info(
 					`👍`,
@@ -36,4 +41,5 @@ export function prepareToTrackClientAcknowledgement(
 			})
 		}
 	}
+	return employSocket(socket, `ack:${continuityKey}`, trackClientAcknowledgement)
 }

package/src/realtime-server/index.ts

@@ -1,6 +1,5 @@
-export * from "./continuity/prepare-to-sync-realtime-continuity"
+export * from "./continuity/provide-continuity"
 export * from "./ipc-sockets"
-export * from "./realtime-action-receiver"
 export * from "./realtime-family-provider"
 export * from "./realtime-mutable-family-provider"
 export * from "./realtime-mutable-provider"
@@ -8,4 +7,3 @@ export * from "./realtime-server-stores"
 export * from "./realtime-state-provider"
 export * from "./realtime-state-receiver"
 export type * from "./server-config"
-export type * from "./socket-interface"

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

@@ -1,13 +1,12 @@
 import type { Json, stringified } from "atom.io/json"
-
-import type { Socket } from "../socket-interface"
+import type { Socket } from "atom.io/realtime"
 
 export type Events = Json.Object<string, Json.Serializable[]>
 
 export type EventPayload<
-	E extends Events,
-	K extends string & keyof E = string & keyof E,
-> = [string, ...E[K]]
+	receiveRelay extends Events,
+	K extends string & keyof receiveRelay = string & keyof receiveRelay,
+> = [string, ...receiveRelay[K]]
 
 export interface EventBuffer<
 	E extends Events,

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

@@ -3,8 +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 { SetRTX } from "atom.io/transceivers/set-rtx"
+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"
@@ -48,14 +49,14 @@ export type ParentProcess = {
 
 export class ParentSocket<
 	I extends Events & {
-		[id in string as `relay:${id}`]: [string, ...Json.Array[]]
+		[id in string as `relay::${id}`]: [string, ...Json.Array[]]
 	},
 	O extends Events & {
-		[id in string as `user:${id}`]: [string, ...Json.Array[]]
+		[id in string as `user::${id}`]: [string, ...Json.Array[]]
 	} & {
 		/* eslint-disable quotes */
-		"user-joins": [string]
-		"user-leaves": [string]
+		"user-joins": [key: UserKey]
+		"user-leaves": [key: UserKey]
 		/* eslint-enable quotes */
 	},
 	P extends ParentProcess = ParentProcess,
@@ -65,6 +66,7 @@ export class ParentSocket<
 	protected relays: Map<string, SubjectSocket<any, any>>
 	protected relayServices: ((
 		socket: SubjectSocket<any, any>,
+		userKey: UserKey,
 	) => (() => void) | void)[]
 	public proc: P
 
@@ -74,9 +76,7 @@ export class ParentSocket<
 		this.proc.stderr.write(
 			stringifyJson(
 				args.map((arg) =>
-					arg instanceof SetRTX
-						? `{ ${arg.toJSON().members.join(` | `)} }`
-						: arg,
+					arg instanceof UList ? `{ ${arg.toJSON().members.join(` | `)} }` : arg,
 				),
 			) + `\x03`,
 		)
@@ -171,22 +171,23 @@ export class ParentSocket<
 			this.id = this.proc.pid?.toString()
 		}
 
-		this.on(`user-joins`, (username) => {
+		this.on(`user-joins`, (username: string) => {
 			this.logger.info(`👤`, `user`, username, `joined`)
-			const relay = new SubjectSocket(`user:${username}`)
+			const userKey = `user::${username}` satisfies UserKey
+			const relay = new SubjectSocket(userKey)
 			this.relays.set(username, relay)
 			this.logger.info(
 				`🔗`,
 				`attaching services:`,
 				`[${[...this.relayServices.keys()].join(`, `)}]`,
 			)
-			for (const attachServices of this.relayServices) {
-				const cleanup = attachServices(relay)
-				if (cleanup) {
-					relay.disposalFunctions.push(cleanup)
+			for (const attachRelay of this.relayServices) {
+				const cleanupRelay = attachRelay(relay, userKey)
+				if (cleanupRelay) {
+					relay.disposalFunctions.push(cleanupRelay)
 				}
 			}
-			this.on(`user:${username}`, (...data) => {
+			this.on(userKey, (...data) => {
 				relay.in.next(data)
 			})
 			relay.out.subscribe(`socket`, (data) => {
@@ -206,8 +207,11 @@ export class ParentSocket<
 		this.proc.stdout.write(`ALIVE`)
 	}
 
-	public relay(
-		attachServices: (socket: SubjectSocket<any, any>) => (() => void) | void,
+	public receiveRelay(
+		attachServices: (
+			socket: SubjectSocket<any, any>,
+			userKey: UserKey,
+		) => (() => void) | void,
 	): void {
 		this.logger.info(`🔗`, `running relay method`)
 		this.relayServices.push(attachServices)

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

@@ -7,9 +7,9 @@ import {
 } from "atom.io/internal"
 import type { Canonical, Json, stringified } from "atom.io/json"
 import { stringifyJson } from "atom.io/json"
+import { employSocket } from "atom.io/realtime"
 
 import type { ServerConfig } from "."
-import { employSocket } from "./employ-socket"
 
 export type FamilyProvider = ReturnType<typeof realtimeAtomFamilyProvider>
 export function realtimeAtomFamilyProvider({

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

@@ -10,9 +10,9 @@ import {
 } from "atom.io/internal"
 import type { Canonical, stringified } from "atom.io/json"
 import { stringifyJson } from "atom.io/json"
+import { employSocket } from "atom.io/realtime"
 
 import type { ServerConfig } from "."
-import { employSocket } from "./employ-socket"
 
 export type MutableFamilyProvider = ReturnType<
 	typeof realtimeMutableFamilyProvider

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

@@ -8,9 +8,9 @@ import {
 	subscribeToState,
 } from "atom.io/internal"
 import type { Json } from "atom.io/json"
+import { employSocket } from "atom.io/realtime"
 
 import type { ServerConfig } from "."
-import { employSocket } from "./employ-socket"
 
 export type MutableProvider = ReturnType<typeof realtimeMutableProvider>
 export function realtimeMutableProvider({

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

@@ -4,8 +4,8 @@ import { spawn } from "node:child_process"
 import type { TransactionIO, TransactionToken } from "atom.io"
 import { transaction } from "atom.io"
 import { editRelationsInStore } from "atom.io/internal"
-import type { UserInRoomMeta } from "atom.io/realtime/shared-room-store"
-import { roomIndex, usersInRooms } from "atom.io/realtime/shared-room-store"
+import type { UserInRoomMeta } from "atom.io/realtime"
+import { roomIndex, usersInRooms } from "atom.io/realtime"
 
 import { ChildSocket } from "../ipc-sockets"
 import type { RoomKey } from "./server-user-store"

package/src/realtime-server/realtime-server-stores/server-user-store.ts

@@ -6,9 +6,8 @@ import type {
 	RegularAtomFamilyToken,
 } from "atom.io"
 import { atomFamily, join, mutableAtom, selectorFamily } from "atom.io"
-import { SetRTX } from "atom.io/transceivers/set-rtx"
-
-import type { Socket } from ".."
+import type { Socket } from "atom.io/realtime"
+import { UList } from "atom.io/transceivers/u-list"
 
 export type SocketKey = `socket::${string}`
 export type UserKey = `user::${string}`
@@ -29,17 +28,17 @@ export const socketAtoms: RegularAtomFamilyToken<Socket | null, SocketKey> =
 		default: null,
 	})
 
-export const socketIndex: MutableAtomToken<SetRTX<SocketKey>> = mutableAtom<
-	SetRTX<SocketKey>
+export const socketIndex: MutableAtomToken<UList<SocketKey>> = mutableAtom<
+	UList<SocketKey>
 >({
 	key: `socketsIndex`,
-	class: SetRTX,
+	class: UList,
 })
-export const userIndex: MutableAtomToken<SetRTX<UserKey>> = mutableAtom<
-	SetRTX<UserKey>
+export const userIndex: MutableAtomToken<UList<UserKey>> = mutableAtom<
+	UList<UserKey>
 >({
 	key: `usersIndex`,
-	class: SetRTX,
+	class: UList,
 })
 export const usersOfSockets: JoinToken<
 	`user`,

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

@@ -1,9 +1,9 @@
 import type * as AtomIO from "atom.io"
 import { getFromStore, IMPLICIT, subscribeToState } from "atom.io/internal"
 import type { Json } from "atom.io/json"
+import { employSocket } from "atom.io/realtime"
 
 import type { ServerConfig } from "."
-import { employSocket } from "./employ-socket"
 
 export type StateProvider = ReturnType<typeof realtimeStateProvider>
 export function realtimeStateProvider({

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

@@ -3,18 +3,15 @@ import {
 	findInStore,
 	getFromStore,
 	IMPLICIT,
+	operateOnStore,
+	OWN_OP,
 	setIntoStore,
 	subscribeToState,
 } from "atom.io/internal"
-import {
-	operateOnStore,
-	OWN_OP,
-} from "atom.io/internal/set-state/operate-on-store"
 import type { Json } from "atom.io/json"
-import { mutexAtoms } from "atom.io/realtime/mutex-store"
+import { employSocket, mutexAtoms } from "atom.io/realtime"
 
 import type { ServerConfig } from "."
-import { employSocket } from "./employ-socket"
 
 export type StateReceiver = ReturnType<typeof realtimeStateReceiver>
 export function realtimeStateReceiver({

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

@@ -1,9 +1,7 @@
 import type { RootStore } from "atom.io/internal"
-
-import type { Socket } from "./socket-interface"
+import type { Socket } from "atom.io/realtime"
 
 export type ServerConfig = {
 	socket: Socket
 	store?: RootStore
-	mutex?: Set<string>
 }

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

@@ -19,7 +19,7 @@ import * as AR from "atom.io/react"
 import * as RTC from "atom.io/realtime-client"
 import * as RTR from "atom.io/realtime-react"
 import * as RTS from "atom.io/realtime-server"
-import { SetRTX } from "atom.io/transceivers/set-rtx"
+import { UList } from "atom.io/transceivers/u-list"
 import * as Happy from "happy-dom"
 import * as React from "react"
 import * as SocketIO from "socket.io"
@@ -45,9 +45,8 @@ function prefixLogger(store: Store, prefix: string) {
 				if (param instanceof ChildProcess) {
 					params[idx] = `ChildProcess:${param.pid}`
 				}
-				if (param instanceof SetRTX) {
-					params[idx] =
-						`SetRTX(${param.size}) {${[...param].join(`, `)}} at ${param.cacheIdx}`
+				if (param instanceof UList) {
+					params[idx] = `UList(${param.size}) {${[...param].join(`, `)}}`
 				}
 				idx++
 			}
@@ -72,6 +71,7 @@ export type TestSetupOptions = {
 	server: (tools: {
 		socket: SocketIO.Socket
 		silo: AtomIO.Silo
+		userKey: RTS.UserKey
 		enableLogging: () => void
 	}) => (() => void) | void
 }
@@ -155,24 +155,25 @@ export const setupRealtimeTestServer = (
 			setIntoStore(silo.store, RTS.socketIndex, (index) =>
 				index.add(socketClaim),
 			)
-			// console.log(`${username} connected on ${socket.id}`)
 			next()
 		} else {
 			next(new Error(`Authentication error`))
 		}
 	})
 
-	const serviceDisposalFunctions: Array<() => void> = []
+	const socketServices = new Set<() => void>()
+	const disposeAllSocketServices = () => {
+		for (const disposeService of socketServices) disposeService()
+	}
 
 	server.on(`connection`, (socket: SocketIO.Socket) => {
-		let userKey: string | null = null
+		const userKeyState = findRelationsInStore(
+			RTS.usersOfSockets,
+			`socket::${socket.id}`,
+			silo.store,
+		).userKeyOfSocket
+		const userKey = getFromStore(silo.store, userKeyState)!
 		function enableLogging() {
-			const userKeyState = findRelationsInStore(
-				RTS.usersOfSockets,
-				`socket::${socket.id}`,
-				silo.store,
-			).userKeyOfSocket
-			userKey = getFromStore(silo.store, userKeyState)
 			prefixLogger(silo.store, `server`)
 			socket.onAny((event, ...args) => {
 				console.log(`🛰 `, userKey, event, ...args)
@@ -184,16 +185,20 @@ export const setupRealtimeTestServer = (
 				console.log(`${userKey} disconnected`)
 			})
 		}
-		const disposeServices = options.server({ socket, enableLogging, silo })
+		const disposeServices = options.server({
+			socket,
+			enableLogging,
+			silo,
+			userKey,
+		})
 		if (disposeServices) {
-			serviceDisposalFunctions.push(disposeServices)
+			socketServices.add(disposeServices)
+			socket.on(`disconnect`, disposeServices)
 		}
 	})
 
 	const dispose = async () => {
-		for (const disposeSocketServices of serviceDisposalFunctions) {
-			disposeSocketServices()
-		}
+		disposeAllSocketServices()
 		await server.close()
 
 		// const roomKeys = getFromStore(silo.store, RT.roomIndex)