atom.io 0.34.2 → 0.35.0

package/src/main/timeline.ts

@@ -10,11 +10,9 @@ import type {
 } from "atom.io/internal"
 import { createTimeline, IMPLICIT, timeTravel } from "atom.io/internal"
 
-import type { AtomFamilyToken, AtomToken } from "."
+import type { AtomFamilyToken, AtomToken, TimelineToken } from "."
 
-/** @public */
 export type TimelineManageable = AtomFamilyToken<any, any> | AtomToken<any>
-/** @public */
 export type AtomOnly<M extends TimelineManageable> = M extends AtomFamilyToken<
 	any,
 	any
@@ -24,18 +22,7 @@ export type AtomOnly<M extends TimelineManageable> = M extends AtomFamilyToken<
 		? M
 		: never
 
-/** @public */
-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
-}
-
 /**
- * @public
  * If there is an update ahead of the cursor (in the future of this {@link timeline}), apply it and move the cursor to the next update
  * @param timeline - A {@link TimelineToken}
  */
@@ -43,7 +30,6 @@ export const redo = (timeline: TimelineToken<any>): void => {
 	timeTravel(IMPLICIT.STORE, `redo`, timeline)
 }
 /**
- * @public
  * Reverse the last update on the {@link timeline} and move the cursor to the previous update
  * @param timeline - A {@link TimelineToken}
  */
@@ -51,7 +37,6 @@ export const undo = (timeline: TimelineToken<any>): void => {
 	timeTravel(IMPLICIT.STORE, `undo`, timeline)
 }
 
-/** @public */
 export type TimelineUpdate<ManagedAtom extends TimelineManageable> =
 	| TimelineAtomUpdate<ManagedAtom>
 	| TimelineMoleculeCreation
@@ -61,7 +46,6 @@ export type TimelineUpdate<ManagedAtom extends TimelineManageable> =
 	| TimelineStateDisposal<AtomOnly<ManagedAtom>>
 	| TimelineTransactionUpdate
 
-/** @public */
 export type TimelineOptions<ManagedAtom extends TimelineManageable> = {
 	/** The unique identifier of the timeline */
 	key: string
@@ -75,7 +59,6 @@ export type TimelineOptions<ManagedAtom extends TimelineManageable> = {
 }
 
 /**
- * @public
  * Create a timeline, a mechanism for recording, undoing, and replaying changes to groups of atoms
  * @param options - {@link TimelineOptions}
  * @returns A reference to the timeline created: a {@link TimelineToken}

package/src/main/tokens.ts

@@ -0,0 +1,247 @@
+import type { Func, Transceiver } from "atom.io/internal"
+import type { Canonical, Json, 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> ? T : never, any, 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>,
+	J extends Json.Serializable,
+	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?: J
+	/** Never present. This is a marker that preserves the type of the atom's transceiver value. */
+	__U?: T extends Transceiver<infer Update> ? 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> ? T : never, any, 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>,
+	J extends Json.Serializable,
+	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?: J
+	/** 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,4 +1,3 @@
-import type { findState, getState, setState } from "atom.io"
 import type { EnvironmentData, Func, Transceiver } from "atom.io/internal"
 import {
 	actUponStore,
@@ -8,65 +7,51 @@ import {
 } from "atom.io/internal"
 import type { Canonical, Json, 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
@@ -74,7 +59,6 @@ export type MoleculeTransfer = {
 	to: Canonical[]
 }
 
-/** @public */
 export type TransactionUpdateContent =
 	| KeyedStateUpdate<unknown>
 	| MoleculeCreation
@@ -84,7 +68,6 @@ export type TransactionUpdateContent =
 	| StateDisposal<ReadableToken<unknown>>
 	| TransactionUpdate<Func>
 
-/** @public */
 export type TransactionUpdate<F extends Func> = {
 	type: `transaction_update`
 	key: string
@@ -95,18 +78,8 @@ 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
@@ -120,29 +93,20 @@ export type ActorToolkit = Readonly<{
 	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 +115,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 +126,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>,

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,16 +3,15 @@ import type {
 	MutableAtomToken,
 	ReadonlyPureSelectorFamilyToken,
 } from "atom.io"
-import { atom, getInternalRelations, join, selectorFamily } from "atom.io"
+import { getInternalRelations, join, mutableAtom, selectorFamily } from "atom.io"
 import type { SetRTXJson } from "atom.io/transceivers/set-rtx"
 import { SetRTX } from "atom.io/transceivers/set-rtx"
 
 export const usersInThisRoomIndex: MutableAtomToken<
 	SetRTX<string>,
 	SetRTXJson<string>
-> = atom<SetRTX<string>, SetRTXJson<string>>({
+> = mutableAtom<SetRTX<string>, SetRTXJson<string>>({
 	key: `usersInRoomIndex`,
-	mutable: true,
 	default: () => new SetRTX<string>(),
 	toJson: (set) => set.toJSON(),
 	fromJson: (json) => SetRTX.fromJSON(json),
@@ -21,10 +20,9 @@ export const usersInThisRoomIndex: MutableAtomToken<
 export const roomIndex: MutableAtomToken<
 	SetRTX<string>,
 	SetRTXJson<string>
-> = atom<SetRTX<string>, SetRTXJson<string>>({
+> = mutableAtom<SetRTX<string>, SetRTXJson<string>>({
 	key: `roomIndex`,
 	default: () => new SetRTX<string>(),
-	mutable: true,
 	toJson: (set) => set.toJSON(),
 	fromJson: (json) => SetRTX.fromJSON(json),
 })

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

@@ -4,7 +4,7 @@ import type {
 	MutableAtomToken,
 	RegularAtomFamilyToken,
 } from "atom.io"
-import { atom, atomFamily, join } from "atom.io"
+import { atomFamily, join, mutableAtom } from "atom.io"
 import type { SetRTXJson } from "atom.io/transceivers/set-rtx"
 import { SetRTX } from "atom.io/transceivers/set-rtx"
 
@@ -32,9 +32,8 @@ export const socketAtoms: RegularAtomFamilyToken<Socket | null, SocketKey> =
 export const socketIndex: MutableAtomToken<
 	SetRTX<SocketKey>,
 	SetRTXJson<SocketKey>
-> = atom<SetRTX<SocketKey>, SetRTXJson<SocketKey>>({
+> = mutableAtom<SetRTX<SocketKey>, SetRTXJson<SocketKey>>({
 	key: `socketsIndex`,
-	mutable: true,
 	default: () => new SetRTX(),
 	toJson: (set) => set.toJSON(),
 	fromJson: (json) => SetRTX.fromJSON(json),
@@ -42,9 +41,8 @@ export const socketIndex: MutableAtomToken<
 export const userIndex: MutableAtomToken<
 	SetRTX<UserKey>,
 	SetRTXJson<UserKey>
-> = atom<SetRTX<UserKey>, SetRTXJson<UserKey>>({
+> = mutableAtom<SetRTX<UserKey>, SetRTXJson<UserKey>>({
 	key: `usersIndex`,
-	mutable: true,
 	default: () => new SetRTX(),
 	toJson: (set) => set.toJSON(),
 	fromJson: (json) => SetRTX.fromJSON(json),