atom.io 0.35.0 → 0.36.0

package/src/main/atom.ts

@@ -1,4 +1,4 @@
-import type { Transceiver } from "atom.io/internal"
+import type { ConstructorOf, Transceiver } from "atom.io/internal"
 import {
 	createMutableAtom,
 	createMutableAtomFamily,
@@ -6,7 +6,7 @@ import {
 	createRegularAtomFamily,
 	IMPLICIT,
 } from "atom.io/internal"
-import type { Canonical, Json, JsonInterface } from "atom.io/json"
+import type { Canonical } from "atom.io/json"
 
 import type { Setter } from "./set-state"
 import type {
@@ -34,20 +34,14 @@ export function atom<T>(options: RegularAtomOptions<T>): RegularAtomToken<T> {
 	return createRegularAtom(IMPLICIT.STORE, options, undefined)
 }
 
-// biome-ignore format: intersection
-export type MutableAtomOptions<
-	T extends Transceiver<any>,
-	J extends Json.Serializable,
-> =
-	& JsonInterface<T, J>
-	& {
-		/** The unique identifier of the atom */
-		key: string
-		/** A function to create an initial value for the atom */
-		default: () => T
-		/** Hooks used to run side effects when the atom is set */
-		effects?: AtomEffect<T>[]
-	}
+export type MutableAtomOptions<T extends Transceiver<any, any>> = {
+	/** The unique identifier of the atom */
+	key: string
+	/** A constructor for the atom's value */
+	class: ConstructorOf<T>
+	/** Hooks used to run side effects when the atom is set */
+	effects?: AtomEffect<T>[]
+}
 /**
  * Create a mutable atom, a global reactive variable in the implicit store
  *
@@ -57,10 +51,9 @@ export type MutableAtomOptions<
  * @returns
  * A reference to the atom created: a {@link MutableAtomToken}
  */
-export function mutableAtom<
-	T extends Transceiver<any>,
-	J extends Json.Serializable,
->(options: MutableAtomOptions<T, J>): MutableAtomToken<T, J> {
+export function mutableAtom<T extends Transceiver<any, any>>(
+	options: MutableAtomOptions<T>,
+): MutableAtomToken<T> {
 	return createMutableAtom(IMPLICIT.STORE, options, undefined)
 }
 
@@ -105,21 +98,17 @@ export function atomFamily<T, K extends Canonical>(
 	return createRegularAtomFamily(IMPLICIT.STORE, options)
 }
 
-// biome-ignore format: intersection
 export type MutableAtomFamilyOptions<
-	T extends Transceiver<any>,
-	J extends Json.Serializable,
+	T extends Transceiver<any, any>,
 	K extends Canonical,
-> =
-	& JsonInterface<T, J>
-	& {
-		/** The unique identifier of the atom family */
-		key: string
-		/** A function to create an initial value for each atom in the family */
-		default: (key: K) => T
-		/** Hooks used to run side effects when an atom in the family is set  */
-		effects?: (key: K) => AtomEffect<T>[]
-	}
+> = {
+	/** The unique identifier of the atom family */
+	key: string
+	/** The class of the transceiver to be created */
+	class: ConstructorOf<T>
+	/** Hooks used to run side effects when an atom in the family is set  */
+	effects?: (key: K) => AtomEffect<T>[]
+}
 /**
  * Create a family of mutable atoms, allowing for the dynamic creation and disposal of atoms.
  *
@@ -130,9 +119,8 @@ export type MutableAtomFamilyOptions<
  * A reference to the atom family created: a {@link MutableAtomFamilyToken}
  */
 export function mutableAtomFamily<
-	T extends Transceiver<any>,
-	J extends Json.Serializable,
+	T extends Transceiver<any, any>,
 	K extends Canonical,
->(options: MutableAtomFamilyOptions<T, J, K>): MutableAtomFamilyToken<T, J, K> {
+>(options: MutableAtomFamilyOptions<T, K>): MutableAtomFamilyToken<T, K> {
 	return createMutableAtomFamily(IMPLICIT.STORE, options)
 }

package/src/main/dispose-state.ts

@@ -25,13 +25,13 @@ export function disposeState<K extends Canonical>(
 	key: K,
 ): void
 export function disposeState(
-	...[token, key]:
+	...params:
 		| [token: ReadableFamilyToken<any, any>, key: Canonical]
 		| [token: ReadableToken<any>]
 ): void {
-	if (key) {
-		Internal.disposeFromStore(Internal.IMPLICIT.STORE, token as any, key)
+	if (params.length === 2) {
+		Internal.disposeFromStore(Internal.IMPLICIT.STORE, ...params)
 	} else {
-		Internal.disposeFromStore(Internal.IMPLICIT.STORE, token as any)
+		Internal.disposeFromStore(Internal.IMPLICIT.STORE, ...params)
 	}
 }

package/src/main/find-state.ts

@@ -12,7 +12,7 @@ import type {
 } from "atom.io"
 import type { Transceiver } from "atom.io/internal"
 import { findInStore, IMPLICIT } from "atom.io/internal"
-import type { Canonical, Json } from "atom.io/json"
+import type { Canonical } from "atom.io/json"
 
 import type { MutableAtomFamilyToken, RegularAtomFamilyToken } from "./tokens"
 
@@ -30,11 +30,10 @@ import type { MutableAtomFamilyToken, RegularAtomFamilyToken } from "./tokens"
  * @overload Mutable Atom
  */
 export function findState<
-	T extends Transceiver<any>,
-	J extends Json.Serializable,
+	T extends Transceiver<any, any>,
 	K extends Canonical,
 	Key extends K,
->(token: MutableAtomFamilyToken<T, J, K>, key: Key): MutableAtomToken<T, J, K>
+>(token: MutableAtomFamilyToken<T, K>, key: Key): MutableAtomToken<T, K>
 /**
  * Finds a {@link RegularAtomToken} in the store, without accessing its value.
  *

package/src/main/join.ts

@@ -14,7 +14,7 @@ import {
 	IMPLICIT,
 } from "atom.io/internal"
 import type { Json } from "atom.io/json"
-import type { SetRTX, SetRTXJson } from "atom.io/transceivers/set-rtx"
+import type { SetRTX } from "atom.io/transceivers/set-rtx"
 
 // biome-ignore format: intersection
 export type JoinOptions<
@@ -262,6 +262,6 @@ export function getInternalRelations<
 	Content extends Json.Object | null,
 >(
 	token: JoinToken<ASide, AType, BSide, BType, Cardinality, Content>,
-): MutableAtomFamilyToken<SetRTX<string>, SetRTXJson<string>, string> {
+): MutableAtomFamilyToken<SetRTX<string>, string> {
 	return getInternalRelationsFromStore(token, IMPLICIT.STORE)
 }

package/src/main/logger.ts

@@ -105,7 +105,7 @@ export const simpleLogger: Logger = {
 
 export class AtomIOLogger implements Logger {
 	public logLevel: `error` | `info` | `warn` | null
-	private readonly filter: LogFilter | undefined
+	public filter: LogFilter | undefined
 	private readonly logger: Logger
 
 	public constructor(
@@ -119,31 +119,31 @@ export class AtomIOLogger implements Logger {
 	}
 
 	public error: LogFn = (...args) => {
-		const filterResult = this.filter?.(...args) ?? true
 		if (this.logLevel !== null) {
+			const filterResult = this.filter?.(...args) ?? true
 			if (filterResult === true) {
 				this.logger.error(...args)
-			} else if (filterResult !== false) {
+			} else if (filterResult) {
 				this.logger.error(...filterResult)
 			}
 		}
 	}
 	public info: LogFn = (...args) => {
-		const filterResult = this.filter?.(...args) ?? true
 		if (this.logLevel === `info`) {
+			const filterResult = this.filter?.(...args) ?? true
 			if (filterResult === true) {
 				this.logger.info(...args)
-			} else if (filterResult !== false) {
+			} else if (filterResult) {
 				this.logger.info(...filterResult)
 			}
 		}
 	}
 	public warn: LogFn = (...args) => {
-		const filterResult = this.filter?.(...args) ?? true
 		if (this.logLevel !== `error` && this.logLevel !== null) {
+			const filterResult = this.filter?.(...args) ?? true
 			if (filterResult === true) {
 				this.logger.warn(...args)
-			} else if (filterResult !== false) {
+			} else if (filterResult) {
 				this.logger.warn(...filterResult)
 			}
 		}

package/src/main/tokens.ts

@@ -1,5 +1,5 @@
-import type { Func, Transceiver } from "atom.io/internal"
-import type { Canonical, Json, stringified } from "atom.io/json"
+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.
@@ -63,7 +63,7 @@ export type TransactionToken<F extends Func> = {
 }
 
 export type AtomToken<T, K extends Canonical = any> =
-	| MutableAtomToken<T extends Transceiver<any> ? T : never, any, K>
+	| 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. */
@@ -76,8 +76,7 @@ export type RegularAtomToken<T, K extends Canonical = any> = {
 	__T?: T
 }
 export type MutableAtomToken<
-	T extends Transceiver<any>,
-	J extends Json.Serializable,
+	T extends Transceiver<any, any>,
 	K extends Canonical = any,
 > = {
 	/** The unique identifier of the atom. */
@@ -87,9 +86,9 @@ export type MutableAtomToken<
 	/** 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
+	__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> ? Update : never
+	__U?: T extends Transceiver<infer Update, any> ? Update : never
 }
 
 export type SelectorToken<T, K extends Canonical = any> =
@@ -160,7 +159,7 @@ export type FamilyMetadata<K extends Canonical = any> = {
 }
 
 export type AtomFamilyToken<T, K extends Canonical = Canonical> =
-	| MutableAtomFamilyToken<T extends Transceiver<any> ? T : never, any, K>
+	| 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 */
@@ -173,8 +172,7 @@ export type RegularAtomFamilyToken<T, K extends Canonical> = {
 	__K?: K
 }
 export type MutableAtomFamilyToken<
-	T extends Transceiver<any>,
-	J extends Json.Serializable,
+	T extends Transceiver<any, any>,
 	K extends Canonical,
 > = {
 	/** The unique identifier of the atom family */
@@ -184,7 +182,7 @@ export type MutableAtomFamilyToken<
 	/** 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
+	__J?: AsJSON<T>
 	/** Never present. This is a marker that preserves the type of keys used for atoms in this family */
 	__K?: K
 }

package/src/main/transaction.ts

@@ -1,11 +1,16 @@
-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"
@@ -55,6 +60,7 @@ export type MoleculeDisposal = {
 export type MoleculeTransfer = {
 	type: `molecule_transfer`
 	key: Canonical
+	exclusive: boolean
 	from: Canonical[]
 	to: Canonical[]
 }
@@ -85,9 +91,9 @@ export type ActorToolkit = Readonly<{
 	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

package/src/main/validators.ts

@@ -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/realtime/shared-room-store.ts

@@ -4,27 +4,19 @@ import type {
 	ReadonlyPureSelectorFamilyToken,
 } 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>
-> = mutableAtom<SetRTX<string>, SetRTXJson<string>>({
-	key: `usersInRoomIndex`,
-	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>
-> = mutableAtom<SetRTX<string>, SetRTXJson<string>>({
+export const roomIndex: MutableAtomToken<SetRTX<string>> = mutableAtom<
+	SetRTX<string>
+>({
 	key: `roomIndex`,
-	default: () => new SetRTX<string>(),
-	toJson: (set) => set.toJSON(),
-	fromJson: (json) => SetRTX.fromJSON(json),
+	class: SetRTX,
 })
 
 export type UserInRoomMeta = {
@@ -52,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) =>

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

@@ -1,19 +1,15 @@
 import type * as AtomIO from "atom.io"
-import type { Store, Transceiver } from "atom.io/internal"
+import type { AsJSON, Store, Transceiver } from "atom.io/internal"
 import { getJsonToken, getUpdateToken, setIntoStore } from "atom.io/internal"
-import type { Json } from "atom.io/json"
 import { parseJson } from "atom.io/json"
 import type { Socket } from "socket.io-client"
 
 /* eslint-disable no-console */
 
-export function pullMutableAtomFamilyMember<
-	T extends Transceiver<any>,
-	J extends Json.Serializable,
->(
+export function pullMutableAtomFamilyMember<T extends Transceiver<any, any>>(
 	store: Store,
 	socket: Socket,
-	token: AtomIO.MutableAtomToken<T, J>,
+	token: AtomIO.MutableAtomToken<T>,
 ): () => void {
 	if (!(`family` in token)) {
 		console.error(`Token is not a family member:`, token)
@@ -21,13 +17,13 @@ export function pullMutableAtomFamilyMember<
 	}
 	const { key: familyKey, subKey: serializedSubKey } = token.family
 	const subKey = parseJson(serializedSubKey)
-	socket.on(`init:${token.key}`, (data: J) => {
+	socket.on(`init:${token.key}`, (data: AsJSON<T>) => {
 		const jsonToken = getJsonToken(store, token)
 		setIntoStore(store, jsonToken, data)
 	})
 	socket.on(
 		`next:${token.key}`,
-		(data: T extends Transceiver<infer Signal> ? Signal : never) => {
+		(data: T extends Transceiver<infer Signal, any> ? Signal : never) => {
 			const trackerToken = getUpdateToken(token)
 			setIntoStore(store, trackerToken, data)
 		},

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

@@ -1,25 +1,21 @@
 import type * as AtomIO from "atom.io"
-import type { Store, Transceiver } from "atom.io/internal"
+import type { AsJSON, Store, Transceiver } from "atom.io/internal"
 import { getJsonToken, getUpdateToken, setIntoStore } from "atom.io/internal"
-import type { Json } from "atom.io/json"
 import type { Socket } from "socket.io-client"
 
-export function pullMutableAtom<
-	T extends Transceiver<any>,
-	J extends Json.Serializable,
->(
+export function pullMutableAtom<T extends Transceiver<any, any>>(
 	store: Store,
 	socket: Socket,
-	token: AtomIO.MutableAtomToken<T, J>,
+	token: AtomIO.MutableAtomToken<T>,
 ): () => void {
 	const jsonToken = getJsonToken(store, token)
 	const updateToken = getUpdateToken(token)
-	socket.on(`init:${token.key}`, (data: J) => {
+	socket.on(`init:${token.key}`, (data: AsJSON<T>) => {
 		setIntoStore(store, jsonToken, data)
 	})
 	socket.on(
 		`next:${token.key}`,
-		(data: T extends Transceiver<infer Update> ? Update : never) => {
+		(data: T extends Transceiver<infer Update, any> ? Update : never) => {
 			setIntoStore(store, updateToken, data)
 		},
 	)

package/src/realtime-react/use-pull-mutable-atom.ts

@@ -1,16 +1,14 @@
 import type * as AtomIO from "atom.io"
 import type { Transceiver } from "atom.io/internal"
-import type { Json } from "atom.io/json"
 import { StoreContext, useO } from "atom.io/react"
 import * as RTC from "atom.io/realtime-client"
 import * as React from "react"
 
 import { useRealtimeService } from "./use-realtime-service"
 
-export function usePullMutable<
-	T extends Transceiver<any>,
-	J extends Json.Serializable,
->(token: AtomIO.MutableAtomToken<T, J>): T {
+export function usePullMutable<T extends Transceiver<any, any>>(
+	token: AtomIO.MutableAtomToken<T>,
+): T {
 	const store = React.useContext(StoreContext)
 	useRealtimeService(`pull:${token.key}`, (socket) =>
 		RTC.pullMutableAtom(store, socket, token),

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

@@ -1,7 +1,7 @@
 import type * as AtomIO from "atom.io"
 import type { Transceiver } from "atom.io/internal"
 import { findInStore } from "atom.io/internal"
-import type { Canonical, Json } from "atom.io/json"
+import type { Canonical } from "atom.io/json"
 import { StoreContext, useO } from "atom.io/react"
 import * as RTC from "atom.io/realtime-client"
 import * as React from "react"
@@ -9,11 +9,10 @@ import * as React from "react"
 import { useRealtimeService } from "./use-realtime-service"
 
 export function usePullMutableAtomFamilyMember<
-	T extends Transceiver<any>,
-	J extends Json.Serializable,
+	T extends Transceiver<any, any>,
 	K extends Canonical,
 	Key extends K,
->(familyToken: AtomIO.MutableAtomFamilyToken<T, J, K>, key: Key): T {
+>(familyToken: AtomIO.MutableAtomFamilyToken<T, K>, key: Key): T {
 	const store = React.useContext(StoreContext)
 	const token = findInStore(store, familyToken, key)
 	useRealtimeService(`pull:${token.key}`, (socket) =>

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

@@ -8,7 +8,7 @@ import {
 	IMPLICIT,
 	subscribeToState,
 } from "atom.io/internal"
-import type { Canonical, Json } from "atom.io/json"
+import type { Canonical } from "atom.io/json"
 import { stringifyJson } from "atom.io/json"
 
 import type { ServerConfig } from "."
@@ -21,11 +21,10 @@ export function realtimeMutableFamilyProvider({
 	store = IMPLICIT.STORE,
 }: ServerConfig) {
 	return function mutableFamilyProvider<
-		T extends Transceiver<any>,
-		J extends Json.Serializable,
+		T extends Transceiver<any, any>,
 		K extends Canonical,
 	>(
-		family: AtomIO.MutableAtomFamilyToken<T, J, K>,
+		family: AtomIO.MutableAtomFamilyToken<T, K>,
 		index: AtomIO.ReadableToken<Iterable<K>>,
 	): () => void {
 		const unsubCallbacksByKey = new Map<string, () => void>()

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

@@ -17,9 +17,8 @@ export function realtimeMutableProvider({
 	store = IMPLICIT.STORE,
 }: ServerConfig) {
 	return function mutableProvider<
-		Core extends Transceiver<Json.Serializable>,
-		SerializableCore extends Json.Serializable,
-	>(token: AtomIO.MutableAtomToken<Core, SerializableCore>): () => void {
+		Core extends Transceiver<Json.Serializable, Json.Serializable>,
+	>(token: AtomIO.MutableAtomToken<Core>): () => void {
 		let unsubscribeFromStateUpdates: (() => void) | null = null
 
 		const jsonToken = getJsonToken(store, token)

package/src/realtime-server/realtime-server-stores/server-room-external-actions.ts

@@ -7,10 +7,11 @@ import { roomIndex, usersInRooms } from "atom.io/realtime"
 import type { ChildSocket } from "../ipc-sockets"
 import type { RoomArguments } from "./server-room-external-store"
 import { roomArgumentsAtoms, roomSelectors } from "./server-room-external-store"
+import type { RoomKey } from "./server-user-store"
 
 export const createRoomTX: AtomIO.TransactionToken<
 	(
-		roomId: string,
+		roomKey: RoomKey,
 		script: string,
 		options?: string[],
 	) => Loadable<ChildSocket<any, any>>
@@ -62,17 +63,17 @@ export const leaveRoomTX: AtomIO.TransactionToken<
 })
 export type LeaveRoomIO = AtomIO.TransactionIO<typeof leaveRoomTX>
 
-export const destroyRoomTX: AtomIO.TransactionToken<(roomId: string) => void> =
+export const destroyRoomTX: AtomIO.TransactionToken<(roomKey: RoomKey) => void> =
 	AtomIO.transaction({
 		key: `destroyRoom`,
-		do: (tools, roomId) => {
+		do: (tools, roomKey) => {
 			editRelationsInStore(
 				usersInRooms,
 				(relations) => {
-					relations.delete({ room: roomId })
+					relations.delete({ room: roomKey })
 				},
 				tools.env().store,
 			)
-			tools.set(roomIndex, (s) => (s.delete(roomId), s))
+			tools.set(roomIndex, (s) => (s.delete(roomKey), s))
 		},
 	})

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

@@ -5,7 +5,6 @@ import type {
 	RegularAtomFamilyToken,
 } 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"
 
 import type { Socket } from ".."
@@ -29,23 +28,17 @@ export const socketAtoms: RegularAtomFamilyToken<Socket | null, SocketKey> =
 		default: null,
 	})
 
-export const socketIndex: MutableAtomToken<
-	SetRTX<SocketKey>,
-	SetRTXJson<SocketKey>
-> = mutableAtom<SetRTX<SocketKey>, SetRTXJson<SocketKey>>({
+export const socketIndex: MutableAtomToken<SetRTX<SocketKey>> = mutableAtom<
+	SetRTX<SocketKey>
+>({
 	key: `socketsIndex`,
-	default: () => new SetRTX(),
-	toJson: (set) => set.toJSON(),
-	fromJson: (json) => SetRTX.fromJSON(json),
+	class: SetRTX,
 })
-export const userIndex: MutableAtomToken<
-	SetRTX<UserKey>,
-	SetRTXJson<UserKey>
-> = mutableAtom<SetRTX<UserKey>, SetRTXJson<UserKey>>({
+export const userIndex: MutableAtomToken<SetRTX<UserKey>> = mutableAtom<
+	SetRTX<UserKey>
+>({
 	key: `usersIndex`,
-	default: () => new SetRTX(),
-	toJson: (set) => set.toJSON(),
-	fromJson: (json) => SetRTX.fromJSON(json),
+	class: SetRTX,
 })
 export const usersOfSockets: JoinToken<
 	`user`,