atom.io 0.16.3 → 0.18.0

package/realtime-server/src/realtime-action-synchronizer.ts

@@ -1,52 +1,74 @@
-import * as AtomIO from "atom.io"
-import { IMPLICIT, findInStore, subscribeToTransaction } from "atom.io/internal"
+import type * as AtomIO from "atom.io"
+import {
+	IMPLICIT,
+	actUponStore,
+	assignTransactionToContinuity,
+	findInStore,
+	getFromStore,
+	setIntoStore,
+	subscribeToTransaction,
+} from "atom.io/internal"
+import type { Json, JsonIO } from "atom.io/json"
 
 import type { ServerConfig } from "."
-import { usersOfSockets } from "./realtime-server-stores"
 import {
 	completeUpdateAtoms,
 	redactedUpdateSelectors,
-	socketEpochSelectors,
-	socketUnacknowledgedUpdatesSelectors,
 	transactionRedactorAtoms,
-} from "./realtime-server-stores/server-sync-store"
+	userUnacknowledgedQueues,
+	usersOfSockets,
+} from "./realtime-server-stores"
 
 export type ActionSynchronizer = ReturnType<typeof realtimeActionSynchronizer>
 export function realtimeActionSynchronizer({
 	socket,
 	store = IMPLICIT.STORE,
 }: ServerConfig) {
-	return function actionSynchronizer<ƒ extends AtomIO.ƒn>(
+	return function actionSynchronizer<ƒ extends JsonIO>(
 		tx: AtomIO.TransactionToken<ƒ>,
 		filter?: (
 			update: AtomIO.TransactionUpdateContent[],
 		) => AtomIO.TransactionUpdateContent[],
 	): () => void {
+		assignTransactionToContinuity(`default`, tx.key, store)
+
 		const userKeyState = findInStore(
 			usersOfSockets.states.userKeyOfSocket,
 			socket.id,
 			store,
 		)
-		const userKey = AtomIO.getState(userKeyState, store)
-		const socketUnacknowledgedUpdatesState = findInStore(
-			socketUnacknowledgedUpdatesSelectors,
-			socket.id,
+		const userKey = getFromStore(userKeyState, store)
+		if (!userKey) {
+			store.logger.error(
+				`❌`,
+				`transaction`,
+				tx.key,
+				`Tried to create a synchronizer for a socket (${socket.id}) that is not connected to a user.`,
+			)
+			return () => {}
+		}
+		const userUnacknowledgedQueue = findInStore(
+			userUnacknowledgedQueues,
+			userKey,
 			store,
 		)
-		const socketUnacknowledgedUpdates = AtomIO.getState(
-			socketUnacknowledgedUpdatesState,
+		const userUnacknowledgedUpdates = getFromStore(
+			userUnacknowledgedQueue,
 			store,
 		)
 		if (filter) {
 			const redactorState = findInStore(transactionRedactorAtoms, tx.key, store)
-			AtomIO.setState(redactorState, { filter }, store)
+			setIntoStore(redactorState, { filter }, store)
 		}
-		const fillTransactionRequest = (update: AtomIO.TransactionUpdate<ƒ>) => {
+
+		const fillTransactionRequest = (
+			update: Pick<AtomIO.TransactionUpdate<ƒ>, `id` | `params`>,
+		) => {
 			const performanceKey = `tx-run:${tx.key}:${update.id}`
 			const performanceKeyStart = `${performanceKey}:start`
 			const performanceKeyEnd = `${performanceKey}:end`
 			performance.mark(performanceKeyStart)
-			AtomIO.runTransaction<ƒ>(tx, update.id, store)(...update.params)
+			actUponStore<ƒ>(tx, update.id, store)(...update.params)
 			performance.mark(performanceKeyEnd)
 			const metric = performance.measure(
 				performanceKey,
@@ -64,9 +86,12 @@ export function realtimeActionSynchronizer({
 				tx,
 				(update) => {
 					const updateState = findInStore(completeUpdateAtoms, update.id, store)
-					AtomIO.setState(updateState, update, store)
-					const toEmit = filter
-						? AtomIO.getState(
+					setIntoStore(updateState, update, store)
+					const toEmit: Pick<
+						AtomIO.TransactionUpdate<ƒ>,
+						`epoch` | `id` | `key` | `output` | `updates`
+					> | null = filter
+						? getFromStore(
 								findInStore(redactedUpdateSelectors, [tx.key, update.id], store),
 								store,
 						  )
@@ -76,8 +101,8 @@ export function realtimeActionSynchronizer({
 					// updates be set in the queue for that socket's client.
 					//
 					// we need a client session that can persist between disconnects
-					AtomIO.setState(
-						socketUnacknowledgedUpdatesState,
+					setIntoStore(
+						userUnacknowledgedQueue,
 						(updates) => {
 							if (toEmit) {
 								updates.push(toEmit)
@@ -88,7 +113,7 @@ export function realtimeActionSynchronizer({
 						store,
 					)
 
-					socket.emit(`tx-new:${tx.key}`, toEmit)
+					socket.emit(`tx-new:${tx.key}`, toEmit as Json.Serializable)
 				},
 				`tx-sub:${tx.key}:${socket.id}`,
 				store,
@@ -100,10 +125,9 @@ export function realtimeActionSynchronizer({
 		let i = 1
 		let next = 1
 		const retry = setInterval(() => {
-			const toEmit = socketUnacknowledgedUpdates[0]
-			console.log(userKey, socketUnacknowledgedUpdates)
+			const toEmit = userUnacknowledgedUpdates[0]
 			if (toEmit && i === next) {
-				socket.emit(`tx-new:${tx.key}`, toEmit)
+				socket.emit(`tx-new:${tx.key}`, toEmit as Json.Serializable)
 				next *= 2
 			}
 
@@ -113,16 +137,10 @@ export function realtimeActionSynchronizer({
 		const trackClientAcknowledgement = (epoch: number) => {
 			i = 1
 			next = 1
-			const socketEpochState = findInStore(
-				socketEpochSelectors,
-				socket.id,
-				store,
-			)
-
-			AtomIO.setState(socketEpochState, epoch, store)
-			if (socketUnacknowledgedUpdates[0]?.epoch === epoch) {
-				AtomIO.setState(
-					socketUnacknowledgedUpdatesState,
+			8
+			if (userUnacknowledgedUpdates[0]?.epoch === epoch) {
+				setIntoStore(
+					userUnacknowledgedQueue,
 					(updates) => {
 						updates.shift()
 						return updates

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

@@ -0,0 +1,247 @@
+import type * as AtomIO from "atom.io"
+import {
+	IMPLICIT,
+	actUponStore,
+	findInStore,
+	getFromStore,
+	isRootStore,
+	setIntoStore,
+	subscribeToState,
+	subscribeToTransaction,
+} from "atom.io/internal"
+import type { Json, JsonIO } from "atom.io/json"
+import type { ContinuityToken } from "atom.io/realtime"
+
+import type { ServerConfig, Socket } from "."
+import { socketAtoms, usersOfSockets } from "."
+import { redactedPerspectiveUpdateSelectors } from "./realtime-server-stores"
+import {
+	completeUpdateAtoms,
+	userUnacknowledgedQueues,
+} from "./realtime-server-stores"
+
+export type RealtimeContinuitySynchronizer = ReturnType<
+	typeof realtimeContinuitySynchronizer
+>
+export function realtimeContinuitySynchronizer({
+	socket: initialSocket,
+	store = IMPLICIT.STORE,
+}: ServerConfig) {
+	return function synchronizer(continuity: ContinuityToken): () => void {
+		let socket: Socket | null = initialSocket
+
+		const continuityKey = continuity.key
+		const userKeyState = findInStore(
+			usersOfSockets.states.userKeyOfSocket,
+			socket.id,
+			store,
+		)
+		const userKey = getFromStore(userKeyState, store)
+		if (!userKey) {
+			store.logger.error(
+				`❌`,
+				`continuity`,
+				continuityKey,
+				`Tried to create a synchronizer for a socket (${socket.id}) that is not connected to a user.`,
+			)
+			return () => {}
+		}
+		const socketKeyState = findInStore(
+			usersOfSockets.states.socketKeyOfUser,
+			userKey,
+			store,
+		)
+		subscribeToState(
+			socketKeyState,
+			({ newValue: newSocketKey }) => {
+				store.logger.info(
+					`👋`,
+					`continuity`,
+					continuityKey,
+					`seeing ${userKey} on new socket ${newSocketKey}`,
+				)
+				if (newSocketKey === null) {
+					store.logger.error(
+						`❌`,
+						`continuity`,
+						continuityKey,
+						`Tried to create a synchronizer for a user (${userKey}) that is not connected to a socket.`,
+					)
+					return
+				}
+				const newSocketState = findInStore(socketAtoms, newSocketKey, store)
+				const newSocket = getFromStore(newSocketState, store)
+				socket = newSocket
+			},
+			`sync-continuity:${continuityKey}:${userKey}`,
+			store,
+		)
+
+		const userUnacknowledgedQueue = findInStore(
+			userUnacknowledgedQueues,
+			userKey,
+			store,
+		)
+		const userUnacknowledgedUpdates = getFromStore(
+			userUnacknowledgedQueue,
+			store,
+		)
+		const unsubscribeFunctions: (() => void)[] = []
+
+		const sendInitialPayload = () => {
+			const initialPayload: Json.Serializable[] = []
+			for (const atom of continuity.globals) {
+				initialPayload.push(atom, getFromStore(atom, store))
+			}
+			for (const { perspectiveAtoms } of continuity.perspectives) {
+				const perspectiveTokensState = findInStore(
+					perspectiveAtoms,
+					userKey,
+					store,
+				)
+				const perspectiveTokens = getFromStore(perspectiveTokensState, store)
+				for (const perspectiveToken of perspectiveTokens) {
+					const resource = getFromStore(perspectiveToken, store)
+					initialPayload.push(perspectiveToken, resource)
+				}
+			}
+
+			const epoch = isRootStore(store)
+				? store.transactionMeta.epoch.get(continuityKey) ?? null
+				: null
+			socket?.emit(`continuity-init:${continuityKey}`, epoch, initialPayload)
+
+			for (const transaction of continuity.actions) {
+				const unsubscribeFromTransaction = subscribeToTransaction(
+					transaction,
+					(update) => {
+						// store.logger.info(`userId`, userKey)
+						const updateState = findInStore(
+							completeUpdateAtoms,
+							update.id,
+							store,
+						)
+						setIntoStore(updateState, update, store)
+						const redactedUpdateKey = {
+							userId: userKey,
+							syncGroupKey: continuityKey,
+							updateId: update.id,
+						}
+						const redactedUpdateState = findInStore(
+							redactedPerspectiveUpdateSelectors,
+							redactedUpdateKey,
+							store,
+						)
+
+						const redactedUpdate = getFromStore(redactedUpdateState, store)
+
+						setIntoStore(
+							userUnacknowledgedQueue,
+							(updates) => {
+								if (redactedUpdate) {
+									updates.push(redactedUpdate)
+									updates.sort((a, b) => a.epoch - b.epoch)
+								}
+								return updates
+							},
+							store,
+						)
+
+						socket?.emit(
+							`tx-new:${continuityKey}`,
+							redactedUpdate as Json.Serializable,
+						)
+					},
+					`sync-continuity:${continuityKey}:${userKey}`,
+					store,
+				)
+				unsubscribeFunctions.push(unsubscribeFromTransaction)
+			}
+		}
+		socket.off(`get:${continuityKey}`, sendInitialPayload)
+		socket.on(`get:${continuityKey}`, sendInitialPayload)
+
+		const fillTransactionRequest = (
+			update: Pick<AtomIO.TransactionUpdate<JsonIO>, `id` | `key` | `params`>,
+		) => {
+			const transactionKey = update.key
+			const updateId = update.id
+			const performanceKey = `tx-run:${transactionKey}:${updateId}`
+			const performanceKeyStart = `${performanceKey}:start`
+			const performanceKeyEnd = `${performanceKey}:end`
+			performance.mark(performanceKeyStart)
+			actUponStore(
+				{ type: `transaction`, key: transactionKey },
+				updateId,
+				store,
+			)(...update.params)
+			performance.mark(performanceKeyEnd)
+			const metric = performance.measure(
+				performanceKey,
+				performanceKeyStart,
+				performanceKeyEnd,
+			)
+			store?.logger.info(
+				`🚀`,
+				`transaction`,
+				transactionKey,
+				updateId,
+				metric.duration,
+			)
+		}
+		socket.off(`tx-run:${continuityKey}`, fillTransactionRequest)
+		socket.on(`tx-run:${continuityKey}`, fillTransactionRequest)
+
+		let i = 1
+		let next = 1
+		const retry = setInterval(() => {
+			const toEmit = userUnacknowledgedUpdates[0]
+			store.logger.info(
+				`🔄`,
+				`continuity`,
+				continuityKey,
+				`${store.config.name} retrying ${userKey} (${i}/${next})`,
+				socket?.id,
+				userUnacknowledgedUpdates,
+			)
+			if (toEmit && i === next) {
+				socket?.emit(`tx-new:${continuityKey}`, toEmit as Json.Serializable)
+				next *= 2
+			}
+
+			i++
+		}, 250)
+		const trackClientAcknowledgement = (epoch: number) => {
+			store.logger.info(
+				`👍`,
+				`continuity`,
+				continuityKey,
+				`${userKey} acknowledged epoch ${epoch}`,
+			)
+			i = 1
+			next = 1
+			const isUnacknowledged = userUnacknowledgedUpdates[0]?.epoch === epoch
+
+			if (isUnacknowledged) {
+				setIntoStore(
+					userUnacknowledgedQueue,
+					(updates) => {
+						updates.shift()
+						return updates
+					},
+					store,
+				)
+			}
+		}
+		socket.off(`ack:${continuityKey}`, trackClientAcknowledgement)
+		socket.on(`ack:${continuityKey}`, trackClientAcknowledgement)
+
+		return () => {
+			clearInterval(retry)
+			for (const unsubscribe of unsubscribeFunctions) unsubscribe()
+			socket?.off(`ack:${continuityKey}`, trackClientAcknowledgement)
+			socket?.off(`get:${continuityKey}`, sendInitialPayload)
+			socket?.off(`tx-run:${continuityKey}`, fillTransactionRequest)
+		}
+	}
+}

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

@@ -1,12 +1,16 @@
-import * as AtomIO from "atom.io"
-import { IMPLICIT, findInStore, subscribeToState } from "atom.io/internal"
-import type { Json } from "atom.io/json"
-import { parseJson } from "atom.io/json"
+import type * as AtomIO from "atom.io"
+import {
+	IMPLICIT,
+	findInStore,
+	getFromStore,
+	subscribeToState,
+} from "atom.io/internal"
+import { type Json, stringifyJson } from "atom.io/json"
 
 import type { ServerConfig } from "."
 
-export type FamilyProvider = ReturnType<typeof realtimeFamilyProvider>
-export function realtimeFamilyProvider({
+export type FamilyProvider = ReturnType<typeof realtimeAtomFamilyProvider>
+export function realtimeAtomFamilyProvider({
 	socket,
 	store = IMPLICIT.STORE,
 }: ServerConfig) {
@@ -14,77 +18,40 @@ export function realtimeFamilyProvider({
 		J extends Json.Serializable,
 		K extends Json.Serializable,
 	>(
-		family: AtomIO.RegularAtomFamily<J, K>,
+		family: AtomIO.RegularAtomFamilyToken<J, K>,
 		index: AtomIO.ReadableToken<Iterable<K>>,
 	): () => void {
-		const unsubSingleCallbacksByKey = new Map<string, () => void>()
-		const unsubFamilyCallbacksByKey = new Map<string, () => void>()
+		const unsubCallbacksByKey = new Map<string, () => void>()
 
-		const fillFamilyUnsubRequest = () => {
-			for (const [, unsub] of unsubFamilyCallbacksByKey) {
-				unsub()
-			}
-			unsubFamilyCallbacksByKey.clear()
-			socket.off(`unsub:${family.key}`, fillFamilyUnsubRequest)
-		}
-
-		const fillSingleUnsubRequest = (key: string) => {
-			socket.off(`unsub:${key}`, fillSingleUnsubRequest)
-			const unsub = unsubSingleCallbacksByKey.get(key)
+		const fillUnsubRequest = (key: string) => {
+			socket.off(`unsub:${key}`, fillUnsubRequest)
+			const unsub = unsubCallbacksByKey.get(key)
 			if (unsub) {
 				unsub()
-				unsubSingleCallbacksByKey.delete(key)
+				unsubCallbacksByKey.delete(key)
 			}
 		}
 
-		const fillSubRequest = (subKey?: K) => {
-			if (subKey === undefined) {
-				const keys = AtomIO.getState(index, store)
-				for (const key of keys) {
-					const token = findInStore(family, key, store)
-					socket.emit(
-						`serve:${family.key}`,
-						parseJson(token.family?.subKey || `null`),
-						AtomIO.getState(token, store),
+		const fillSubRequest = (subKey: K) => {
+			const exposedSubKeys = getFromStore(index, store)
+			for (const exposedSubKey of exposedSubKeys) {
+				if (stringifyJson(exposedSubKey) === stringifyJson(subKey)) {
+					const token = findInStore(family, subKey, store)
+					socket.emit(`serve:${token.key}`, getFromStore(token, store))
+					const unsubscribe = subscribeToState(
+						token,
+						({ newValue }) => {
+							socket.emit(`serve:${token.key}`, newValue)
+						},
+						`expose-family:${family.key}:${socket.id}`,
+						store,
 					)
+					unsubCallbacksByKey.set(token.key, unsubscribe)
+					socket.on(`unsub:${token.key}`, () => {
+						fillUnsubRequest(token.key)
+					})
+					break
 				}
-
-				const unsubscribeFromTokenCreation = family.subject.subscribe(
-					`expose-family:${socket.id}`,
-					(token: AtomIO.WritableToken<J>) => {
-						const unsub = subscribeToState(
-							token,
-							({ newValue }) => {
-								socket.emit(
-									`serve:${family.key}`,
-									parseJson(token.family?.subKey || `null`),
-									newValue,
-								)
-							},
-							`expose-family:${family.key}:${socket.id}`,
-							store,
-						)
-						unsubFamilyCallbacksByKey.set(token.key, unsub)
-					},
-				)
-				unsubFamilyCallbacksByKey.set(family.key, unsubscribeFromTokenCreation)
-
-				socket.on(`unsub:${family.key}`, fillFamilyUnsubRequest)
-			} else {
-				const token = family(subKey)
-				socket.emit(`serve:${token.key}`, AtomIO.getState(token, store))
-				const unsubscribe = subscribeToState(
-					token,
-					({ newValue }) => {
-						socket.emit(`serve:${token.key}`, newValue)
-					},
-					`expose-family:${family.key}:${socket.id}`,
-					store,
-				)
-				unsubSingleCallbacksByKey.set(token.key, unsubscribe)
-				socket.on(`unsub:${token.key}`, () => {
-					fillSingleUnsubRequest(token.key)
-				})
 			}
 		}
 
@@ -92,14 +59,11 @@ export function realtimeFamilyProvider({
 
 		return () => {
 			socket.off(`sub:${family.key}`, fillSubRequest)
-			for (const [, unsub] of unsubFamilyCallbacksByKey) {
-				unsub()
-			}
-			for (const [, unsub] of unsubSingleCallbacksByKey) {
+
+			for (const [, unsub] of unsubCallbacksByKey) {
 				unsub()
 			}
-			unsubFamilyCallbacksByKey.clear()
-			unsubSingleCallbacksByKey.clear()
+			unsubCallbacksByKey.clear()
 		}
 	}
 }

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

@@ -1,14 +1,15 @@
-import * as AtomIO from "atom.io"
+import type * as AtomIO from "atom.io"
 import type { Transceiver } from "atom.io/internal"
 import {
 	IMPLICIT,
 	findInStore,
+	getFromStore,
 	getJsonToken,
 	getUpdateToken,
 	subscribeToState,
 } from "atom.io/internal"
 import type { Json } from "atom.io/json"
-import { parseJson } from "atom.io/json"
+import { stringifyJson } from "atom.io/json"
 
 import type { ServerConfig } from "."
 
@@ -24,100 +25,42 @@ export function realtimeMutableFamilyProvider({
 		J extends Json.Serializable,
 		K extends Json.Serializable,
 	>(
-		family: AtomIO.MutableAtomFamily<T, J, K>,
+		family: AtomIO.MutableAtomFamilyToken<T, J, K>,
 		index: AtomIO.ReadableToken<Iterable<K>>,
 	): () => void {
-		const unsubSingleCallbacksByKey = new Map<string, () => void>()
-		const unsubFamilyCallbacksByKey = new Map<string, () => void>()
+		const unsubCallbacksByKey = new Map<string, () => void>()
 
-		const fillFamilyUnsubRequest = () => {
-			for (const [, unsub] of unsubFamilyCallbacksByKey) {
-				unsub()
-			}
-			unsubFamilyCallbacksByKey.clear()
-			socket.off(`unsub:${family.key}`, fillFamilyUnsubRequest)
-		}
-
-		const fillSingleUnsubRequest = (key: string) => {
-			socket.off(`unsub:${key}`, fillSingleUnsubRequest)
-			const unsub = unsubSingleCallbacksByKey.get(key)
+		const fillUnsubRequest = (key: string) => {
+			socket.off(`unsub:${key}`, fillUnsubRequest)
+			const unsub = unsubCallbacksByKey.get(key)
 			if (unsub) {
 				unsub()
-				unsubSingleCallbacksByKey.delete(key)
+				unsubCallbacksByKey.delete(key)
 			}
 		}
 
-		const fillSubRequest = (subKey?: K) => {
-			if (subKey === undefined) {
-				const keys = AtomIO.getState(index, store)
-				for (const key of keys) {
-					const token = findInStore(family, key, store)
+		const fillSubRequest = (subKey: K) => {
+			const exposedSubKeys = getFromStore(index, store)
+			for (const exposedSubKey of exposedSubKeys) {
+				if (stringifyJson(exposedSubKey) === stringifyJson(subKey)) {
+					const token = findInStore(family, subKey, store)
 					const jsonToken = getJsonToken(token)
-					const trackerToken = getUpdateToken(token)
-					socket.emit(
-						`init:${family.key}`,
-						parseJson(jsonToken.family?.subKey || `null`),
-						AtomIO.getState(jsonToken, store),
-					)
-					const unsubFromUpdates = subscribeToState(
-						trackerToken,
+					const updateToken = getUpdateToken(token)
+					socket.emit(`init:${token.key}`, getFromStore(jsonToken, store))
+					const unsubscribe = subscribeToState(
+						updateToken,
 						({ newValue }) => {
-							socket.emit(
-								`next:${token.key}`,
-								parseJson(jsonToken.family?.subKey || `null`),
-								newValue,
-							)
+							socket.emit(`next:${token.key}`, newValue)
 						},
 						`expose-family:${family.key}:${socket.id}`,
 						store,
 					)
-					unsubFamilyCallbacksByKey.set(token.key, unsubFromUpdates)
+					unsubCallbacksByKey.set(token.key, unsubscribe)
+					socket.on(`unsub:${token.key}`, () => {
+						fillUnsubRequest(token.key)
+					})
+					break
 				}
-				const unsubscribeFromTokenCreation = family.subject.subscribe(
-					`expose-family:${socket.id}`,
-					(token) => {
-						const jsonToken = getJsonToken(token)
-						const trackerToken = getUpdateToken(token)
-						socket.emit(
-							`init:${family.key}`,
-							parseJson(jsonToken.family?.subKey || `null`),
-							AtomIO.getState(jsonToken, store),
-						)
-						const unsubFromUpdates = subscribeToState(
-							trackerToken,
-							({ newValue }) => {
-								socket.emit(
-									`next:${token.key}`,
-									parseJson(jsonToken.family?.subKey || `null`),
-									newValue,
-								)
-							},
-							`expose-family:${family.key}:${socket.id}`,
-							store,
-						)
-						unsubFamilyCallbacksByKey.set(token.key, unsubFromUpdates)
-					},
-				)
-				unsubFamilyCallbacksByKey.set(family.key, unsubscribeFromTokenCreation)
-
-				socket.on(`unsub:${family.key}`, fillFamilyUnsubRequest)
-			} else {
-				const token = family(subKey)
-				const jsonToken = getJsonToken(token)
-				const updateToken = getUpdateToken(token)
-				socket.emit(`init:${token.key}`, AtomIO.getState(jsonToken, store))
-				const unsubscribe = subscribeToState(
-					updateToken,
-					({ newValue }) => {
-						socket.emit(`next:${token.key}`, newValue)
-					},
-					`expose-family:${family.key}:${socket.id}`,
-					store,
-				)
-				unsubSingleCallbacksByKey.set(token.key, unsubscribe)
-				socket.on(`unsub:${token.key}`, () => {
-					fillSingleUnsubRequest(token.key)
-				})
 			}
 		}
 
@@ -125,14 +68,10 @@ export function realtimeMutableFamilyProvider({
 
 		return () => {
 			socket.off(`sub:${family.key}`, fillSubRequest)
-			for (const [, unsub] of unsubFamilyCallbacksByKey) {
-				unsub()
-			}
-			for (const [, unsub] of unsubSingleCallbacksByKey) {
+			for (const [, unsub] of unsubCallbacksByKey) {
 				unsub()
 			}
-			unsubFamilyCallbacksByKey.clear()
-			unsubSingleCallbacksByKey.clear()
+			unsubCallbacksByKey.clear()
 		}
 	}
 }