atom.io 0.40.6 → 0.40.7

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/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)
 }

package/src/realtime-client/pull-selector-roots.ts

@@ -0,0 +1,90 @@
+import type { AtomToken, SelectorToken } from "atom.io"
+import type { Store } from "atom.io/internal"
+import { getFamilyOfToken, subscribeToState } from "atom.io/internal"
+import { parseJson } from "atom.io/json"
+import type { Socket } from "socket.io-client"
+
+import { pullAtom } from "./pull-atom"
+import { pullAtomFamilyMember } from "./pull-atom-family-member"
+import { pullMutableAtom } from "./pull-mutable-atom"
+import { pullMutableAtomFamilyMember } from "./pull-mutable-atom-family-member"
+
+export function pullSelectorRoots(
+	store: Store,
+	socket: Socket,
+	selectorToken: SelectorToken<any>,
+): () => void {
+	const atomSubscriptions = new Map<string, () => void>()
+	const clearAtomSubscriptions = () => {
+		for (const [, unsub] of atomSubscriptions) unsub()
+		atomSubscriptions.clear()
+	}
+
+	const start = () => {
+		const atomKeys = store.selectorAtoms.getRelatedKeys(selectorToken.key)
+		if (atomKeys) {
+			for (const [atomKey, unsub] of atomSubscriptions) {
+				if (!atomKeys.has(atomKey)) {
+					unsub()
+					atomSubscriptions.delete(atomKey)
+				}
+			}
+
+			for (const atomKey of atomKeys) {
+				if (atomSubscriptions.has(atomKey)) {
+					continue
+				}
+				const atom = store.atoms.get(atomKey) as AtomToken<any, any>
+				switch (atom.type) {
+					case `atom`: {
+						if (atom.family) {
+							const { subKey: serializedSubKey } = atom.family
+							const subKey = parseJson(serializedSubKey)
+							const family = getFamilyOfToken(store, atom)
+							atomSubscriptions.set(
+								atomKey,
+								pullAtomFamilyMember(store, socket, family, subKey),
+							)
+						} else {
+							atomSubscriptions.set(atomKey, pullAtom(store, socket, atom))
+						}
+						break
+					}
+					case `mutable_atom`: {
+						if (atom.family) {
+							const { subKey: serializedSubKey } = atom.family
+							const subKey = parseJson(serializedSubKey)
+							const family = getFamilyOfToken(store, atom)
+							atomSubscriptions.set(
+								atomKey,
+								pullMutableAtomFamilyMember(store, socket, family, subKey),
+							)
+						} else {
+							atomSubscriptions.set(
+								atomKey,
+								pullMutableAtom(store, socket, atom),
+							)
+						}
+						break
+					}
+				}
+			}
+		}
+	}
+
+	const unsubFromSelector = subscribeToState(
+		store,
+		selectorToken,
+		`pull-watches-dependencies`,
+		() => {
+			start()
+		},
+	)
+
+	start()
+
+	return () => {
+		clearAtomSubscriptions()
+		unsubFromSelector()
+	}
+}

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

@@ -2,37 +2,12 @@ import type * as AtomIO from "atom.io"
 import type { Store } from "atom.io/internal"
 import type { Socket } from "socket.io-client"
 
-import { pullAtom } from "./pull-atom"
-import { pullMutableAtom } from "./pull-mutable-atom"
+import { pullSelectorRoots } from "./pull-selector-roots"
 
 export function pullSelector<T>(
 	store: Store,
 	socket: Socket,
 	token: AtomIO.SelectorToken<T>,
 ): () => void {
-	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(pullAtom(store, socket, atom))
-					break
-				}
-				case `mutable_atom`: {
-					unsubscribes.push(pullMutableAtom(store, socket, atom))
-					break
-				}
-			}
-		}
-	}
-	return () => {
-		for (const unsubscribe of unsubscribes) {
-			unsubscribe()
-		}
-	}
+	return pullSelectorRoots(store, socket, token)
 }

package/src/realtime-client/push-state.ts

@@ -1,7 +1,9 @@
 import type { WritableToken } from "atom.io"
 import type { Store } from "atom.io/internal"
-import { subscribeToState } from "atom.io/internal"
+import { setIntoStore, subscribeToState } from "atom.io/internal"
 import type { Json } from "atom.io/json"
+import { mutexAtoms } from "atom.io/realtime/mutex-store"
+import { employSocket } from "atom.io/realtime-server/employ-socket"
 import type { Socket } from "socket.io-client"
 
 export function pushState<J extends Json.Serializable>(
@@ -9,12 +11,38 @@ export function pushState<J extends Json.Serializable>(
 	socket: Socket,
 	token: WritableToken<J>,
 ): () => void {
-	socket.emit(`claim:${token.key}`)
-	subscribeToState(store, token, `push`, ({ newValue }) => {
+	const publish = (newValue: J) => {
 		socket.emit(`pub:${token.key}`, newValue)
-	})
+	}
+
+	const subscriptions = new Set<() => void>()
+	const clearSubscriptions = () => {
+		for (const unsub of subscriptions) unsub()
+		subscriptions.clear()
+	}
+
+	const init = () => {
+		subscriptions.add(
+			employSocket(socket, `claim-result:${token.key}`, (success: boolean) => {
+				if (!success) return
+
+				clearSubscriptions()
+				setIntoStore(store, mutexAtoms, token.key, true)
+				subscriptions.add(
+					subscribeToState(store, token, `push`, ({ newValue }) => {
+						publish(newValue)
+					}),
+				)
+			}),
+		)
+
+		socket.emit(`claim:${token.key}`)
+	}
+
+	init()
+
 	return () => {
-		socket.off(`pub:${token.key}`)
+		clearSubscriptions()
 		socket.emit(`unclaim:${token.key}`)
 	}
 }

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

@@ -1,5 +1,5 @@
 import * as AtomIO from "atom.io"
-import { persistSync } from "atom.io/web"
+import { storageSync } from "atom.io/web"
 
 export const myIdState__INTERNAL: AtomIO.RegularAtomToken<string | undefined> =
 	AtomIO.atom<string | undefined>({
@@ -16,8 +16,5 @@ export const myUsernameState: AtomIO.RegularAtomToken<string | null> =
 	AtomIO.atom<string | null>({
 		key: `myName`,
 		default: null,
-		effects:
-			typeof window === `undefined`
-				? []
-				: [persistSync(window.localStorage, JSON, `myUsername`)],
+		effects: [storageSync(globalThis.localStorage, JSON, `myUsername`)],
 	})

package/src/realtime-react/index.ts

@@ -1,4 +1,3 @@
-export * from "./on-mount"
 export * from "./realtime-context"
 export * from "./use-pull-atom"
 export * from "./use-pull-atom-family-member"
@@ -7,5 +6,7 @@ export * from "./use-pull-mutable-family-member"
 export * from "./use-pull-selector"
 export * from "./use-pull-selector-family-member"
 export * from "./use-push"
+export * from "./use-realtime-service"
 export * from "./use-server-action"
+export * from "./use-single-effect"
 export * from "./use-sync-continuity"

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

@@ -3,12 +3,14 @@ import * as RTC from "atom.io/realtime-client"
 import * as React from "react"
 import type { Socket } from "socket.io-client"
 
+export type RealtimeServiceCounter = {
+	consumerCount: number
+	dispose: () => void
+}
+
 export type RealtimeReactStore = {
 	socket: Socket | null
-	services: Map<
-		string,
-		[consumerCount: number, dispose: (() => void) | undefined]
-	> | null
+	services: Map<string, RealtimeServiceCounter> | null
 }
 
 export const RealtimeContext: React.Context<RealtimeReactStore> =
@@ -21,7 +23,9 @@ export const RealtimeProvider: React.FC<{
 	children: React.ReactNode
 	socket: Socket | null
 }> = ({ children, socket }) => {
-	const services = React.useRef(new Map<string, [number, () => void]>()).current
+	const services = React.useRef(
+		new Map<string, RealtimeServiceCounter>(),
+	).current
 	const setMyId = useI(RTC.myIdState__INTERNAL)
 	React.useEffect(() => {
 		setMyId(socket?.id)

package/src/realtime-react/use-pull-atom-family-member.ts

@@ -10,12 +10,11 @@ import { useRealtimeService } from "./use-realtime-service"
 export function usePullAtomFamilyMember<
 	J extends Json.Serializable,
 	K extends Canonical,
-	Key extends K,
->(family: AtomIO.RegularAtomFamilyToken<J, K>, subKey: Key): J {
+>(family: AtomIO.RegularAtomFamilyToken<J, K>, subKey: NoInfer<K>): J {
 	const store = React.useContext(StoreContext)
 	const token = findInStore(store, family, subKey)
 	useRealtimeService(`pull:${token.key}`, (socket) =>
-		RTC.pullAtomFamilyMember(store, socket, token),
+		RTC.pullAtomFamilyMember(store, socket, family, subKey),
 	)
 	return useO(token)
 }

package/src/realtime-react/use-pull-mutable-family-member.ts

@@ -11,12 +11,11 @@ import { useRealtimeService } from "./use-realtime-service"
 export function usePullMutableAtomFamilyMember<
 	T extends Transceiver<any, any, any>,
 	K extends Canonical,
-	Key extends K,
->(familyToken: AtomIO.MutableAtomFamilyToken<T, K>, key: Key): T {
+>(familyToken: AtomIO.MutableAtomFamilyToken<T, K>, key: NoInfer<K>): T {
 	const store = React.useContext(StoreContext)
 	const token = findInStore(store, familyToken, key)
 	useRealtimeService(`pull:${token.key}`, (socket) =>
-		RTC.pullMutableAtomFamilyMember(store, socket, token),
+		RTC.pullMutableAtomFamilyMember(store, socket, familyToken, key),
 	)
 	return useO(token)
 }