atom.io 0.40.6 → 0.40.8

package/src/internal/subscribe/recall-state.ts

@@ -1,5 +1,5 @@
-import type { ReadableState } from ".."
 import { newest } from "../lineage"
+import type { ReadableState } from "../state-types"
 import type { Store } from "../store"
 
 export const recallState = <T, E>(

package/src/internal/subscribe/subscribe-to-root-atoms.ts

@@ -1,5 +1,5 @@
-import type { Atom, Selector } from ".."
 import { readOrComputeValue } from "../get-state/read-or-compute-value"
+import type { Atom, Selector } from "../state-types"
 import type { Store } from "../store"
 import { recallState } from "./recall-state"
 
@@ -37,14 +37,3 @@ export const subscribeToRootDependency = (
 		},
 	)
 }
-
-// export const subscribeToRootAtoms = (
-// 	store: Store,
-// 	selector: Selector<any>,
-// ): (() => void)[] => {
-// 	const target = newest(store)
-// 	const dependencySubscriptions = traceAllSelectorAtoms(selector, store).map(
-// 		(atom) => subscribeToRootDependency(target, selector, atom),
-// 	)
-// 	return dependencySubscriptions
-// }

package/src/internal/subscribe/subscribe-to-state.ts

@@ -1,5 +1,6 @@
 import type { ReadableToken, StateUpdate, UpdateHandler } from "atom.io"
 
+import { hasRole } from "../atom"
 import { readOrComputeValue } from "../get-state"
 import { reduceReference } from "../get-state/reduce-reference"
 import { traceRootSelectorAtoms } from "../selector"
@@ -15,6 +16,14 @@ export function subscribeToState<T, E>(
 ): () => void {
 	function safelyHandleUpdate(update: StateUpdate<any>): void {
 		if (store.operation.open) {
+			if (
+				state?.type === `atom` &&
+				hasRole(state, `tracker:signal`) &&
+				`*` + store.operation.token.key === token.key &&
+				`inboundTracker` in handleUpdate
+			) {
+				return
+			}
 			const unsubscribe = store.on.operationClose.subscribe(
 				`state subscription ${key}`,
 				() => {

package/src/internal/subscribe/subscribe-to-transaction.ts

@@ -1,7 +1,8 @@
 import type { TransactionToken, TransactionUpdateHandler } from "atom.io"
 
-import type { Fn, Store } from ".."
-import { withdraw } from ".."
+import type { Store } from "../store"
+import { withdraw } from "../store"
+import type { Fn } from "../utility-types"
 
 export const subscribeToTransaction = <F extends Fn>(
 	store: Store,

package/src/internal/transaction/build-transaction.ts

@@ -16,9 +16,10 @@ import { getJsonToken } from "../mutable"
 import { MapOverlay } from "../overlays/map-overlay"
 import { resetInStore, setIntoStore } from "../set-state"
 import type { Fn } from "../utility-types"
-import type { TransactionProgress } from "."
-import { actUponStore, getEpochNumberOfAction } from "."
+import { actUponStore } from "./act-upon-store"
+import { getEpochNumberOfAction } from "./get-epoch-number"
 import type { ChildStore, RootStore } from "./is-root-store"
+import type { TransactionProgress } from "./transaction-meta-progress"
 
 export const buildTransaction = (
 	store: RootStore,

package/src/internal/transaction/index.ts

@@ -1,12 +1,3 @@
-import type {
-	ActorToolkit,
-	TransactionOutcomeEvent,
-	TransactionToken,
-} from "atom.io"
-
-import type { Junction } from "../junction"
-import type { Fn } from "../utility-types"
-
 export * from "./abort-transaction"
 export * from "./act-upon-store"
 export * from "./apply-transaction"
@@ -16,17 +7,4 @@ export * from "./create-transaction"
 export * from "./get-epoch-number"
 export * from "./is-root-store"
 export * from "./set-epoch-number"
-
-export const TRANSACTION_PHASES = [`idle`, `building`, `applying`] as const
-export type TransactionPhase = (typeof TRANSACTION_PHASES)[number]
-
-export type TransactionProgress<F extends Fn> = {
-	phase: `applying` | `building`
-	update: TransactionOutcomeEvent<TransactionToken<F>>
-	toolkit: ActorToolkit
-}
-
-export type TransactionEpoch = {
-	epoch: Map<string, number>
-	actionContinuities: Junction<`continuity`, string, `action`, string>
-}
+export * from "./transaction-meta-progress"

package/src/internal/transaction/is-root-store.ts

@@ -1,7 +1,10 @@
 import type { MapOverlay } from "../overlays/map-overlay"
 import type { Store } from "../store"
 import type { Fn } from "../utility-types"
-import type { TransactionEpoch, TransactionProgress } from "."
+import type {
+	TransactionEpoch,
+	TransactionProgress,
+} from "./transaction-meta-progress"
 
 export interface RootStore extends Store {
 	transactionMeta: TransactionEpoch

package/src/internal/transaction/transaction-meta-progress.ts

@@ -0,0 +1,22 @@
+import type {
+	ActorToolkit,
+	TransactionOutcomeEvent,
+	TransactionToken,
+} from "atom.io"
+
+import type { Junction } from "../junction"
+import type { Fn } from "../utility-types"
+
+export const TRANSACTION_PHASES = [`idle`, `building`, `applying`] as const
+export type TransactionPhase = (typeof TRANSACTION_PHASES)[number]
+
+export type TransactionProgress<F extends Fn> = {
+	phase: `applying` | `building`
+	update: TransactionOutcomeEvent<TransactionToken<F>>
+	toolkit: ActorToolkit
+}
+
+export type TransactionEpoch = {
+	epoch: Map<string, number>
+	actionContinuities: Junction<`continuity`, string, `action`, string>
+}

package/src/main/atom.ts

@@ -9,7 +9,6 @@ import {
 import type { Canonical } from "atom.io/json"
 
 import type { StateUpdate } from "./events"
-import type { Setter } from "./set-state"
 import type {
 	MutableAtomFamilyToken,
 	MutableAtomToken,
@@ -78,7 +77,7 @@ export type Effectors<T> = {
 	 * Set the value of the atom
 	 * @param next - The new value of the atom, or a setter function
 	 */
-	setSelf: <New extends T>(next: New | Setter<T, New>) => void
+	setSelf: <New extends T>(next: New | ((old: T) => New)) => void
 	/** Subscribe to changes to the atom */
 	onSet: (callback: (options: StateUpdate<T>) => void) => void
 }

package/src/main/find-state.ts

@@ -50,7 +50,7 @@ export function findState<
 export function findState<T, K extends Canonical, Key extends K>(
 	token: RegularAtomFamilyToken<T, K>,
 	key: Key,
-): RegularAtomToken<T, K>
+): RegularAtomToken<T, Key>
 /**
  * Finds a {@link WritableSelectorToken} in the store, without accessing its value.
  *
@@ -67,7 +67,7 @@ export function findState<T, K extends Canonical, Key extends K>(
 export function findState<T, K extends Canonical, Key extends K>(
 	token: WritableSelectorFamilyToken<T, K>,
 	key: Key,
-): WritableSelectorToken<T, K>
+): WritableSelectorToken<T, Key>
 /**
  * Finds a {@link ReadonlySelectorToken} in the store, without accessing its value.
  *
@@ -84,7 +84,7 @@ export function findState<T, K extends Canonical, Key extends K>(
 export function findState<T, K extends Canonical, Key extends K>(
 	token: ReadonlySelectorFamilyToken<T, K>,
 	key: Key,
-): ReadonlySelectorToken<T, K>
+): ReadonlySelectorToken<T, Key>
 /**
  * Finds a {@link WritableToken} in the store, without accessing its value.
  *
@@ -101,7 +101,7 @@ export function findState<T, K extends Canonical, Key extends K>(
 export function findState<T, K extends Canonical, Key extends K>(
 	token: WritableFamilyToken<T, K>,
 	key: Key,
-): WritableToken<T, K>
+): WritableToken<T, Key>
 /**
  * Finds a {@link MutableAtomToken} in the store, without accessing its value.
  *
@@ -119,7 +119,7 @@ export function findState<T, K extends Canonical, Key extends K>(
 export function findState<T, K extends Canonical, Key extends K>(
 	token: ReadableFamilyToken<T, K>,
 	key: Key,
-): ReadableToken<T, K>
+): ReadableToken<T, Key>
 
 export function findState(
 	token: ReadableFamilyToken<any, any>,

package/src/main/get-state.ts

@@ -22,14 +22,14 @@ export function getState<T, E = never>(
  * @return The current value of the state
  * @overload Streamlined
  */
-export function getState<T, K extends Canonical, Key extends K, E = never>(
+export function getState<T, K extends Canonical, E = never>(
 	token: ReadableFamilyToken<T, K, E>,
-	key: Key,
+	key: NoInfer<K>,
 ): ViewOf<E | T>
 
-export function getState<T, K extends Canonical, Key extends K, E = never>(
+export function getState<T, K extends Canonical, E = never>(
 	...params:
-		| [token: ReadableFamilyToken<T, K, E>, key: Key]
+		| [token: ReadableFamilyToken<T, K, E>, key: NoInfer<K>]
 		| [token: ReadableToken<T, any, E>]
 ): ViewOf<E | T> {
 	return getFromStore(IMPLICIT.STORE, ...params)

package/src/main/realm.ts

@@ -34,7 +34,7 @@ export class Realm<H extends Hierarchy> {
 		this.store = store
 		this.deallocateTX = createDeallocateTX(store)
 		this.claimTX = createClaimTX(store)
-		makeRootMoleculeInStore(`root`, store)
+		makeRootMoleculeInStore(store, `root`)
 	}
 	/**
 	 * Make space for a new subject of the realm
@@ -117,7 +117,7 @@ export class Anarchy {
 		this.store = store
 		this.deallocateTX = createDeallocateTX(store)
 		this.claimTX = createClaimTX(store)
-		makeRootMoleculeInStore(`root`, store)
+		makeRootMoleculeInStore(store, `root`)
 	}
 	/**
 	 * Declare a new entity

package/src/main/set-state.ts

@@ -9,7 +9,7 @@ import type { WritableFamilyToken, WritableToken } from "./tokens"
  * @returns
  * The new value of the state.
  */
-export type Setter<T, New extends T> = (oldValue: T) => New
+export type Setter<T> = (oldValue: T) => T
 
 /**
  * Set the value of a state into the implicit store.
@@ -18,9 +18,9 @@ export type Setter<T, New extends T> = (oldValue: T) => New
  * @overload Default
  * @default
  */
-export function setState<T, New extends T>(
+export function setState<T, TT extends T>(
 	token: WritableToken<T, any, any>,
-	value: New | Setter<T, New>,
+	value: Setter<TT> | TT,
 ): void
 
 /**
@@ -30,20 +30,20 @@ export function setState<T, New extends T>(
  * @param value - The new value of the state.
  * @overload Streamlined
  */
-export function setState<T, K extends Canonical, New extends T, Key extends K>(
+export function setState<T, TT extends T, K extends Canonical>(
 	token: WritableFamilyToken<T, K, any>,
-	key: Key,
-	value: New | Setter<T, New>,
+	key: NoInfer<K>,
+	value: Setter<TT> | TT,
 ): void
 
-export function setState<T, K extends Canonical, New extends T, Key extends K>(
+export function setState<T, TT extends T, K extends Canonical>(
 	...params:
 		| [
 				token: WritableFamilyToken<T, K, any>,
-				key: Key,
-				value: New | Setter<T, New>,
+				key: NoInfer<K>,
+				value: Setter<TT> | TT,
 		  ]
-		| [token: WritableToken<T, any, any>, value: New | Setter<T, New>]
+		| [token: WritableToken<T, any, any>, value: Setter<TT> | TT]
 ): void {
 	setIntoStore(IMPLICIT.STORE, ...params)
 }

package/src/react/parse-state-overloads.ts

@@ -11,17 +11,17 @@ import type { Canonical } from "atom.io/json"
 export function parseStateOverloads<T, K extends Canonical, Key extends K, E>(
 	store: Store,
 	...rest: [WritableFamilyToken<T, K, E>, Key] | [WritableToken<T, any, E>]
-): WritableToken<T, K, E>
+): WritableToken<T, Key, E>
 
 export function parseStateOverloads<T, K extends Canonical, Key extends K, E>(
 	store: Store,
 	...rest: [ReadableFamilyToken<T, K, E>, Key] | [ReadableToken<T, any, E>]
-): ReadableToken<T, K, E>
+): ReadableToken<T, Key, E>
 
 export function parseStateOverloads<T, K extends Canonical, Key extends K, E>(
 	store: Store,
 	...rest: [ReadableFamilyToken<T, K, E>, Key] | [ReadableToken<T, any, E>]
-): ReadableToken<T, K, E> {
+): ReadableToken<T, Key, E> {
 	let token: ReadableToken<any, any, any>
 	if (rest.length === 2) {
 		const family = rest[0]

package/src/react/use-i.ts

@@ -10,13 +10,15 @@ export function useI<T>(
 	token: WritableToken<T, any, any>,
 ): <New extends T>(next: New | ((old: T) => New)) => void
 
-export function useI<T, K extends Canonical, Key extends K>(
+export function useI<T, K extends Canonical>(
 	token: WritableFamilyToken<T, K, any>,
-	key: Key,
+	key: NoInfer<K>,
 ): <New extends T>(next: New | ((old: T) => New)) => void
 
-export function useI<T, K extends Canonical, Key extends K>(
-	...params: [WritableFamilyToken<T, K, any>, Key] | [WritableToken<T, any, any>]
+export function useI<T, K extends Canonical>(
+	...params:
+		| [WritableFamilyToken<T, K, any>, NoInfer<K>]
+		| [WritableToken<T, any, any>]
 ): <New extends T>(next: New | ((old: T) => New)) => void {
 	const store = React.useContext(StoreContext)
 	const token = parseStateOverloads(store, ...params)

package/src/react/use-loadable.ts

@@ -9,9 +9,9 @@ export function useLoadable<T, E>(
 	token: ReadableToken<Loadable<T>, any, E>,
 ): `LOADING` | { loading: boolean; value: E | T }
 
-export function useLoadable<T, K extends Canonical, Key extends K, E>(
+export function useLoadable<T, K extends Canonical, E>(
 	token: ReadableFamilyToken<Loadable<T>, K, E>,
-	key: Key,
+	key: NoInfer<K>,
 ): `LOADING` | { loading: boolean; value: E | T }
 
 export function useLoadable<T, F extends T, E>(
@@ -19,15 +19,9 @@ export function useLoadable<T, F extends T, E>(
 	fallback: F,
 ): { loading: boolean; value: T; error?: E }
 
-export function useLoadable<
-	T,
-	K extends Canonical,
-	F extends T,
-	Key extends K,
-	E,
->(
+export function useLoadable<T, K extends Canonical, F extends T, E>(
 	token: ReadableFamilyToken<Loadable<T>, K, E>,
-	key: Key,
+	key: NoInfer<K>,
 	fallback: F,
 ): { loading: boolean; value: T; error?: E }
 

package/src/react/use-o.ts

@@ -8,13 +8,15 @@ import { StoreContext } from "./store-context"
 
 export function useO<T, E>(token: ReadableToken<T, any, E>): E | T
 
-export function useO<T, K extends Canonical, Key extends K, E>(
+export function useO<T, K extends Canonical, E>(
 	token: ReadableFamilyToken<T, K, E>,
-	key: Key,
+	key: NoInfer<K>,
 ): E | T
 
-export function useO<T, K extends Canonical, Key extends K, E>(
-	...params: [ReadableFamilyToken<T, K, E>, Key] | [ReadableToken<T, any, E>]
+export function useO<T, K extends Canonical, E>(
+	...params:
+		| [ReadableFamilyToken<T, K, E>, NoInfer<K>]
+		| [ReadableToken<T, any, E>]
 ): E | T {
 	const store = React.useContext(StoreContext)
 	const token = parseStateOverloads(store, ...params)

package/src/react-devtools/store.ts

@@ -16,7 +16,7 @@ import type {
 	WritableTokenIndex,
 } from "atom.io/introspection"
 import { attachIntrospectionStates, isPlainObject } from "atom.io/introspection"
-import { persistSync } from "atom.io/web"
+import { storageSync } from "atom.io/web"
 import type { Context } from "react"
 import { createContext } from "react"
 
@@ -48,7 +48,7 @@ export function attachDevtoolsStates(
 				typeof window === `undefined`
 					? []
 					: [
-							persistSync(window.localStorage, JSON, `🔍 Devtools Are Hidden`),
+							storageSync(window.localStorage, JSON, `🔍 Devtools Are Hidden`),
 							({ setSelf }) => {
 								window.addEventListener(`keydown`, (e) => {
 									if (e.ctrlKey && e.shiftKey && e.key.toLowerCase() === `a`) {
@@ -70,7 +70,7 @@ export function attachDevtoolsStates(
 			effects:
 				typeof window === `undefined`
 					? []
-					: [persistSync(window.localStorage, JSON, `🔍 Devtools Are Open`)],
+					: [storageSync(window.localStorage, JSON, `🔍 Devtools Are Open`)],
 		},
 		undefined,
 	)
@@ -87,7 +87,7 @@ export function attachDevtoolsStates(
 			effects:
 				typeof window === `undefined`
 					? []
-					: [persistSync(window.localStorage, JSON, `🔍 Devtools View`)],
+					: [storageSync(window.localStorage, JSON, `🔍 Devtools View`)],
 		},
 		undefined,
 	)
@@ -104,7 +104,7 @@ export function attachDevtoolsStates(
 			effects:
 				typeof window === `undefined`
 					? []
-					: [persistSync(window.localStorage, JSON, `🔍 Devtools View Options`)],
+					: [storageSync(window.localStorage, JSON, `🔍 Devtools View Options`)],
 		},
 		undefined,
 	)
@@ -119,7 +119,7 @@ export function attachDevtoolsStates(
 		effects: (key) =>
 			typeof window === `undefined`
 				? []
-				: [persistSync(window.localStorage, JSON, `view-is-open:${key.join()}`)],
+				: [storageSync(window.localStorage, JSON, `view-is-open:${key.join()}`)],
 	})
 
 	const openCloseAllTX: TransactionToken<

package/src/realtime/index.ts

@@ -1,2 +1,3 @@
+export * from "./mutex-store"
 export * from "./realtime-continuity"
 export * from "./shared-room-store"

package/src/realtime/mutex-store.ts

@@ -0,0 +1,11 @@
+import type { AtomFamilyToken } from "atom.io"
+import { atomFamily } from "atom.io"
+import type { Canonical } from "atom.io/json"
+
+export const mutexAtoms: AtomFamilyToken<boolean, Canonical> = atomFamily<
+	boolean,
+	Canonical
+>({
+	key: `mutex`,
+	default: false,
+})

package/src/realtime/realtime-continuity.ts

@@ -16,7 +16,7 @@ import type { UserKey } from "atom.io/realtime-server"
 
 /* eslint-disable no-console */
 
-export class InvariantMap<K, V> extends Map<K, V> {
+export class InvariantMap<K, V> extends Map<K, V> implements ReadonlyMap<K, V> {
 	public set(key: K, value: V): this {
 		if (this.has(key)) {
 			console.warn(`Tried to set a key that already exists in an InvariantMap`, {
@@ -27,10 +27,6 @@ export class InvariantMap<K, V> extends Map<K, V> {
 		}
 		return super.set(key, value)
 	}
-
-	public clear(): void {
-		throw new Error(`Cannot clear an InvariantMap`)
-	}
 }
 
 export type PerspectiveToken<F extends AtomFamilyToken<any>> = {

package/src/realtime-client/index.ts

@@ -7,5 +7,4 @@ export * from "./pull-selector"
 export * from "./pull-selector-family-member"
 export * from "./push-state"
 export * from "./realtime-client-stores"
-export * from "./server-action"
 export * from "./sync-continuity"

package/src/realtime-client/pull-atom-family-member.ts

@@ -1,28 +1,25 @@
 import type * as AtomIO from "atom.io"
-import { setIntoStore, type Store } from "atom.io/internal"
-import type { Json } from "atom.io/json"
-import { parseJson } from "atom.io/json"
+import { findInStore, setIntoStore, type Store } from "atom.io/internal"
+import type { Canonical, Json } from "atom.io/json"
 import type { Socket } from "socket.io-client"
 
-/* eslint-disable no-console */
-
-export function pullAtomFamilyMember<J extends Json.Serializable>(
+export function pullAtomFamilyMember<
+	J extends Json.Serializable,
+	K extends Canonical,
+>(
 	store: Store,
 	socket: Socket,
-	token: AtomIO.RegularAtomToken<J>,
+	family: AtomIO.AtomFamilyToken<J, K, any>,
+	key: NoInfer<K>,
 ): () => void {
-	if (!(`family` in token)) {
-		console.error(`Token is not a family member:`, token)
-		return () => {}
-	}
-	const { key: familyKey, subKey: serializedSubKey } = token.family
-	const subKey = parseJson(serializedSubKey)
-	socket?.on(`serve:${token.key}`, (data: J) => {
+	const token = findInStore(store, family, key)
+	const setServedValue = (data: J) => {
 		setIntoStore(store, token, data)
-	})
-	socket?.emit(`sub:${familyKey}`, subKey)
+	}
+	socket?.on(`serve:${token.key}`, setServedValue)
+	socket?.emit(`sub:${family.key}`, key)
 	return () => {
-		socket?.off(`serve:${token.key}`)
+		socket?.off(`serve:${token.key}`, setServedValue)
 		socket?.emit(`unsub:${token.key}`)
 	}
 }

package/src/realtime-client/pull-atom.ts

@@ -6,7 +6,7 @@ import type { Socket } from "socket.io-client"
 export function pullAtom<J extends Json.Serializable>(
 	store: Store,
 	socket: Socket,
-	token: AtomIO.RegularAtomToken<J>,
+	token: AtomIO.RegularAtomToken<J, any, any>,
 ): () => void {
 	const setServedValue = (data: J) => {
 		setIntoStore(store, token, data)

package/src/realtime-client/pull-mutable-atom-family-member.ts

@@ -1,20 +1,24 @@
 import type * as AtomIO from "atom.io"
 import type { AsJSON, SignalFrom, Store, Transceiver } from "atom.io/internal"
-import { getJsonToken, getUpdateToken, setIntoStore } from "atom.io/internal"
-import { parseJson } from "atom.io/json"
+import {
+	findInStore,
+	getJsonToken,
+	getUpdateToken,
+	setIntoStore,
+} from "atom.io/internal"
+import type { Canonical } from "atom.io/json"
 import type { Socket } from "socket.io-client"
 
-/* eslint-disable no-console */
-
 export function pullMutableAtomFamilyMember<
 	T extends Transceiver<any, any, any>,
->(store: Store, socket: Socket, token: AtomIO.MutableAtomToken<T>): () => void {
-	if (!(`family` in token)) {
-		console.error(`Token is not a family member:`, token)
-		return () => {}
-	}
-	const { key: familyKey, subKey: serializedSubKey } = token.family
-	const subKey = parseJson(serializedSubKey)
+	K extends Canonical,
+>(
+	store: Store,
+	socket: Socket,
+	family: AtomIO.MutableAtomFamilyToken<T, K>,
+	key: NoInfer<K>,
+): () => void {
+	const token = findInStore(store, family, key)
 	socket.on(`init:${token.key}`, (data: AsJSON<T>) => {
 		const jsonToken = getJsonToken(store, token)
 		setIntoStore(store, jsonToken, data)
@@ -23,7 +27,7 @@ export function pullMutableAtomFamilyMember<
 		const trackerToken = getUpdateToken(token)
 		setIntoStore(store, trackerToken, data)
 	})
-	socket.emit(`sub:${familyKey}`, subKey)
+	socket.emit(`sub:${family.key}`, key)
 	return () => {
 		socket.off(`serve:${token.key}`)
 		socket.emit(`unsub:${token.key}`)

package/src/realtime-client/pull-selector-family-member.ts

@@ -1,44 +1,17 @@
 import type * as AtomIO from "atom.io"
 import type { Store } from "atom.io/internal"
+import { findInStore } from "atom.io/internal"
+import type { Canonical } from "atom.io/json"
 import type { Socket } from "socket.io-client"
 
-import { pullAtomFamilyMember } from "./pull-atom-family-member"
-import { pullMutableAtomFamilyMember } from "./pull-mutable-atom-family-member"
+import { pullSelectorRoots } from "./pull-selector-roots"
 
-/* eslint-disable no-console */
-
-export function pullSelectorFamilyMember<T>(
+export function pullSelectorFamilyMember<T, K extends Canonical>(
 	store: Store,
 	socket: Socket,
-	token: AtomIO.SelectorToken<T>,
+	familyToken: AtomIO.SelectorFamilyToken<T, K>,
+	key: NoInfer<K>,
 ): () => void {
-	if (!(`family` in token)) {
-		console.error(`Token is not a family member:`, token)
-		return () => {}
-	}
-	const atomKeys = store.selectorAtoms.getRelatedKeys(token.key)
-	const unsubscribes: Array<() => void> = []
-	if (atomKeys) {
-		for (const atomKey of atomKeys) {
-			const atom = store.atoms.get(atomKey)
-			if (!atom) {
-				continue
-			}
-			switch (atom.type) {
-				case `atom`: {
-					unsubscribes.push(pullAtomFamilyMember(store, socket, atom))
-					break
-				}
-				case `mutable_atom`: {
-					unsubscribes.push(pullMutableAtomFamilyMember(store, socket, atom))
-					break
-				}
-			}
-		}
-	}
-	return () => {
-		for (const unsubscribe of unsubscribes) {
-			unsubscribe()
-		}
-	}
+	const token = findInStore(store, familyToken, key)
+	return pullSelectorRoots(store, socket, token)
 }