atom.io 0.6.9 → 0.7.0

package/realtime-testing/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/setup-realtime-test.tsx","../../../anvl/src/object/entries.ts"],"names":["clients"],"mappings":"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","sourcesContent":["import * as http from \"http\"\n\nimport { type RenderResult, prettyDOM, render } from \"@testing-library/react\"\nimport * as AtomIO from \"atom.io\"\nimport * as Internal from \"atom.io/internal\"\nimport * as AR from \"atom.io/react\"\nimport * as RTC from \"atom.io/realtime-react\"\nimport * as Happy from \"happy-dom\"\nimport * as React from \"react\"\nimport * as SocketIO from \"socket.io\"\nimport type { Socket as ClientSocket } from \"socket.io-client\"\nimport { io } from \"socket.io-client\"\n\nimport { recordToEntries } from \"~/packages/anvl/src/object\"\n\nexport type TestSetupOptions = {\n\tserver: (tools: { socket: SocketIO.Socket; silo: AtomIO.Silo }) => void\n}\nexport type TestSetupOptions__SingleClient = TestSetupOptions & {\n\tclient: React.FC\n}\nexport type TestSetupOptions__MultiClient<ClientNames extends string> =\n\tTestSetupOptions & {\n\t\tclients: {\n\t\t\t[K in ClientNames]: React.FC\n\t\t}\n\t}\n\nexport type RealtimeTestTools = {\n\tname: string\n\tsilo: AtomIO.Silo\n\tdispose: () => void\n}\nexport type RealtimeTestClient = RealtimeTestTools & {\n\trenderResult: RenderResult\n\tprettyPrint: () => void\n\treconnect: () => void\n\tdisconnect: () => void\n}\nexport type RealtimeTestServer = RealtimeTestTools & {\n\tport: number\n}\n\nexport type RealtimeTestAPI = {\n\tserver: RealtimeTestServer\n\tteardown: () => void\n}\nexport type RealtimeTestAPI__SingleClient = RealtimeTestAPI & {\n\tclient: RealtimeTestClient\n}\nexport type RealtimeTestAPI__MultiClient<ClientNames extends string> =\n\tRealtimeTestAPI & {\n\t\tclients: Record<ClientNames, RealtimeTestClient>\n\t}\n\nexport const setupRealtimeTestServer = (\n\toptions: TestSetupOptions,\n): RealtimeTestServer => {\n\tconst httpServer = http.createServer((_, res) => res.end(`Hello World!`))\n\tconst address = httpServer.listen().address()\n\tconst port =\n\t\ttypeof address === `string` ? 80 : address === null ? null : address.port\n\tif (port === null) throw new Error(`Could not determine port for test server`)\n\tconst server = new SocketIO.Server(httpServer)\n\tconst silo = new AtomIO.Silo(`SERVER`, Internal.IMPLICIT.STORE)\n\n\tserver.on(`connection`, (socket: SocketIO.Socket) => {\n\t\toptions.server({ socket, silo })\n\t})\n\n\tconst dispose = () => {\n\t\tserver.close()\n\t\tInternal.clearStore(silo.store)\n\t}\n\n\treturn {\n\t\tname: `SERVER`,\n\t\tsilo,\n\t\tdispose,\n\t\tport,\n\t}\n}\nexport const setupRealtimeTestClient = (\n\toptions: TestSetupOptions__SingleClient,\n\tname: string,\n\tport: number,\n): RealtimeTestClient => {\n\tconst socket: ClientSocket = io(`http://localhost:${port}/`)\n\tconst silo = new AtomIO.Silo(name, Internal.IMPLICIT.STORE)\n\n\tconst { document } = new Happy.Window()\n\tdocument.body.innerHTML = `<div id=\"app\"></div>`\n\tconst renderResult = render(\n\t\t<AR.StoreProvider store={silo.store}>\n\t\t\t<RTC.RealtimeProvider socket={socket}>\n\t\t\t\t<options.client />\n\t\t\t</RTC.RealtimeProvider>\n\t\t</AR.StoreProvider>,\n\t\t{\n\t\t\tcontainer: document.querySelector(`#app`) as unknown as HTMLElement,\n\t\t},\n\t)\n\n\tconst prettyPrint = () => console.log(prettyDOM(renderResult.container))\n\n\tconst disconnect = () => socket.disconnect()\n\tconst reconnect = () => socket.connect()\n\n\tconst dispose = () => {\n\t\tsocket.disconnect()\n\t\tInternal.clearStore(silo.store)\n\t}\n\n\treturn {\n\t\tname,\n\t\tsilo,\n\t\trenderResult,\n\t\tprettyPrint,\n\t\tdisconnect,\n\t\treconnect,\n\t\tdispose,\n\t}\n}\n\nexport const singleClient = (\n\toptions: TestSetupOptions__SingleClient,\n): RealtimeTestAPI__SingleClient => {\n\tconst server = setupRealtimeTestServer(options)\n\tconst client = setupRealtimeTestClient(options, `CLIENT`, server.port)\n\n\treturn {\n\t\tclient,\n\t\tserver,\n\t\tteardown: () => {\n\t\t\tclient.dispose()\n\t\t\tserver.dispose()\n\t\t},\n\t}\n}\n\nexport const multiClient = <ClientNames extends string>(\n\toptions: TestSetupOptions__MultiClient<ClientNames>,\n): RealtimeTestAPI__MultiClient<ClientNames> => {\n\tconst server = setupRealtimeTestServer(options)\n\tconst clients = recordToEntries(options.clients).reduce(\n\t\t(clients, [name, client]) => ({\n\t\t\t...clients,\n\t\t\t[name]: setupRealtimeTestClient({ ...options, client }, name, server.port),\n\t\t}),\n\t\t{} as Record<ClientNames, RealtimeTestClient>,\n\t)\n\n\treturn {\n\t\tclients,\n\t\tserver,\n\t\tteardown: () => {\n\t\t\trecordToEntries(clients).forEach(([, client]) => client.dispose())\n\t\t\tserver.dispose()\n\t\t},\n\t}\n}\n","export type Entries<K extends keyof any, V> = [key: K, value: V][]\n\nexport const recordToEntries = <K extends keyof any, V>(\n\tobj: Record<K, V>,\n): Entries<K, V> => Object.entries(obj) as Entries<K, V>\n\nexport const entriesToRecord = <K extends keyof any, V>(\n\tentries: Entries<K, V>,\n): Record<K, V> => Object.fromEntries(entries) as Record<K, V>\n"]}

package/realtime-testing/src/index.ts

@@ -0,0 +1 @@
+export * from "./setup-realtime-test"

package/realtime-testing/src/setup-realtime-test.tsx

@@ -0,0 +1,161 @@
+import * as http from "http"
+
+import { type RenderResult, prettyDOM, render } from "@testing-library/react"
+import * as AtomIO from "atom.io"
+import * as Internal from "atom.io/internal"
+import * as AR from "atom.io/react"
+import * as RTC from "atom.io/realtime-react"
+import * as Happy from "happy-dom"
+import * as React from "react"
+import * as SocketIO from "socket.io"
+import type { Socket as ClientSocket } from "socket.io-client"
+import { io } from "socket.io-client"
+
+import { recordToEntries } from "~/packages/anvl/src/object"
+
+export type TestSetupOptions = {
+	server: (tools: { socket: SocketIO.Socket; silo: AtomIO.Silo }) => void
+}
+export type TestSetupOptions__SingleClient = TestSetupOptions & {
+	client: React.FC
+}
+export type TestSetupOptions__MultiClient<ClientNames extends string> =
+	TestSetupOptions & {
+		clients: {
+			[K in ClientNames]: React.FC
+		}
+	}
+
+export type RealtimeTestTools = {
+	name: string
+	silo: AtomIO.Silo
+	dispose: () => void
+}
+export type RealtimeTestClient = RealtimeTestTools & {
+	renderResult: RenderResult
+	prettyPrint: () => void
+	reconnect: () => void
+	disconnect: () => void
+}
+export type RealtimeTestServer = RealtimeTestTools & {
+	port: number
+}
+
+export type RealtimeTestAPI = {
+	server: RealtimeTestServer
+	teardown: () => void
+}
+export type RealtimeTestAPI__SingleClient = RealtimeTestAPI & {
+	client: RealtimeTestClient
+}
+export type RealtimeTestAPI__MultiClient<ClientNames extends string> =
+	RealtimeTestAPI & {
+		clients: Record<ClientNames, RealtimeTestClient>
+	}
+
+export const setupRealtimeTestServer = (
+	options: TestSetupOptions,
+): RealtimeTestServer => {
+	const httpServer = http.createServer((_, res) => res.end(`Hello World!`))
+	const address = httpServer.listen().address()
+	const port =
+		typeof address === `string` ? 80 : address === null ? null : address.port
+	if (port === null) throw new Error(`Could not determine port for test server`)
+	const server = new SocketIO.Server(httpServer)
+	const silo = new AtomIO.Silo(`SERVER`, Internal.IMPLICIT.STORE)
+
+	server.on(`connection`, (socket: SocketIO.Socket) => {
+		options.server({ socket, silo })
+	})
+
+	const dispose = () => {
+		server.close()
+		Internal.clearStore(silo.store)
+	}
+
+	return {
+		name: `SERVER`,
+		silo,
+		dispose,
+		port,
+	}
+}
+export const setupRealtimeTestClient = (
+	options: TestSetupOptions__SingleClient,
+	name: string,
+	port: number,
+): RealtimeTestClient => {
+	const socket: ClientSocket = io(`http://localhost:${port}/`)
+	const silo = new AtomIO.Silo(name, Internal.IMPLICIT.STORE)
+
+	const { document } = new Happy.Window()
+	document.body.innerHTML = `<div id="app"></div>`
+	const renderResult = render(
+		<AR.StoreProvider store={silo.store}>
+			<RTC.RealtimeProvider socket={socket}>
+				<options.client />
+			</RTC.RealtimeProvider>
+		</AR.StoreProvider>,
+		{
+			container: document.querySelector(`#app`) as unknown as HTMLElement,
+		},
+	)
+
+	const prettyPrint = () => console.log(prettyDOM(renderResult.container))
+
+	const disconnect = () => socket.disconnect()
+	const reconnect = () => socket.connect()
+
+	const dispose = () => {
+		socket.disconnect()
+		Internal.clearStore(silo.store)
+	}
+
+	return {
+		name,
+		silo,
+		renderResult,
+		prettyPrint,
+		disconnect,
+		reconnect,
+		dispose,
+	}
+}
+
+export const singleClient = (
+	options: TestSetupOptions__SingleClient,
+): RealtimeTestAPI__SingleClient => {
+	const server = setupRealtimeTestServer(options)
+	const client = setupRealtimeTestClient(options, `CLIENT`, server.port)
+
+	return {
+		client,
+		server,
+		teardown: () => {
+			client.dispose()
+			server.dispose()
+		},
+	}
+}
+
+export const multiClient = <ClientNames extends string>(
+	options: TestSetupOptions__MultiClient<ClientNames>,
+): RealtimeTestAPI__MultiClient<ClientNames> => {
+	const server = setupRealtimeTestServer(options)
+	const clients = recordToEntries(options.clients).reduce(
+		(clients, [name, client]) => ({
+			...clients,
+			[name]: setupRealtimeTestClient({ ...options, client }, name, server.port),
+		}),
+		{} as Record<ClientNames, RealtimeTestClient>,
+	)
+
+	return {
+		clients,
+		server,
+		teardown: () => {
+			recordToEntries(clients).forEach(([, client]) => client.dispose())
+			server.dispose()
+		},
+	}
+}

package/src/atom.ts

@@ -1,8 +1,13 @@
-import type { Subject } from "atom.io/internal"
-import { atomFamily__INTERNAL, atom__INTERNAL } from "atom.io/internal"
-import type { Json } from "atom.io/json"
+import type { Subject, Transceiver } from "atom.io/internal"
+import {
+	createAtom,
+	createAtomFamily,
+	createMutableAtom,
+	createMutableAtomFamily,
+} from "atom.io/internal"
+import type { Json, JsonInterface } from "atom.io/json"
 
-import type { AtomToken } from "."
+import type { AtomToken, MutableAtomToken } from "."
 
 export type Effectors<T> = {
 	setSelf: <V extends T>(next: V | ((oldValue: T) => V)) => void
@@ -15,11 +20,27 @@ export type AtomOptions<T> = {
 	key: string
 	default: T | (() => T)
 	effects?: AtomEffect<T>[]
-	mutable?: boolean
 }
+// biome-ignore format: complex intersection
+export type MutableAtomOptions<T extends Transceiver<any>, J extends Json.Serializable> = 
+	& JsonInterface<T, J>
+	& Omit<AtomOptions<T>, `default`> 
+	& { 
+			default: ()	=> T
+			mutable: true
+		}
 
-export function atom<T>(options: AtomOptions<T>): AtomToken<T> {
-	return atom__INTERNAL<T>(options)
+export function atom<T extends Transceiver<any>, J extends Json.Serializable>(
+	options: MutableAtomOptions<T, J>,
+): MutableAtomToken<T, J>
+export function atom<T>(options: AtomOptions<T>): AtomToken<T>
+export function atom<T>(
+	options: AtomOptions<any> | MutableAtomOptions<any, any>,
+): AtomToken<any> {
+	if (`mutable` in options) {
+		return createMutableAtom(options)
+	}
+	return createAtom<T>(options)
 }
 
 export type AtomFamilyOptions<T, K extends Json.Serializable> = {
@@ -35,9 +56,43 @@ export type AtomFamily<T, K extends Json.Serializable = Json.Serializable> = ((
 	type: `atom_family`
 	subject: Subject<AtomToken<T>>
 }
+// biome-ignore format: intersection
+export type MutableAtomFamilyOptions<
+	T extends Transceiver<any>,
+	J extends Json.Serializable,
+	K extends Json.Serializable,
+> = 
+	& AtomFamilyOptions<T, K>
+	& JsonInterface<T, J>
+	& { mutable: true }
 
+// biome-ignore format: intersection
+export type MutableAtomFamily<
+	Core extends Transceiver<any>,
+	SerializableCore extends Json.Serializable,
+	Key extends Json.Serializable,
+> = 
+	& JsonInterface<Core, SerializableCore>
+	& ((key: Key) => MutableAtomToken<Core, SerializableCore>) 
+	& {
+			key: `${string}::mutable`
+			type: `atom_family`
+			subject: Subject<MutableAtomToken<Core, SerializableCore>>
+		}
+
+export function atomFamily<
+	T extends Transceiver<any>,
+	J extends Json.Serializable,
+	K extends Json.Serializable,
+>(options: MutableAtomFamilyOptions<T, J, K>): MutableAtomFamily<T, J, K>
 export function atomFamily<T, K extends Json.Serializable>(
 	options: AtomFamilyOptions<T, K>,
-): AtomFamily<T, K> {
-	return atomFamily__INTERNAL<T, K>(options)
+): AtomFamily<T, K>
+export function atomFamily<T, K extends Json.Serializable>(
+	options: AtomFamilyOptions<T, K> | MutableAtomFamilyOptions<any, any, any>,
+): AtomFamily<T, K> | MutableAtomFamily<any, any, any> {
+	if (`mutable` in options) {
+		return createMutableAtomFamily(options)
+	}
+	return createAtomFamily<T, K>(options)
 }

package/src/index.ts

@@ -1,31 +1,23 @@
-import {
-	IMPLICIT,
-	closeOperation,
-	getState__INTERNAL,
-	isAtomDefault,
-	isSelectorDefault,
-	openOperation,
-	setState__INTERNAL,
-	withdraw,
-} from "atom.io/internal"
-import * as __INTERNAL__ from "atom.io/internal"
-import type { Store } from "atom.io/internal"
-
-import type { ƒn } from "~/packages/anvl/src/function"
-import { capitalize } from "~/packages/anvl/src/string/capitalize"
-
-export { ƒn }
+import * as IO from "atom.io/internal"
+import type { Store, Transceiver } from "atom.io/internal"
+import type { Json } from "atom.io/json"
 
 export * from "./atom"
 export * from "./logger"
 export * from "./selector"
 export * from "./silo"
-export * from "./subscribe"
+export {
+	subscribe,
+	subscribeToTimeline,
+	subscribeToTransaction,
+	KeyedStateUpdate,
+	StateUpdate,
+	UpdateHandler,
+} from "./subscribe"
 export * from "./timeline"
 export * from "./transaction"
-export { __INTERNAL__ }
-export type { Store } from "atom.io/internal"
-export type { Json } from "atom.io/json"
+
+export type ƒn = (...parameters: any[]) => any
 
 export type AtomToken<_> = {
 	key: string
@@ -33,6 +25,13 @@ export type AtomToken<_> = {
 	family?: FamilyMetadata
 	__brand?: _
 }
+export interface MutableAtomToken<
+	T extends Transceiver<any>,
+	J extends Json.Serializable,
+> extends AtomToken<T> {
+	__asJSON?: J
+	__update?: T extends Transceiver<infer Update> ? Update : never
+}
 export type SelectorToken<_> = {
 	key: string
 	type: `selector`
@@ -53,11 +52,15 @@ export type FamilyMetadata = {
 	subKey: string
 }
 
+export const capitalize = (str: string): string =>
+	str[0].toUpperCase() + str.slice(1)
+
 export const getState = <T>(
 	token: ReadonlySelectorToken<T> | StateToken<T>,
-	store: Store = IMPLICIT.STORE,
+	store: Store = IO.IMPLICIT.STORE,
 ): T => {
-	const state = withdraw<T>(token, store)
+	const state =
+		IO.withdraw(token, store) ?? IO.withdrawNewFamilyMember(token, store)
 	if (state === null) {
 		throw new Error(
 			`${capitalize(token.type)} "${token.key}" not found in store "${
@@ -65,23 +68,24 @@ export const getState = <T>(
 			}".`,
 		)
 	}
-	return getState__INTERNAL(state, store)
+	return IO.getState__INTERNAL(state, store)
 }
 
 export const setState = <T, New extends T>(
 	token: StateToken<T>,
 	value: New | ((oldValue: T) => New),
-	store: Store = IMPLICIT.STORE,
+	store: Store = IO.IMPLICIT.STORE,
 ): void => {
 	try {
-		openOperation(token, store)
+		IO.openOperation(token, store)
 	} catch (thrown) {
 		if (!(typeof thrown === `symbol`)) {
 			throw thrown
 		}
 		return
 	}
-	const state = withdraw(token, store)
+	const state =
+		IO.withdraw(token, store) ?? IO.withdrawNewFamilyMember(token, store)
 	if (state === null) {
 		throw new Error(
 			`${capitalize(token.type)} "${token.key}" not found in store "${
@@ -89,14 +93,14 @@ export const setState = <T, New extends T>(
 			}".`,
 		)
 	}
-	setState__INTERNAL(state, value, store)
-	closeOperation(store)
+	IO.setState__INTERNAL(state, value, store)
+	IO.closeOperation(store)
 }
 
 export const isDefault = (
 	token: ReadonlySelectorToken<unknown> | StateToken<unknown>,
-	store: Store = IMPLICIT.STORE,
+	store: Store = IO.IMPLICIT.STORE,
 ): boolean =>
 	token.type === `atom`
-		? isAtomDefault(token.key, store)
-		: isSelectorDefault(token.key, store)
+		? IO.isAtomDefault(token.key, store)
+		: IO.isSelectorDefault(token.key, store)

package/src/logger.ts

@@ -1,7 +1,7 @@
 import { IMPLICIT } from "atom.io/internal"
 import type { Store } from "atom.io/internal"
 
-import { doNothing } from "~/packages/anvl/src/function"
+export const NO_OP = (): void => undefined
 
 export type Logger = Pick<Console, `error` | `info` | `warn`>
 export const LOG_LEVELS: ReadonlyArray<keyof Logger> = [
@@ -22,7 +22,7 @@ export const setLogLevel = (
 		LOG_LEVELS.forEach((logLevel) => {
 			if (LOG_LEVELS.indexOf(logLevel) < LOG_LEVELS.indexOf(preferredLevel)) {
 				// biome-ignore lint/style/noNonNullAssertion: we just set it
-				store.config.logger![logLevel] = doNothing
+				store.config.logger![logLevel] = NO_OP
 			} else {
 				// biome-ignore lint/style/noNonNullAssertion: we just set it
 				store.config.logger![logLevel] = logger__INTERNAL[logLevel]
@@ -39,7 +39,7 @@ export const useLogger = (
 		store.config.logger === null
 			? null
 			: LOG_LEVELS.find(
-					(logLevel) => store.config.logger?.[logLevel] !== doNothing,
+					(logLevel) => store.config.logger?.[logLevel] !== NO_OP,
 			  ) ?? null
 	store.config.logger__INTERNAL = { ...logger }
 	setLogLevel(currentLogLevel, store)

package/src/selector.ts

@@ -1,5 +1,5 @@
 import type { Subject } from "atom.io/internal"
-import { selectorFamily__INTERNAL, selector__INTERNAL } from "atom.io/internal"
+import { createSelector, createSelectorFamily } from "atom.io/internal"
 import type { Json } from "atom.io/json"
 
 import type { ReadonlySelectorToken, SelectorToken } from "."
@@ -22,7 +22,7 @@ export function selector<T>(
 export function selector<T>(
 	options: ReadonlySelectorOptions<T> | SelectorOptions<T>,
 ): ReadonlySelectorToken<T> | SelectorToken<T> {
-	return selector__INTERNAL(options)
+	return createSelector(options)
 }
 
 export type SelectorFamilyOptions<T, K extends Json.Serializable> = {
@@ -62,5 +62,5 @@ export function selectorFamily<T, K extends Json.Serializable>(
 export function selectorFamily<T, K extends Json.Serializable>(
 	options: ReadonlySelectorFamilyOptions<T, K> | SelectorFamilyOptions<T, K>,
 ): ReadonlySelectorFamily<T, K> | SelectorFamily<T, K> {
-	return selectorFamily__INTERNAL(options)
+	return createSelectorFamily(options)
 }

package/src/silo.ts

@@ -1,10 +1,12 @@
 import {
 	Store,
-	atomFamily__INTERNAL,
-	atom__INTERNAL,
+	createAtom,
+	createAtomFamily,
+	createMutableAtom,
+	createMutableAtomFamily,
+	createSelector,
+	createSelectorFamily,
 	redo__INTERNAL,
-	selectorFamily__INTERNAL,
-	selector__INTERNAL,
 	timeline__INTERNAL,
 	transaction__INTERNAL,
 	undo__INTERNAL,
@@ -30,21 +32,28 @@ export class Silo {
 	public undo: typeof undo
 	public redo: typeof redo
 	public constructor(name: string, fromStore: Store | null = null) {
-		const store = new Store(name, fromStore)
-		this.store = store
-		this.atom = (options) => atom__INTERNAL(options, undefined, store)
-		this.atomFamily = (options) => atomFamily__INTERNAL(options, store)
-		this.selector = (options) =>
-			selector__INTERNAL(options, undefined, store) as any
-		this.selectorFamily = (options) =>
-			selectorFamily__INTERNAL(options, store) as any
-		this.transaction = (options) => transaction__INTERNAL(options, store)
-		this.timeline = (options) => timeline__INTERNAL(options, store)
-		this.getState = (token) => getState(token, store)
-		this.setState = (token, newValue) => setState(token, newValue, store)
-		;(this.subscribe = (token, handler, key) =>
-			subscribe(token, handler, key, store)),
-			(this.undo = (token) => undo__INTERNAL(token, store))
-		this.redo = (token) => redo__INTERNAL(token, store)
+		const s = new Store(name, fromStore)
+		this.store = s
+		this.atom = (options) => {
+			if (`mutable` in options) {
+				return createMutableAtom(options, s)
+			}
+			return createAtom(options, undefined, s)
+		}
+		this.atomFamily = (options) => {
+			if (`mutable` in options) {
+				return createMutableAtomFamily(options, s) as any
+			}
+			return createAtomFamily(options, s)
+		}
+		this.selector = (options) => createSelector(options, undefined, s) as any
+		this.selectorFamily = (options) => createSelectorFamily(options, s) as any
+		this.transaction = (options) => transaction__INTERNAL(options, s)
+		this.timeline = (options) => timeline__INTERNAL(options, s)
+		this.getState = (token) => getState(token, s)
+		this.setState = (token, newValue) => setState(token, newValue, s)
+		this.subscribe = (token, handler, key) => subscribe(token, handler, key, s)
+		this.undo = (token) => undo__INTERNAL(token, s)
+		this.redo = (token) => redo__INTERNAL(token, s)
 	}
 }

package/src/subscribe.ts

@@ -19,12 +19,12 @@ export type KeyedStateUpdate<T> = StateUpdate<T> & {
 }
 export type UpdateHandler<T> = (update: StateUpdate<T>) => void
 
-export const subscribe = <T>(
+export function subscribe<T>(
 	token: ReadonlySelectorToken<T> | StateToken<T>,
 	handleUpdate: UpdateHandler<T>,
 	key: string = Math.random().toString(36).slice(2),
 	store: Store = IMPLICIT.STORE,
-): (() => void) => {
+): () => void {
 	const state = withdraw<T>(token, store)
 	if (state === null) {
 		throw new Error(
@@ -32,7 +32,7 @@ export const subscribe = <T>(
 		)
 	}
 	const unsubFunction = state.subject.subscribe(key, handleUpdate)
-	store.config.logger?.info(`👀 subscribe to "${state.key}"`)
+	store.config.logger?.info(`👀 adding subscription "${key}" to "${state.key}"`)
 	const dependencyUnsubFunctions =
 		state.type !== `atom` ? subscribeToRootAtoms(state, store) : null
 

package/src/timeline.ts

@@ -3,12 +3,12 @@ import type {
 	TimelineSelectorUpdate,
 	TimelineTransactionUpdate,
 } from "atom.io/internal"
-import { IMPLICIT } from "atom.io/internal"
 import {
+	IMPLICIT,
 	redo__INTERNAL,
 	timeline__INTERNAL,
 	undo__INTERNAL,
-} from "atom.io/internal/"
+} from "atom.io/internal"
 
 import type { AtomFamily, AtomToken } from "."
 

package/transceivers/set-rtx/dist/index.d.mts

@@ -0,0 +1,39 @@
+import { Transceiver, TransceiverMode, Subject } from 'atom.io/internal';
+import { primitive, Json } from 'atom.io/json';
+
+type SetUpdate = `add:${string}` | `clear:${string}` | `del:${string}` | `tx:${string}`;
+type NumberedSetUpdate = `${number}=${SetUpdate}`;
+interface SetRTXJson<P extends primitive> extends Json.Object {
+    members: P[];
+    cache: (NumberedSetUpdate | null)[];
+    cacheLimit: number;
+    cacheIdx: number;
+    cacheUpdateNumber: number;
+}
+declare class SetRTX<P extends primitive> extends Set<P> implements Transceiver<NumberedSetUpdate> {
+    mode: TransceiverMode;
+    readonly subject: Subject<SetUpdate>;
+    cacheLimit: number;
+    cache: (NumberedSetUpdate | null)[];
+    cacheIdx: number;
+    cacheUpdateNumber: number;
+    constructor(values?: Set<P> | readonly P[] | null, cacheLimit?: number);
+    toJSON(): SetRTXJson<P>;
+    static fromJSON<P extends primitive>(json: SetRTXJson<P>): SetRTX<P>;
+    add(value: P): this;
+    clear(): void;
+    delete(value: P): boolean;
+    readonly parent: SetRTX<P> | null;
+    child: SetRTX<P> | null;
+    transactionUpdates: SetUpdate[] | null;
+    transaction(run: (child: SetRTX<P>) => boolean): void;
+    protected _subscribe(key: string, fn: (update: SetUpdate) => void): () => void;
+    subscribe(key: string, fn: (update: NumberedSetUpdate) => void): () => void;
+    emit(update: SetUpdate): void;
+    private doStep;
+    do(update: NumberedSetUpdate): number | `OUT_OF_RANGE` | null;
+    undoStep(update: SetUpdate): void;
+    undo(update: NumberedSetUpdate): number | null;
+}
+
+export { NumberedSetUpdate, SetRTX, SetRTXJson, SetUpdate };

package/transceivers/set-rtx/dist/index.d.ts

@@ -0,0 +1,39 @@
+import { Transceiver, TransceiverMode, Subject } from 'atom.io/internal';
+import { primitive, Json } from 'atom.io/json';
+
+type SetUpdate = `add:${string}` | `clear:${string}` | `del:${string}` | `tx:${string}`;
+type NumberedSetUpdate = `${number}=${SetUpdate}`;
+interface SetRTXJson<P extends primitive> extends Json.Object {
+    members: P[];
+    cache: (NumberedSetUpdate | null)[];
+    cacheLimit: number;
+    cacheIdx: number;
+    cacheUpdateNumber: number;
+}
+declare class SetRTX<P extends primitive> extends Set<P> implements Transceiver<NumberedSetUpdate> {
+    mode: TransceiverMode;
+    readonly subject: Subject<SetUpdate>;
+    cacheLimit: number;
+    cache: (NumberedSetUpdate | null)[];
+    cacheIdx: number;
+    cacheUpdateNumber: number;
+    constructor(values?: Set<P> | readonly P[] | null, cacheLimit?: number);
+    toJSON(): SetRTXJson<P>;
+    static fromJSON<P extends primitive>(json: SetRTXJson<P>): SetRTX<P>;
+    add(value: P): this;
+    clear(): void;
+    delete(value: P): boolean;
+    readonly parent: SetRTX<P> | null;
+    child: SetRTX<P> | null;
+    transactionUpdates: SetUpdate[] | null;
+    transaction(run: (child: SetRTX<P>) => boolean): void;
+    protected _subscribe(key: string, fn: (update: SetUpdate) => void): () => void;
+    subscribe(key: string, fn: (update: NumberedSetUpdate) => void): () => void;
+    emit(update: SetUpdate): void;
+    private doStep;
+    do(update: NumberedSetUpdate): number | `OUT_OF_RANGE` | null;
+    undoStep(update: SetUpdate): void;
+    undo(update: NumberedSetUpdate): number | null;
+}
+
+export { NumberedSetUpdate, SetRTX, SetRTXJson, SetUpdate };