atom.io 0.34.2 → 0.36.0

package/src/main/tokens.ts

@@ -0,0 +1,245 @@
+import type { AsJSON, Func, Transceiver } from "atom.io/internal"
+import type { Canonical, stringified } from "atom.io/json"
+
+/**
+ * A token is an object that uniquely identifies a particular state, family, timeline, or transaction.
+ *
+ * While they represent one of these resources, they are not the resource itself. Think of them like paper currency representing money in the bank.
+ *
+ * Tokens are returned from resource creation functions, such as {@link atom} and {@link transaction}.
+ *
+ * Tokens can be used as parameters to functions that take a token, such as {@link getState}, {@link setState}, or {@link runTransaction}.
+ *
+ * Tokens are fully serializable, so they can be passed between processes.
+ */
+export type AtomIOToken =
+	| ReadableFamilyToken<any, any>
+	| ReadableToken<any>
+	| TimelineToken<any>
+	| TransactionToken<any>
+
+/**
+ * These states cannot be set.
+ */
+export type ReadableToken<T, K extends Canonical = any> =
+	| AtomToken<T, K>
+	| SelectorToken<T, K>
+/**
+ * These states can be set.
+ */
+export type WritableToken<T, K extends Canonical = any> =
+	| AtomToken<T, K>
+	| WritableSelectorToken<T, K>
+
+/**
+ * States belonging to this family can be gotten from the store.
+ */
+export type ReadableFamilyToken<T, K extends Canonical> =
+	| AtomFamilyToken<T, K>
+	| SelectorFamilyToken<T, K>
+/**
+ * States belonging to this family can be set.
+ */
+export type WritableFamilyToken<T, K extends Canonical> =
+	| AtomFamilyToken<T, K>
+	| WritableSelectorFamilyToken<T, K>
+
+export type TimelineToken<M> = {
+	/** The unique identifier of the timeline */
+	key: string
+	/** Discriminator */
+	type: `timeline`
+	/** Never present. This is a marker that preserves the type of the managed atoms */
+	__M?: M
+}
+
+export type TransactionToken<F extends Func> = {
+	/** The unique identifier of the transaction */
+	key: string
+	/** Discriminator */
+	type: `transaction`
+	/** Never present. This is a marker that preserves the type of the transaction function */
+	__F?: F
+}
+
+export type AtomToken<T, K extends Canonical = any> =
+	| MutableAtomToken<T extends Transceiver<any, any> ? T : never, K>
+	| RegularAtomToken<T, K>
+export type RegularAtomToken<T, K extends Canonical = any> = {
+	/** The unique identifier of the atom. */
+	key: string
+	/** Discriminator. */
+	type: `atom`
+	/** Present if the atom belongs to a family. */
+	family?: FamilyMetadata<K>
+	/** Never present. This is a marker that preserves the type of the atom's value. */
+	__T?: T
+}
+export type MutableAtomToken<
+	T extends Transceiver<any, any>,
+	K extends Canonical = any,
+> = {
+	/** The unique identifier of the atom. */
+	key: string
+	/** Discriminator. */
+	type: `mutable_atom`
+	/** Present if the atom belongs to a family. */
+	family?: FamilyMetadata<K>
+	/** Never present. This is a marker that preserves the JSON form of the atom's transceiver value. */
+	__J?: AsJSON<T>
+	/** Never present. This is a marker that preserves the type of the atom's transceiver value. */
+	__U?: T extends Transceiver<infer Update, any> ? Update : never
+}
+
+export type SelectorToken<T, K extends Canonical = any> =
+	| ReadonlySelectorToken<T, K>
+	| WritableSelectorToken<T, K>
+export type ReadonlySelectorToken<T, K extends Canonical = any> =
+	| ReadonlyHeldSelectorToken<T, K>
+	| ReadonlyPureSelectorToken<T, K>
+export type WritableSelectorToken<T, K extends Canonical = any> =
+	| WritableHeldSelectorToken<T, K>
+	| WritablePureSelectorToken<T, K>
+export type PureSelectorToken<T, K extends Canonical = any> =
+	| ReadonlyPureSelectorToken<T, K>
+	| WritablePureSelectorToken<T, K>
+export type HeldSelectorToken<T, K extends Canonical = any> =
+	| ReadonlyHeldSelectorToken<T, K>
+	| WritableHeldSelectorToken<T, K>
+
+export type WritablePureSelectorToken<T, K extends Canonical = any> = {
+	/** The unique identifier of the selector. */
+	key: string
+	/** Discriminator. */
+	type: `writable_pure_selector`
+	/** Present if the selector belongs to a family. */
+	family?: FamilyMetadata<K>
+	/** Never present. This is a marker that preserves the type of the selector's value. */
+	__T?: T
+}
+export type WritableHeldSelectorToken<T, K extends Canonical = any> = {
+	/** The unique identifier of the selector. */
+	key: string
+	/** Discriminator. */
+	type: `writable_held_selector`
+	/** Present if the selector belongs to a family. */
+	family?: FamilyMetadata<K>
+	/** Never present. This is a marker that preserves the type of the selector's value. */
+	__T?: T
+}
+export type ReadonlyPureSelectorToken<T, K extends Canonical = any> = {
+	/** The unique identifier of the selector. */
+	key: string
+	/** Discriminator. */
+	type: `readonly_pure_selector`
+	/** Present if the selector belongs to a family. */
+	family?: FamilyMetadata<K>
+	/** Never present. This is a marker that preserves the type of the selector's value. */
+	__T?: T
+}
+export type ReadonlyHeldSelectorToken<T, K extends Canonical = any> = {
+	/** The unique identifier of the selector. */
+	key: string
+	/** Discriminator. */
+	type: `readonly_held_selector`
+	/** Present if the selector belongs to a family. */
+	family?: FamilyMetadata<K>
+	/** Never present. This is a marker that preserves the type of the selector's value. */
+	__T?: T
+}
+
+/**
+ * Identifies a state's connection to its family.
+ */
+export type FamilyMetadata<K extends Canonical = any> = {
+	/** The family's unique key. */
+	key: string
+	/** The family member's unique identifier, in the form of a string. */
+	subKey: stringified<K>
+}
+
+export type AtomFamilyToken<T, K extends Canonical = Canonical> =
+	| MutableAtomFamilyToken<T extends Transceiver<any, any> ? T : never, K>
+	| RegularAtomFamilyToken<T, K>
+export type RegularAtomFamilyToken<T, K extends Canonical> = {
+	/** The unique identifier of the atom family */
+	key: string
+	/** Discriminator */
+	type: `atom_family`
+	/** Never present. This is a marker that preserves the type of atoms in this family */
+	__T?: T
+	/** Never present. This is a marker that preserves the type of keys used for atoms in this family */
+	__K?: K
+}
+export type MutableAtomFamilyToken<
+	T extends Transceiver<any, any>,
+	K extends Canonical,
+> = {
+	/** The unique identifier of the atom family */
+	key: string
+	/** Discriminator */
+	type: `mutable_atom_family`
+	/** Never present. This is a marker that preserves the type of atoms in this family */
+	__T?: T
+	/** Never present. This is a marker that preserves the type of the JSON form of atoms in this family */
+	__J?: AsJSON<T>
+	/** Never present. This is a marker that preserves the type of keys used for atoms in this family */
+	__K?: K
+}
+
+export type SelectorFamilyToken<T, K extends Canonical> =
+	| ReadonlySelectorFamilyToken<T, K>
+	| WritableSelectorFamilyToken<T, K>
+export type ReadonlySelectorFamilyToken<T, K extends Canonical> =
+	| ReadonlyHeldSelectorFamilyToken<T, K>
+	| ReadonlyPureSelectorFamilyToken<T, K>
+export type WritableSelectorFamilyToken<T, K extends Canonical> =
+	| WritableHeldSelectorFamilyToken<T, K>
+	| WritablePureSelectorFamilyToken<T, K>
+export type PureSelectorFamilyToken<T, K extends Canonical> =
+	| ReadonlyPureSelectorFamilyToken<T, K>
+	| WritablePureSelectorFamilyToken<T, K>
+export type HeldSelectorFamilyToken<T, K extends Canonical> =
+	| ReadonlyHeldSelectorFamilyToken<T, K>
+	| WritableHeldSelectorFamilyToken<T, K>
+
+export type WritablePureSelectorFamilyToken<T, K extends Canonical> = {
+	/** The unique identifier of the family */
+	key: string
+	/** Discriminator */
+	type: `writable_pure_selector_family`
+	/** Never present. This is a marker that preserves the type of the value of each family member */
+	__T?: T
+	/** Never present. This is a marker that preserves the type of keys used for each family member */
+	__K?: K
+}
+export type ReadonlyPureSelectorFamilyToken<T, K extends Canonical> = {
+	/** The unique identifier of the family */
+	key: string
+	/** Discriminator */
+	type: `readonly_pure_selector_family`
+	/** Never present. This is a marker that preserves the type of the value of each family member */
+	__T?: T
+	/** Never present. This is a marker that preserves the type of keys used for each family member */
+	__K?: K
+}
+export type WritableHeldSelectorFamilyToken<T, K extends Canonical> = {
+	/** The unique identifier of the family */
+	key: string
+	/** Discriminator */
+	type: `writable_held_selector_family`
+	/** Never present. This is a marker that preserves the type of the value of each family member */
+	__T?: T
+	/** Never present. This is a marker that preserves the type of keys used for each family member */
+	__K?: K
+}
+export type ReadonlyHeldSelectorFamilyToken<T, K extends Canonical> = {
+	/** The unique identifier of the family */
+	key: string
+	/** Discriminator */
+	type: `readonly_held_selector_family`
+	/** Never present. This is a marker that preserves the type of the value of each family member */
+	__T?: T
+	/** Never present. This is a marker that preserves the type of keys used for each family member */
+	__K?: K
+}

package/src/main/transaction.ts

@@ -1,80 +1,70 @@
-import type { findState, getState, setState } from "atom.io"
-import type { EnvironmentData, Func, Transceiver } from "atom.io/internal"
+import type {
+	AsJSON,
+	EnvironmentData,
+	Func,
+	Transceiver,
+} from "atom.io/internal"
 import {
 	actUponStore,
 	arbitrary,
 	createTransaction,
 	IMPLICIT,
 } from "atom.io/internal"
-import type { Canonical, Json, stringified } from "atom.io/json"
+import type { Canonical, stringified } from "atom.io/json"
 
+import type { disposeState } from "./dispose-state"
+import type { findState } from "./find-state"
+import type { getState } from "./get-state"
+import type { resetState } from "./reset-state"
+import type { setState } from "./set-state"
+import type { KeyedStateUpdate } from "./subscribe"
 import type {
-	disposeState,
-	KeyedStateUpdate,
 	MutableAtomToken,
 	ReadableToken,
-	TokenType,
+	TransactionToken,
 	WritablePureSelectorToken,
-} from "."
-import type { resetState } from "./reset-state"
+} from "./tokens"
+import type { TokenType } from "./validators"
 
-/** @public */
-export type TransactionToken<F extends Func> = {
-	/** The unique identifier of the transaction */
-	key: string
-	/** Discriminator */
-	type: `transaction`
-	/** Never present. This is a marker that preserves the type of the transaction function */
-	__F?: F
-}
-
-/** @public */
 export type StateCreation<Token extends ReadableToken<any>> = {
 	type: `state_creation`
 	token: Token
 }
-/** @public */
+export type StateDisposal<Token extends ReadableToken<any>> =
+	| AtomDisposal<Token>
+	| SelectorDisposal<Token>
+
 export type AtomDisposal<Token extends ReadableToken<any>> = {
 	type: `state_disposal`
 	subType: `atom`
 	token: Token
 	value: TokenType<Token>
 }
-/** @public */
 export type SelectorDisposal<Token extends ReadableToken<any>> = {
 	type: `state_disposal`
 	subType: `selector`
 	token: Token
 }
-/** @public */
-export type StateDisposal<Token extends ReadableToken<any>> =
-	| AtomDisposal<Token>
-	| SelectorDisposal<Token>
 
-/** @public */
 export type MoleculeCreation = {
 	type: `molecule_creation`
 	key: Canonical
 	provenance: Canonical
 }
-
-/** @public */
 export type MoleculeDisposal = {
 	type: `molecule_disposal`
 	key: Canonical
 	provenance: stringified<Canonical>[]
 	values: [key: string, value: any][]
 }
-
-/** @public */
 export type MoleculeTransfer = {
 	type: `molecule_transfer`
 	key: Canonical
+	exclusive: boolean
 	from: Canonical[]
 	to: Canonical[]
 }
 
-/** @public */
 export type TransactionUpdateContent =
 	| KeyedStateUpdate<unknown>
 	| MoleculeCreation
@@ -84,7 +74,6 @@ export type TransactionUpdateContent =
 	| StateDisposal<ReadableToken<unknown>>
 	| TransactionUpdate<Func>
 
-/** @public */
 export type TransactionUpdate<F extends Func> = {
 	type: `transaction_update`
 	key: string
@@ -95,54 +84,35 @@ export type TransactionUpdate<F extends Func> = {
 	output: ReturnType<F>
 }
 
-/** @public */
-export type GetterToolkit = Pick<SetterToolkit, `find` | `get` | `json`>
-/** @public */
-export type SetterToolkit = Readonly<{
-	get: typeof getState
-	set: typeof setState
-	find: typeof findState
-	json: <T extends Transceiver<any>, J extends Json.Serializable>(
-		state: MutableAtomToken<T, J>,
-	) => WritablePureSelectorToken<J>
-}>
-/** @public */
+export type ReaderToolkit = Pick<ActorToolkit, `find` | `get` | `json`>
+export type WriterToolkit = Pick<ActorToolkit, `find` | `get` | `json` | `set`>
 export type ActorToolkit = Readonly<{
 	get: typeof getState
 	set: typeof setState
 	reset: typeof resetState
 	find: typeof findState
-	json: <T extends Transceiver<any>, J extends Json.Serializable>(
-		state: MutableAtomToken<T, J>,
-	) => WritablePureSelectorToken<J>
+	json: <T extends Transceiver<any, any>>(
+		state: MutableAtomToken<T>,
+	) => WritablePureSelectorToken<AsJSON<T>>
 	dispose: typeof disposeState
 	run: typeof runTransaction
 	env: () => EnvironmentData
 }>
 
-/** @public */
 export type Read<F extends Func> = (
-	toolkit: GetterToolkit,
+	toolkit: ReaderToolkit,
 	...parameters: Parameters<F>
 ) => ReturnType<F>
-
-/** @public */
 export type Write<F extends Func> = (
-	toolkit: SetterToolkit,
+	toolkit: WriterToolkit,
 	...parameters: Parameters<F>
 ) => ReturnType<F>
-
-/** @public */
 export type Transact<F extends Func> = (
 	toolkit: ActorToolkit,
 	...parameters: Parameters<F>
 ) => ReturnType<F>
-
-/** @public */
 export type TransactionIO<Token extends TransactionToken<any>> =
 	Token extends TransactionToken<infer F> ? F : never
-
-/** @public */
 export type TransactionOptions<F extends Func> = {
 	/** The unique identifier of the transaction */
 	key: string
@@ -151,7 +121,6 @@ export type TransactionOptions<F extends Func> = {
 }
 
 /**
- * @public
  * Create a transaction, a mechanism for batching updates multiple states in a single, all-or-nothing operation
  * @param options - {@link TransactionOptions}
  * @returns A reference to the transaction created: a {@link TransactionToken}
@@ -163,7 +132,6 @@ export function transaction<F extends Func>(
 }
 
 /**
- * @public
  * Execute a {@link transaction}
  * @param token - A {@link TransactionToken}
  * @param id - A unique identifier for the transaction. If not provided, a random identifier will be generated

package/src/main/validators.ts

@@ -11,7 +11,7 @@ import type {
 	WritablePureSelectorFamilyToken,
 	WritablePureSelectorToken,
 	WritableToken,
-} from "atom.io"
+} from "./tokens"
 
 export type TokenType<
 	Comparison extends ReadableFamilyToken<any, any> | ReadableToken<any>,
@@ -56,7 +56,7 @@ export function belongsTo<Family extends RegularAtomFamilyToken<any, any>>(
 	family: Family,
 	unknownToken: ReadableToken<any>,
 ): unknownToken is RegularAtomToken<TokenType<Family>>
-export function belongsTo<Family extends MutableAtomFamilyToken<any, any, any>>(
+export function belongsTo<Family extends MutableAtomFamilyToken<any, any>>(
 	family: Family,
 	unknownToken: ReadableToken<any>,
 ): unknownToken is MutableAtomToken<TokenType<Family>, any>

package/src/react/use-json.ts

@@ -1,8 +1,5 @@
-import type {
-	MutableAtomFamilyToken,
-	MutableAtomToken,
-	ReadableToken,
-} from "atom.io"
+import type { MutableAtomFamilyToken, MutableAtomToken } from "atom.io"
+import type { AsJSON, Transceiver } from "atom.io/internal"
 import { findInStore, getJsonToken } from "atom.io/internal"
 import type { Canonical, Json } from "atom.io/json"
 import * as React from "react"
@@ -10,29 +7,22 @@ import * as React from "react"
 import { StoreContext } from "./store-context"
 import { useO } from "./use-o"
 
-export function useJSON<Serializable extends Json.Serializable>(
-	token: MutableAtomToken<any, Serializable>,
-): Serializable
+export function useJSON<T extends Transceiver<any, any>>(
+	token: MutableAtomToken<T>,
+): AsJSON<T>
 
-export function useJSON<
-	Serializable extends Json.Serializable,
-	Key extends Canonical,
->(token: MutableAtomFamilyToken<any, Serializable, Key>, key: Key): Serializable
+export function useJSON<T extends Transceiver<any, any>, K extends Canonical>(
+	token: MutableAtomFamilyToken<T, K>,
+	key: K,
+): AsJSON<T>
 
-export function useJSON<
-	Serializable extends Json.Serializable,
-	Key extends Canonical,
->(
-	token:
-		| MutableAtomFamilyToken<any, Serializable, Key>
-		| MutableAtomToken<any, Serializable>,
-	key?: Key,
-): Serializable {
+export function useJSON(
+	token: MutableAtomFamilyToken<any, any> | MutableAtomToken<any>,
+	key?: Canonical,
+): Json.Serializable {
 	const store = React.useContext(StoreContext)
-	const stateToken: ReadableToken<any> =
-		token.type === `mutable_atom_family`
-			? findInStore(store, token, key as Key)
-			: token
+	const stateToken: MutableAtomToken<any> =
+		token.type === `mutable_atom_family` ? findInStore(store, token, key) : token
 	const jsonToken = getJsonToken(store, stateToken)
 	return useO(jsonToken)
 }

package/src/react-devtools/store.ts

@@ -6,8 +6,8 @@ import type {
 	TransactionToken,
 } from "atom.io"
 import {
-	createAtomFamily,
-	createStandaloneAtom,
+	createRegularAtom,
+	createRegularAtomFamily,
 	createTransaction,
 	type Store,
 } from "atom.io/internal"
@@ -39,53 +39,69 @@ export function attachDevtoolsStates(
 ): DevtoolsStates & IntrospectionStates & { store: Store } {
 	const introspectionStates = attachIntrospectionStates(store)
 
-	const devtoolsAreHiddenAtom = createStandaloneAtom<boolean>(store, {
-		key: `🔍 Devtools Are Hidden`,
-		default: hideByDefault,
-		effects:
-			typeof window === `undefined`
-				? []
-				: [
-						persistSync(window.localStorage, JSON, `🔍 Devtools Are Hidden`),
-						({ setSelf }) => {
-							window.addEventListener(`keydown`, (e) => {
-								if (e.ctrlKey && e.shiftKey && e.key.toLowerCase() === `a`) {
-									e.preventDefault()
-									setSelf((state) => !state)
-								}
-							})
-						},
-					],
-	})
+	const devtoolsAreHiddenAtom = createRegularAtom<boolean>(
+		store,
+		{
+			key: `🔍 Devtools Are Hidden`,
+			default: hideByDefault,
+			effects:
+				typeof window === `undefined`
+					? []
+					: [
+							persistSync(window.localStorage, JSON, `🔍 Devtools Are Hidden`),
+							({ setSelf }) => {
+								window.addEventListener(`keydown`, (e) => {
+									if (e.ctrlKey && e.shiftKey && e.key.toLowerCase() === `a`) {
+										e.preventDefault()
+										setSelf((state) => !state)
+									}
+								})
+							},
+						],
+		},
+		undefined,
+	)
 
-	const devtoolsAreOpenAtom = createStandaloneAtom<boolean>(store, {
-		key: `🔍 Devtools Are Open`,
-		default: true,
-		effects:
-			typeof window === `undefined`
-				? []
-				: [persistSync(window.localStorage, JSON, `🔍 Devtools Are Open`)],
-	})
+	const devtoolsAreOpenAtom = createRegularAtom<boolean>(
+		store,
+		{
+			key: `🔍 Devtools Are Open`,
+			default: true,
+			effects:
+				typeof window === `undefined`
+					? []
+					: [persistSync(window.localStorage, JSON, `🔍 Devtools Are Open`)],
+		},
+		undefined,
+	)
 
-	const devtoolsViewSelectionAtom = createStandaloneAtom<DevtoolsView>(store, {
-		key: `🔍 Devtools View Selection`,
-		default: `atoms`,
-		effects:
-			typeof window === `undefined`
-				? []
-				: [persistSync(window.localStorage, JSON, `🔍 Devtools View`)],
-	})
+	const devtoolsViewSelectionAtom = createRegularAtom<DevtoolsView>(
+		store,
+		{
+			key: `🔍 Devtools View Selection`,
+			default: `atoms`,
+			effects:
+				typeof window === `undefined`
+					? []
+					: [persistSync(window.localStorage, JSON, `🔍 Devtools View`)],
+		},
+		undefined,
+	)
 
-	const devtoolsViewOptionsAtom = createStandaloneAtom<DevtoolsView[]>(store, {
-		key: `🔍 Devtools View Options`,
-		default: [`atoms`, `selectors`, `transactions`, `timelines`],
-		effects:
-			typeof window === `undefined`
-				? []
-				: [persistSync(window.localStorage, JSON, `🔍 Devtools View Options`)],
-	})
+	const devtoolsViewOptionsAtom = createRegularAtom<DevtoolsView[]>(
+		store,
+		{
+			key: `🔍 Devtools View Options`,
+			default: [`atoms`, `selectors`, `transactions`, `timelines`],
+			effects:
+				typeof window === `undefined`
+					? []
+					: [persistSync(window.localStorage, JSON, `🔍 Devtools View Options`)],
+		},
+		undefined,
+	)
 
-	const viewIsOpenAtoms = createAtomFamily<
+	const viewIsOpenAtoms = createRegularAtomFamily<
 		boolean,
 		readonly (number | string)[]
 	>(store, {

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

@@ -3,30 +3,20 @@ import type {
 	MutableAtomToken,
 	ReadonlyPureSelectorFamilyToken,
 } from "atom.io"
-import { atom, getInternalRelations, join, selectorFamily } from "atom.io"
-import type { SetRTXJson } from "atom.io/transceivers/set-rtx"
+import { getInternalRelations, join, mutableAtom, selectorFamily } from "atom.io"
 import { SetRTX } from "atom.io/transceivers/set-rtx"
 
-export const usersInThisRoomIndex: MutableAtomToken<
-	SetRTX<string>,
-	SetRTXJson<string>
-> = atom<SetRTX<string>, SetRTXJson<string>>({
-	key: `usersInRoomIndex`,
-	mutable: true,
-	default: () => new SetRTX<string>(),
-	toJson: (set) => set.toJSON(),
-	fromJson: (json) => SetRTX.fromJSON(json),
-})
+export const usersInThisRoomIndex: MutableAtomToken<SetRTX<string>> =
+	mutableAtom<SetRTX<string>>({
+		key: `usersInRoomIndex`,
+		class: SetRTX,
+	})
 
-export const roomIndex: MutableAtomToken<
-	SetRTX<string>,
-	SetRTXJson<string>
-> = atom<SetRTX<string>, SetRTXJson<string>>({
+export const roomIndex: MutableAtomToken<SetRTX<string>> = mutableAtom<
+	SetRTX<string>
+>({
 	key: `roomIndex`,
-	default: () => new SetRTX<string>(),
-	mutable: true,
-	toJson: (set) => set.toJSON(),
-	fromJson: (json) => SetRTX.fromJSON(json),
+	class: SetRTX,
 })
 
 export type UserInRoomMeta = {
@@ -54,12 +44,9 @@ export const usersInRooms: JoinToken<
 )
 
 export const usersInMyRoomView: ReadonlyPureSelectorFamilyToken<
-	MutableAtomToken<SetRTX<string>, SetRTXJson<string>>[],
+	MutableAtomToken<SetRTX<string>>[],
 	string
-> = selectorFamily<
-	MutableAtomToken<SetRTX<string>, SetRTXJson<string>>[],
-	string
->({
+> = selectorFamily<MutableAtomToken<SetRTX<string>>[], string>({
 	key: `usersInMyRoomView`,
 	get:
 		(myUsername) =>