atom.io 0.45.5 → 0.46.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atom.io",
-  "version": "0.45.5",
+  "version": "0.46.1",
   "description": "Composable and testable reactive data library.",
   "homepage": "https://atom.io.fyi",
   "sideEffects": false,
@@ -60,19 +60,19 @@
     }
   },
   "devDependencies": {
-    "@storybook/addon-docs": "10.1.4",
-    "@storybook/addon-onboarding": "10.1.4",
-    "@storybook/react-vite": "10.1.4",
+    "@storybook/addon-docs": "10.1.5",
+    "@storybook/addon-onboarding": "10.1.5",
+    "@storybook/react-vite": "10.1.5",
     "@testing-library/react": "16.3.0",
     "@types/eslint": "9.6.1",
     "@types/estree": "1.0.8",
     "@types/http-proxy": "1.17.17",
     "@types/react": "19.2.7",
     "@types/tmp": "0.2.6",
-    "@typescript-eslint/parser": "8.48.1",
-    "@typescript-eslint/rule-tester": "8.48.1",
-    "@typescript-eslint/utils": "8.48.1",
-    "@typescript/native-preview": "7.0.0-dev.20251208.1",
+    "@typescript-eslint/parser": "8.49.0",
+    "@typescript-eslint/rule-tester": "8.49.0",
+    "@typescript-eslint/utils": "8.49.0",
+    "@typescript/native-preview": "7.0.0-dev.20251209.1",
     "@vitest/coverage-v8": "4.0.15",
     "@vitest/ui": "4.0.15",
     "arktype": "2.1.28",
@@ -91,9 +91,9 @@
     "recoverage": "0.1.13",
     "socket.io": "4.8.1",
     "socket.io-client": "4.8.1",
-    "storybook": "10.1.4",
+    "storybook": "10.1.5",
     "tmp": "0.2.5",
-    "tsdown": "0.17.1",
+    "tsdown": "0.17.2",
     "vite": "7.2.7",
     "vite-tsconfig-paths": "5.1.4",
     "vitest": "4.0.15",

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

@@ -15,25 +15,16 @@ export function subscribeToState<T, E>(
 	handleUpdate: UpdateHandler<E | T>,
 ): () => 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}`,
-				() => {
-					unsubscribe()
-					handleUpdate(update)
-				},
-			)
-		} else {
-			handleUpdate(update)
+		if (
+			store.operation.open &&
+			state?.type === `atom` &&
+			hasRole(state, `tracker:signal`) &&
+			`*` + store.operation.token.key === token.key &&
+			`inboundTracker` in handleUpdate
+		) {
+			return
 		}
+		handleUpdate(update)
 	}
 	reduceReference(store, token)
 	const state = withdraw(store, token)

package/src/realtime/cast-socket.ts

@@ -61,6 +61,7 @@ export function castSocket<T extends TypedSocket>(
 				})
 			})
 		},
+		onAnyOutgoing: socket.onAnyOutgoing.bind(socket),
 		off: socket.off.bind(socket),
 		offAny: socket.offAny.bind(socket),
 		emit: socket.emit.bind(socket),

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

@@ -1,6 +1,7 @@
 import type {
 	JoinToken,
 	MutableAtomToken,
+	PureSelectorFamilyToken,
 	ReadonlyPureSelectorFamilyToken,
 } from "atom.io"
 import { getInternalRelations, join, mutableAtom, selectorFamily } from "atom.io"
@@ -41,6 +42,20 @@ export const usersInRooms: JoinToken<`room`, RoomKey, `user`, UserKey, `1:n`> =
 		isBType: isUserKey,
 	})
 
+export const visibleUsersInRoomsSelector: PureSelectorFamilyToken<
+	(RoomKey | UserKey)[],
+	UserKey
+> = selectorFamily({
+	key: `selfList`,
+	get:
+		(userKey) =>
+		({ get }) => {
+			const [, roomsOfUsersAtoms] = getInternalRelations(usersInRooms, `split`)
+			const rooms = get(roomsOfUsersAtoms, userKey)
+			return [userKey, ...rooms]
+		},
+})
+
 export const ownersOfRooms: JoinToken<`user`, UserKey, `room`, RoomKey, `1:n`> =
 	join({
 		key: `ownersOfRooms`,

package/src/realtime/socket-interface.ts

@@ -28,11 +28,12 @@ export type EventEmitter<EmitEvents extends EventsMap = EventsMap> = <
 
 export type TypedSocket<
 	ListenEvents extends EventsMap = EventsMap,
-	EmitEvents extends EventsMap = EventsMap,
+	EmitEvents extends EventsMap = never,
 > = {
 	id: string | undefined
 	on: ParticularEventListener<ListenEvents>
 	onAny: (listener: AllEventsListener<ListenEvents>) => void
+	onAnyOutgoing: (listener: AllEventsListener<EmitEvents>) => void
 	off: ParticularEventListener<ListenEvents>
 	offAny: (listener: AllEventsListener<ListenEvents>) => void
 	emit: EventEmitter<EmitEvents>
@@ -44,6 +45,9 @@ export type Socket = {
 	onAny: (
 		listener: (event: string, ...args: Json.Serializable[]) => void,
 	) => void
+	onAnyOutgoing: (
+		listener: (event: string, ...args: Json.Serializable[]) => void,
+	) => void
 	off: (event: string, listener: (...args: Json.Serializable[]) => void) => void
 	offAny: (
 		listener: (event: string, ...args: Json.Serializable[]) => void,

package/src/realtime-server/index.ts

@@ -1,9 +1,10 @@
 export * from "./continuity/provide-continuity"
 export * from "./ipc-sockets"
+export * from "./provide-rooms"
 export * from "./realtime-family-provider"
 export * from "./realtime-mutable-family-provider"
 export * from "./realtime-mutable-provider"
-export * from "./realtime-server-stores"
 export * from "./realtime-state-provider"
 export * from "./realtime-state-receiver"
-export type * from "./server-config"
+export * from "./server-config"
+export * from "./server-socket-state"

package/src/realtime-server/ipc-sockets/custom-socket.ts

@@ -20,6 +20,9 @@ export abstract class CustomSocket<I extends Events, O extends Events>
 {
 	protected listeners: Map<keyof O, Set<(...args: Json.Array) => void>>
 	protected globalListeners: Set<(event: string, ...args: Json.Array) => void>
+	protected globalListenersOutgoing: Set<
+		(event: string, ...args: Json.Array) => void
+	>
 	protected handleEvent<K extends string & keyof I>(
 		...args: EventPayload<I, K>
 	): void {
@@ -36,7 +39,7 @@ export abstract class CustomSocket<I extends Events, O extends Events>
 	}
 
 	public id = `no_id_retrieved`
-	public emit: <Event extends keyof I>(
+	public emit: <Event extends string & keyof I>(
 		event: Event,
 		...args: I[Event]
 	) => CustomSocket<I, O>
@@ -47,9 +50,15 @@ export abstract class CustomSocket<I extends Events, O extends Events>
 			...args: I[Event]
 		) => CustomSocket<I, O>,
 	) {
-		this.emit = emit
+		this.emit = (...args) => {
+			for (const listener of this.globalListenersOutgoing) {
+				listener(...args)
+			}
+			return emit(...args)
+		}
 		this.listeners = new Map()
 		this.globalListeners = new Set()
+		this.globalListenersOutgoing = new Set()
 	}
 
 	public on<Event extends keyof O>(
@@ -70,6 +79,13 @@ export abstract class CustomSocket<I extends Events, O extends Events>
 		return this
 	}
 
+	public onAnyOutgoing(
+		listener: (event: string, ...args: Json.Array) => void,
+	): this {
+		this.globalListenersOutgoing.add(listener)
+		return this
+	}
+
 	public off<Event extends keyof O>(
 		event: Event,
 		listener?: (...args: O[Event]) => void,

package/src/realtime-server/ipc-sockets/parent-socket.ts

@@ -190,7 +190,7 @@ export class ParentSocket<
 				relay.in.next(data)
 			})
 			relay.out.subscribe(`socket`, (data) => {
-				this.emit(...(data as [string, ...I[keyof I]]))
+				this.emit(...(data as [string, ...I[string & keyof I]]))
 			})
 		})
 

package/src/realtime-server/{realtime-server-stores/provide-rooms.ts → provide-rooms.ts}

@@ -19,7 +19,6 @@ import type {
 	RoomSocketInterface,
 	Socket,
 	SocketGuard,
-	SocketKey,
 	StandardSchemaV1,
 	TypedSocket,
 	UserKey,
@@ -30,18 +29,13 @@ import {
 	ownersOfRooms,
 	roomKeysAtom,
 	usersInRooms,
+	visibleUsersInRoomsSelector,
 } from "atom.io/realtime"
 
-import { ChildSocket } from "../ipc-sockets"
-import { realtimeMutableFamilyProvider } from "../realtime-mutable-family-provider"
-import { realtimeMutableProvider } from "../realtime-mutable-provider"
-import type { ServerConfig } from "../server-config"
-import {
-	selfListSelectors,
-	socketKeysAtom,
-	userKeysAtom,
-	usersOfSockets,
-} from "./server-user-store"
+import { ChildSocket } from "./ipc-sockets"
+import { realtimeMutableFamilyProvider } from "./realtime-mutable-family-provider"
+import { realtimeMutableProvider } from "./realtime-mutable-provider"
+import type { ServerConfig } from "./server-config"
 
 export type RoomMap = Map<
 	string,
@@ -240,74 +234,55 @@ export function provideRooms<RoomNames extends string>({
 	socket,
 	resolveRoomScript,
 	roomNames,
-}: ProvideRoomsConfig<RoomNames> & ServerConfig): void {
-	const socketKey = `socket::${socket.id}` satisfies SocketKey
-	const userKey = getFromStore(
-		store,
-		findRelationsInStore(store, usersOfSockets, socketKey).userKeyOfSocket,
-	)!
-	// const roomSocket = socket as TypedSocket<RoomSocketInterface<RoomNames>, {}>
-	const roomSocket = castSocket<TypedSocket<RoomSocketInterface<RoomNames>, {}>>(
-		socket,
-		createRoomSocketGuard(roomNames),
-	)
-
+	userKey,
+}: ProvideRoomsConfig<RoomNames> & ServerConfig): () => void {
+	const roomSocket = castSocket<
+		TypedSocket<RoomSocketInterface<RoomNames>, never>
+	>(socket, createRoomSocketGuard(roomNames))
 	const exposeMutable = realtimeMutableProvider({ socket, store, userKey })
-	const exposeMutableFamily = realtimeMutableFamilyProvider({
-		socket,
-		store,
-		userKey,
-	})
-
-	exposeMutable(roomKeysAtom)
-
-	const [, usersInRoomsAtoms] = getInternalRelationsFromStore(
+	const unsubFromRoomKeys = exposeMutable(roomKeysAtom)
+	const usersInRoomsAtoms = getInternalRelationsFromStore(store, usersInRooms)
+	const [, usersInRoomsAtomsUsersOnly] = getInternalRelationsFromStore(
 		store,
 		usersInRooms,
 		`split`,
 	)
 	const usersWhoseRoomsCanBeSeenSelector = findInStore(
 		store,
-		selfListSelectors,
+		visibleUsersInRoomsSelector,
 		userKey,
 	)
-	exposeMutableFamily(usersInRoomsAtoms, usersWhoseRoomsCanBeSeenSelector)
-	// const usersOfSocketsAtoms = getInternalRelationsFromStore(
-	// 	store,
-	// 	usersOfSockets,
-	// )
-	// exposeMutableFamily(usersOfSocketsAtoms, socketKeysAtom)
-	const [ownersOfRoomsAtoms] = getInternalRelationsFromStore(
+	const ownersOfRoomsAtoms = getInternalRelationsFromStore(store, ownersOfRooms)
+	const exposeMutableFamily = realtimeMutableFamilyProvider({
+		socket,
 		store,
-		ownersOfRooms,
-		`split`,
+		userKey,
+	})
+	const unsubFromUsersInRooms = exposeMutableFamily(
+		usersInRoomsAtoms,
+		usersWhoseRoomsCanBeSeenSelector,
+	)
+	const unsubFromOwnersOfRooms = exposeMutableFamily(
+		ownersOfRoomsAtoms,
+		usersWhoseRoomsCanBeSeenSelector,
 	)
-	exposeMutableFamily(ownersOfRoomsAtoms, usersWhoseRoomsCanBeSeenSelector)
-
 	const enterRoom = provideEnterAndExit({ store, socket, roomSocket, userKey })
 
-	const userRoomSet = getFromStore(store, usersInRoomsAtoms, userKey)
+	const userRoomSet = getFromStore(store, usersInRoomsAtomsUsersOnly, userKey)
 	for (const userRoomKey of userRoomSet) {
 		enterRoom(userRoomKey)
 		break
 	}
-
 	roomSocket.on(
 		`createRoom`,
 		spawnRoom({ store, socket, userKey, resolveRoomScript }),
 	)
 	roomSocket.on(`deleteRoom`, destroyRoom({ store, socket, userKey }))
-	socket.on(`disconnect`, () => {
-		store.logger.info(
-			`📡`,
-			`socket`,
-			socket.id ?? `[ID MISSING?!]`,
-			`👤 ${userKey} disconnects`,
-		)
-		editRelationsInStore(store, usersOfSockets, (rel) => rel.delete(socketKey))
-		setIntoStore(store, userKeysAtom, (keys) => (keys.delete(userKey), keys))
-		setIntoStore(store, socketKeysAtom, (keys) => (keys.delete(socketKey), keys))
-	})
+	return () => {
+		unsubFromRoomKeys()
+		unsubFromUsersInRooms()
+		unsubFromOwnersOfRooms()
+	}
 }
 
 const roomKeySchema: StandardSchemaV1<Json.Array, [RoomKey]> = {

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

@@ -21,9 +21,11 @@ export function realtimeStateProvider({
 	store = IMPLICIT.STORE,
 }: ServerConfig) {
 	store.logger.info(`🔌`, `user`, userKey, `initialized state provider`)
-	return function stateProvider<J extends Json.Serializable>(
-		clientToken: AtomIO.WritableToken<J>,
-		serverData: AtomIO.ReadableToken<NoInfer<J>> | NoInfer<J> = clientToken,
+	return function stateProvider<C extends Json.Serializable, S extends C>(
+		clientToken: AtomIO.WritableToken<C>,
+		serverData:
+			| AtomIO.ReadableToken<S>
+			| S = clientToken as AtomIO.ReadableToken<S>,
 	): () => void {
 		const isStatic = !isReadableToken(serverData)
 

package/src/realtime-server/realtime-state-receiver.ts

@@ -9,6 +9,7 @@ import {
 	subscribeToState,
 } from "atom.io/internal"
 import type { Json } from "atom.io/json"
+import type { SocketKey, StandardSchemaV1 } from "atom.io/realtime"
 import { employSocket, mutexAtoms } from "atom.io/realtime"
 
 import type { ServerConfig } from "."
@@ -16,12 +17,15 @@ import type { ServerConfig } from "."
 export type StateReceiver = ReturnType<typeof realtimeStateReceiver>
 export function realtimeStateReceiver({
 	socket,
+	userKey,
 	store = IMPLICIT.STORE,
 }: ServerConfig) {
 	return function stateReceiver<S extends Json.Serializable, C extends S>(
+		schema: StandardSchemaV1<unknown, C>,
 		clientToken: WritableToken<C>,
 		serverToken: WritableToken<S> = clientToken,
 	): () => void {
+		const socketKey = `socket::${socket.id}` satisfies SocketKey
 		const mutexAtom = findInStore(store, mutexAtoms, serverToken.key)
 
 		const subscriptions = new Set<() => void>()
@@ -33,8 +37,20 @@ export function realtimeStateReceiver({
 		const permitPublish = () => {
 			clearSubscriptions()
 			subscriptions.add(
-				employSocket(socket, `pub:${clientToken.key}`, (newValue) => {
-					setIntoStore(store, serverToken, newValue as C)
+				employSocket(socket, `pub:${clientToken.key}`, async (newValue) => {
+					const parsed = await schema[`~standard`].validate(newValue)
+					if (parsed.issues) {
+						store.logger.error(
+							`❌`,
+							`user`,
+							userKey,
+							`attempted to publish invalid value`,
+							newValue,
+							`to state "${serverToken.key}"`,
+						)
+						return
+					}
+					setIntoStore(store, serverToken, parsed.value)
 				}),
 			)
 			subscriptions.add(
@@ -52,7 +68,7 @@ export function realtimeStateReceiver({
 					if (getFromStore(store, mutexAtom)) {
 						clearSubscriptions()
 						subscriptions.add(
-							subscribeToState(store, mutexAtom, socket.id!, () => {
+							subscribeToState(store, mutexAtom, socketKey, () => {
 								const currentValue = getFromStore(store, mutexAtom)
 								if (currentValue === false) {
 									operateOnStore(OWN_OP, store, mutexAtom, true)

package/src/realtime-server/server-config.ts

@@ -1,8 +1,119 @@
+import type { IncomingHttpHeaders } from "node:http"
+import type { ParsedUrlQuery } from "node:querystring"
+
+import { Realm } from "atom.io"
 import type { RootStore } from "atom.io/internal"
-import type { Socket, UserKey } from "atom.io/realtime"
+import {
+	editRelationsInStore,
+	findInStore,
+	findRelationsInStore,
+	getFromStore,
+	IMPLICIT,
+	setIntoStore,
+} from "atom.io/internal"
+import type { Socket, SocketKey, UserKey } from "atom.io/realtime"
+import type { Server } from "socket.io"
+
+import { realtimeStateProvider } from "./realtime-state-provider"
+import type { SocketSystemHierarchy } from "./server-socket-state"
+import {
+	socketAtoms,
+	socketKeysAtom,
+	userKeysAtom,
+	usersOfSockets,
+} from "./server-socket-state"
 
 export type ServerConfig = {
 	socket: Socket
 	userKey: UserKey
 	store?: RootStore
 }
+
+/** Socket Handshake details--taken from socket.io */
+export type Handshake = {
+	/** The headers sent as part of the handshake */
+	headers: IncomingHttpHeaders
+	/** The date of creation (as string) */
+	time: string
+	/** The ip of the client */
+	address: string
+	/** Whether the connection is cross-domain */
+	xdomain: boolean
+	/** Whether the connection is secure */
+	secure: boolean
+	/** The date of creation (as unix timestamp) */
+	issued: number
+	/** The request URL string */
+	url: string
+	/** The query object */
+	query: ParsedUrlQuery
+	/** The auth object */
+	auth: {
+		[key: string]: any
+	}
+}
+
+export function realtime(
+	server: Server,
+	auth: (handshake: Handshake) => Error | UserKey,
+	onConnect: (config: ServerConfig) => () => void,
+	store: RootStore = IMPLICIT.STORE,
+): () => Promise<void> {
+	const socketRealm = new Realm<SocketSystemHierarchy>(store)
+
+	server
+		.use((socket, next) => {
+			const result = auth(socket.handshake)
+			if (result instanceof Error) {
+				next(result)
+				return
+			}
+			const userClaim = socketRealm.allocate(`root`, result)
+			const socketClaim = socketRealm.allocate(`root`, `socket::${socket.id}`)
+			const socketState = findInStore(store, socketAtoms, socketClaim)
+			setIntoStore(store, socketState, socket)
+			editRelationsInStore(store, usersOfSockets, (relations) => {
+				relations.set(userClaim, socketClaim)
+			})
+			setIntoStore(store, userKeysAtom, (index) => index.add(userClaim))
+			setIntoStore(store, socketKeysAtom, (index) => index.add(socketClaim))
+			next()
+		})
+		.on(`connection`, (socket) => {
+			const socketKey = `socket::${socket.id}` satisfies SocketKey
+			const userKeyState = findRelationsInStore(
+				store,
+				usersOfSockets,
+				socketKey,
+			).userKeyOfSocket
+			const userKey = getFromStore(store, userKeyState)!
+			const serverConfig: ServerConfig = { store, socket, userKey }
+			const provideState = realtimeStateProvider(serverConfig)
+			const unsubFromMyUserKey = provideState(
+				{ key: `myUserKey`, type: `atom` },
+				userKey,
+			)
+
+			const disposeServices = onConnect(serverConfig)
+
+			socket.on(`disconnect`, () => {
+				store.logger.info(`📡`, `socket`, socketKey, `👤 ${userKey} disconnects`)
+				disposeServices()
+				unsubFromMyUserKey()
+				editRelationsInStore(store, usersOfSockets, (rel) =>
+					rel.delete(socketKey),
+				)
+				setIntoStore(store, userKeysAtom, (keys) => (keys.delete(userKey), keys))
+				setIntoStore(
+					store,
+					socketKeysAtom,
+					(keys) => (keys.delete(socketKey), keys),
+				)
+			})
+		})
+
+	const disposeAll = async () => {
+		await server.close()
+	}
+	return disposeAll
+}

package/src/realtime-server/{realtime-server-stores/server-user-store.ts → server-socket-state.ts}

@@ -2,10 +2,9 @@ import type {
 	Hierarchy,
 	JoinToken,
 	MutableAtomToken,
-	PureSelectorFamilyToken,
 	RegularAtomFamilyToken,
 } from "atom.io"
-import { atomFamily, join, mutableAtom, selectorFamily } from "atom.io"
+import { atomFamily, join, mutableAtom } from "atom.io"
 import type { RoomKey, Socket, SocketKey, UserKey } from "atom.io/realtime"
 import { isSocketKey, isUserKey } from "atom.io/realtime"
 import { UList } from "atom.io/transceivers/u-list"
@@ -46,9 +45,3 @@ export const usersOfSockets: JoinToken<
 	isAType: isUserKey,
 	isBType: isSocketKey,
 })
-
-export const selfListSelectors: PureSelectorFamilyToken<UserKey[], UserKey> =
-	selectorFamily({
-		key: `selfList`,
-		get: (userKey) => () => [userKey],
-	})