atom.io 0.27.4 → 0.28.0

package/realtime-testing/dist/index.js

@@ -1,13 +1,13 @@
-import { recordToEntries } from '../../dist/chunk-IW6WYRS7.js';
 import '../../dist/chunk-XWL6SNVU.js';
 import * as http from 'http';
 import { render, prettyDOM } from '@testing-library/react';
 import * as AtomIO from 'atom.io';
-import { editRelationsInStore } from 'atom.io/data';
+import { editRelationsInStore, findRelationsInStore } from 'atom.io/data';
 import { IMPLICIT, findInStore, setIntoStore, getFromStore, clearStore } from 'atom.io/internal';
+import { toEntries } from 'atom.io/json';
 import * as AR from 'atom.io/react';
 import * as RT from 'atom.io/realtime';
-import { myUsernameState } from 'atom.io/realtime-client';
+import * as RTC from 'atom.io/realtime-client';
 import * as RTR from 'atom.io/realtime-react';
 import * as RTS from 'atom.io/realtime-server';
 import * as Happy from 'happy-dom';
@@ -16,6 +16,19 @@ import { io } from 'socket.io-client';
 import { jsx } from 'react/jsx-runtime';
 
 var testNumber = 0;
+function prefixLogger(store, prefix) {
+  store.loggers[0] = new AtomIO.AtomIOLogger(`info`, void 0, {
+    info: (...args) => {
+      console.info(prefix, ...args);
+    },
+    warn: (...args) => {
+      console.warn(prefix, ...args);
+    },
+    error: (...args) => {
+      console.error(prefix, ...args);
+    }
+  });
+}
 var setupRealtimeTestServer = (options) => {
   ++testNumber;
   const silo = new AtomIO.Silo(
@@ -29,8 +42,8 @@ var setupRealtimeTestServer = (options) => {
   const server = new SocketIO.Server(httpServer).use((socket, next) => {
     const { token, username } = socket.handshake.auth;
     if (token === `test` && socket.id) {
-      const socketState = findInStore(RTS.socketAtoms, socket.id, silo.store);
-      setIntoStore(socketState, socket, silo.store);
+      const socketState = findInStore(silo.store, RTS.socketAtoms, socket.id);
+      setIntoStore(silo.store, socketState, socket);
       editRelationsInStore(
         RTS.usersOfSockets,
         (relations) => {
@@ -38,8 +51,8 @@ var setupRealtimeTestServer = (options) => {
         },
         silo.store
       );
-      setIntoStore(RTS.userIndex, (index) => index.add(username), silo.store);
-      setIntoStore(RTS.socketIndex, (index) => index.add(socket.id), silo.store);
+      setIntoStore(silo.store, RTS.userIndex, (index) => index.add(username));
+      setIntoStore(silo.store, RTS.socketIndex, (index) => index.add(socket.id));
       console.log(`${username} connected on ${socket.id}`);
       next();
     } else {
@@ -47,14 +60,33 @@ var setupRealtimeTestServer = (options) => {
     }
   });
   server.on(`connection`, (socket) => {
-    options.server({ socket, silo });
+    let userKey = null;
+    function enableLogging() {
+      const userKeyState = findRelationsInStore(
+        RTS.usersOfSockets,
+        socket.id,
+        silo.store
+      ).userKeyOfSocket;
+      userKey = getFromStore(silo.store, userKeyState);
+      prefixLogger(silo.store, `server`);
+      socket.onAny((event, ...args) => {
+        console.log(`\u{1F6F0} `, userKey, event, ...args);
+      });
+      socket.onAnyOutgoing((event, ...args) => {
+        console.log(`\u{1F6F0}  >>`, userKey, event, ...args);
+      });
+    }
+    options.server({ socket, enableLogging, silo });
+    socket.on(`disconnect`, () => {
+      console.log(`${userKey} disconnected`);
+    });
   });
   const dispose = () => {
     server.close();
-    const roomKeys = getFromStore(RT.roomIndex, silo.store);
+    const roomKeys = getFromStore(silo.store, RT.roomIndex);
     for (const roomKey of roomKeys) {
-      const roomState = findInStore(RTS.roomSelectors, roomKey, silo.store);
-      const room = getFromStore(roomState, silo.store);
+      const roomState = findInStore(silo.store, RTS.roomSelectors, roomKey);
+      const room = getFromStore(silo.store, roomState);
       if (room && !(room instanceof Promise)) {
         room.process.kill();
       }
@@ -81,7 +113,7 @@ var setupRealtimeTestClient = (options, name, port) => {
         silo.store.valueMap.set(key, [...value]);
       }
     }
-    silo.setState(myUsernameState, `${name}-${testNumber}`);
+    silo.setState(RTC.myUsernameState, `${name}-${testNumber}`);
     const { document } = new Happy.Window();
     document.body.innerHTML = `<div id="app"></div>`;
     const renderResult = render(
@@ -93,6 +125,15 @@ var setupRealtimeTestClient = (options, name, port) => {
     const prettyPrint = () => {
       console.log(prettyDOM(renderResult.container));
     };
+    const enableLogging = () => {
+      prefixLogger(silo.store, name);
+      socket.onAny((event, ...args) => {
+        console.log(`\u{1F4E1} `, name, event, ...args);
+      });
+      socket.onAnyOutgoing((event, ...args) => {
+        console.log(`\u{1F4E1}  >>`, name, event, ...args);
+      });
+    };
     const dispose = () => {
       renderResult.unmount();
       socket.disconnect();
@@ -104,7 +145,8 @@ var setupRealtimeTestClient = (options, name, port) => {
       silo,
       socket,
       renderResult,
-      prettyPrint
+      prettyPrint,
+      enableLogging
     };
   };
   return Object.assign(testClient, { init });
@@ -123,7 +165,7 @@ var singleClient = (options) => {
 };
 var multiClient = (options) => {
   const server = setupRealtimeTestServer(options);
-  const clients = recordToEntries(options.clients).reduce(
+  const clients = toEntries(options.clients).reduce(
     (clientRecord, [name, client]) => {
       clientRecord[name] = setupRealtimeTestClient(
         { ...options, client },
@@ -139,7 +181,7 @@ var multiClient = (options) => {
     server,
     teardown: () => {
       server.dispose();
-      for (const [, client] of recordToEntries(clients)) {
+      for (const [, client] of toEntries(clients)) {
         client.dispose();
       }
     }

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

@@ -3,7 +3,8 @@ import * as http from "node:http"
 import type { RenderResult } from "@testing-library/react"
 import { prettyDOM, render } from "@testing-library/react"
 import * as AtomIO from "atom.io"
-import { editRelationsInStore } from "atom.io/data"
+import { editRelationsInStore, findRelationsInStore } from "atom.io/data"
+import type { Store } from "atom.io/internal"
 import {
 	clearStore,
 	findInStore,
@@ -11,9 +12,10 @@ import {
 	IMPLICIT,
 	setIntoStore,
 } from "atom.io/internal"
+import { toEntries } from "atom.io/json"
 import * as AR from "atom.io/react"
 import * as RT from "atom.io/realtime"
-import { myUsernameState } from "atom.io/realtime-client"
+import * as RTC from "atom.io/realtime-client"
 import * as RTR from "atom.io/realtime-react"
 import * as RTS from "atom.io/realtime-server"
 import * as Happy from "happy-dom"
@@ -22,13 +24,29 @@ 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"
-
 let testNumber = 0
 
+function prefixLogger(store: Store, prefix: string) {
+	store.loggers[0] = new AtomIO.AtomIOLogger(`info`, undefined, {
+		info: (...args) => {
+			console.info(prefix, ...args)
+		},
+		warn: (...args) => {
+			console.warn(prefix, ...args)
+		},
+		error: (...args) => {
+			console.error(prefix, ...args)
+		},
+	})
+}
+
 export type TestSetupOptions = {
 	port: number
-	server: (tools: { socket: SocketIO.Socket; silo: AtomIO.Silo }) => void
+	server: (tools: {
+		socket: SocketIO.Socket
+		silo: AtomIO.Silo
+		enableLogging: () => void
+	}) => void
 }
 export type TestSetupOptions__SingleClient = TestSetupOptions & {
 	client: React.FC
@@ -47,6 +65,7 @@ export type RealtimeTestTools = {
 export type RealtimeTestClient = RealtimeTestTools & {
 	renderResult: RenderResult
 	prettyPrint: () => void
+	enableLogging: () => void
 	socket: ClientSocket
 }
 export type RealtimeTestClientBuilder = {
@@ -57,6 +76,7 @@ export type RealtimeTestClientBuilder = {
 export type RealtimeTestServer = RealtimeTestTools & {
 	dispose: () => void
 	port: number
+	// enableLogging: () => void
 }
 
 export type RealtimeTestAPI = {
@@ -89,8 +109,8 @@ export const setupRealtimeTestServer = (
 	const server = new SocketIO.Server(httpServer).use((socket, next) => {
 		const { token, username } = socket.handshake.auth
 		if (token === `test` && socket.id) {
-			const socketState = findInStore(RTS.socketAtoms, socket.id, silo.store)
-			setIntoStore(socketState, socket, silo.store)
+			const socketState = findInStore(silo.store, RTS.socketAtoms, socket.id)
+			setIntoStore(silo.store, socketState, socket)
 			editRelationsInStore(
 				RTS.usersOfSockets,
 				(relations) => {
@@ -98,8 +118,8 @@ export const setupRealtimeTestServer = (
 				},
 				silo.store,
 			)
-			setIntoStore(RTS.userIndex, (index) => index.add(username), silo.store)
-			setIntoStore(RTS.socketIndex, (index) => index.add(socket.id), silo.store)
+			setIntoStore(silo.store, RTS.userIndex, (index) => index.add(username))
+			setIntoStore(silo.store, RTS.socketIndex, (index) => index.add(socket.id))
 			console.log(`${username} connected on ${socket.id}`)
 			next()
 		} else {
@@ -108,15 +128,34 @@ export const setupRealtimeTestServer = (
 	})
 
 	server.on(`connection`, (socket: SocketIO.Socket) => {
-		options.server({ socket, silo })
+		let userKey: string | null = null
+		function enableLogging() {
+			const userKeyState = findRelationsInStore(
+				RTS.usersOfSockets,
+				socket.id,
+				silo.store,
+			).userKeyOfSocket
+			userKey = getFromStore(silo.store, userKeyState)
+			prefixLogger(silo.store, `server`)
+			socket.onAny((event, ...args) => {
+				console.log(`🛰 `, userKey, event, ...args)
+			})
+			socket.onAnyOutgoing((event, ...args) => {
+				console.log(`🛰  >>`, userKey, event, ...args)
+			})
+		}
+		options.server({ socket, enableLogging, silo })
+		socket.on(`disconnect`, () => {
+			console.log(`${userKey} disconnected`)
+		})
 	})
 
 	const dispose = () => {
 		server.close()
-		const roomKeys = getFromStore(RT.roomIndex, silo.store)
+		const roomKeys = getFromStore(silo.store, RT.roomIndex)
 		for (const roomKey of roomKeys) {
-			const roomState = findInStore(RTS.roomSelectors, roomKey, silo.store)
-			const room = getFromStore(roomState, silo.store)
+			const roomState = findInStore(silo.store, RTS.roomSelectors, roomKey)
+			const room = getFromStore(silo.store, roomState)
 			if (room && !(room instanceof Promise)) {
 				room.process.kill()
 			}
@@ -147,7 +186,7 @@ export const setupRealtimeTestClient = (
 				silo.store.valueMap.set(key, [...value])
 			}
 		}
-		silo.setState(myUsernameState, `${name}-${testNumber}`)
+		silo.setState(RTC.myUsernameState, `${name}-${testNumber}`)
 
 		const { document } = new Happy.Window()
 		document.body.innerHTML = `<div id="app"></div>`
@@ -166,6 +205,16 @@ export const setupRealtimeTestClient = (
 			console.log(prettyDOM(renderResult.container))
 		}
 
+		const enableLogging = () => {
+			prefixLogger(silo.store, name)
+			socket.onAny((event, ...args) => {
+				console.log(`📡 `, name, event, ...args)
+			})
+			socket.onAnyOutgoing((event, ...args) => {
+				console.log(`📡  >>`, name, event, ...args)
+			})
+		}
+
 		const dispose = () => {
 			renderResult.unmount()
 			socket.disconnect()
@@ -179,6 +228,7 @@ export const setupRealtimeTestClient = (
 			socket,
 			renderResult,
 			prettyPrint,
+			enableLogging,
 		}
 	}
 	return Object.assign(testClient, { init })
@@ -204,7 +254,7 @@ export const multiClient = <ClientNames extends string>(
 	options: TestSetupOptions__MultiClient<ClientNames>,
 ): RealtimeTestAPI__MultiClient<ClientNames> => {
 	const server = setupRealtimeTestServer(options)
-	const clients = recordToEntries(options.clients).reduce(
+	const clients = toEntries(options.clients).reduce(
 		(clientRecord, [name, client]) => {
 			clientRecord[name] = setupRealtimeTestClient(
 				{ ...options, client },
@@ -221,7 +271,7 @@ export const multiClient = <ClientNames extends string>(
 		server,
 		teardown: () => {
 			server.dispose()
-			for (const [, client] of recordToEntries(clients)) {
+			for (const [, client] of toEntries(clients)) {
 				client.dispose()
 			}
 		},

package/src/atom.ts

@@ -53,7 +53,7 @@ export function atom<T>(options: RegularAtomOptions<T>): RegularAtomToken<T>
 export function atom(
 	options: MutableAtomOptions<any, any> | RegularAtomOptions<any>,
 ): AtomToken<any> {
-	return createStandaloneAtom(options, IMPLICIT.STORE)
+	return createStandaloneAtom(IMPLICIT.STORE, options)
 }
 
 export type RegularAtomFamilyOptions<T, K extends Canonical> = {
@@ -112,5 +112,5 @@ export function atomFamily<T, K extends Canonical>(
 		| MutableAtomFamilyOptions<any, any, any>
 		| RegularAtomFamilyOptions<T, K>,
 ): MutableAtomFamilyToken<any, any, any> | RegularAtomFamilyToken<T, K> {
-	return createAtomFamily(options, IMPLICIT.STORE)
+	return createAtomFamily(IMPLICIT.STORE, options)
 }

package/src/dispose-state.ts

@@ -32,8 +32,8 @@ export function disposeState(
 	key?: Json.Serializable,
 ): void {
 	if (key) {
-		Internal.disposeFromStore(token as any, key, Internal.IMPLICIT.STORE)
+		Internal.disposeFromStore(Internal.IMPLICIT.STORE, token as any, key)
 	} else {
-		Internal.disposeFromStore(token as any, Internal.IMPLICIT.STORE)
+		Internal.disposeFromStore(Internal.IMPLICIT.STORE, token as any)
 	}
 }

package/src/get-state.ts

@@ -26,19 +26,15 @@ export function getState<M extends MoleculeConstructor>(
 ): InstanceType<M>
 
 export function getState(
-	token:
-		| MoleculeFamilyToken<any>
-		| MoleculeToken<any>
-		| ReadableFamilyToken<any, any>
-		| ReadableToken<any>,
-	key?: Canonical,
+	...params:
+		| [
+				token: MoleculeFamilyToken<any> | ReadableFamilyToken<any, any>,
+				key: Canonical,
+		  ]
+		| [token: MoleculeToken<any> | ReadableToken<any>]
 ): any {
-	if (key) {
-		return Internal.getFromStore(
-			token as any,
-			key as any,
-			Internal.IMPLICIT.STORE,
-		)
+	if (params.length === 2) {
+		return Internal.getFromStore(Internal.IMPLICIT.STORE, ...params)
 	}
-	return Internal.getFromStore(token as any, Internal.IMPLICIT.STORE)
+	return Internal.getFromStore(Internal.IMPLICIT.STORE, ...params)
 }

package/src/molecule.ts

@@ -101,7 +101,7 @@ export type MoleculeToken<M extends MoleculeConstructor> = {
 export function moleculeFamily<M extends MoleculeConstructor>(
 	options: MoleculeFamilyOptions<M>,
 ): MoleculeFamilyToken<M> {
-	return createMoleculeFamily(options, IMPLICIT.STORE)
+	return createMoleculeFamily(IMPLICIT.STORE, options)
 }
 
 export function makeMolecule<M extends MoleculeConstructor>(

package/src/selector.ts

@@ -27,7 +27,7 @@ export function selector<T>(
 export function selector<T>(
 	options: ReadonlySelectorOptions<T> | WritableSelectorOptions<T>,
 ): ReadonlySelectorToken<T> | WritableSelectorToken<T> {
-	return createStandaloneSelector(options, IMPLICIT.STORE)
+	return createStandaloneSelector(IMPLICIT.STORE, options)
 }
 
 export type WritableSelectorFamilyOptions<T, K extends Canonical> = {
@@ -69,5 +69,5 @@ export function selectorFamily<T, K extends Canonical>(
 		| ReadonlySelectorFamilyOptions<T, K>
 		| WritableSelectorFamilyOptions<T, K>,
 ): ReadonlySelectorFamilyToken<T, K> | WritableSelectorFamilyToken<T, K> {
-	return createSelectorFamily(options, IMPLICIT.STORE)
+	return createSelectorFamily(IMPLICIT.STORE, options)
 }

package/src/set-state.ts

@@ -1,6 +1,5 @@
 import * as Internal from "atom.io/internal"
 import type { Canonical } from "atom.io/json"
-import type { Json } from "rel8"
 
 import type { WritableFamilyToken, WritableToken } from "."
 
@@ -32,13 +31,17 @@ export function setState<T, K extends Canonical, New extends T, Key extends K>(
 ): void
 
 export function setState<T, New extends T>(
-	token: WritableFamilyToken<T, Canonical> | WritableToken<T>,
-	p1: Json.Serializable | New | ((oldValue: T) => New),
-	p2?: New | ((oldValue: T) => New),
+	...params:
+		| [
+				token: WritableFamilyToken<T, Canonical>,
+				key: Canonical,
+				value: New | ((oldValue: T) => New),
+		  ]
+		| [token: WritableToken<T>, value: New | ((oldValue: T) => New)]
 ): void {
-	if (p2) {
-		Internal.setIntoStore(token as any, p1 as any, p2, Internal.IMPLICIT.STORE)
+	if (params.length === 2) {
+		Internal.setIntoStore(Internal.IMPLICIT.STORE, ...params)
 	} else {
-		Internal.setIntoStore(token as any, p1 as any, Internal.IMPLICIT.STORE)
+		Internal.setIntoStore(Internal.IMPLICIT.STORE, ...params)
 	}
 }

package/src/silo.ts

@@ -1,6 +1,7 @@
 import type { findState } from "atom.io/ephemeral"
-import type { Transceiver } from "atom.io/internal"
 import {
+	actUponStore,
+	arbitrary,
 	createAtomFamily,
 	createMoleculeFamily,
 	createSelectorFamily,
@@ -14,33 +15,24 @@ import {
 	makeMoleculeInStore,
 	setIntoStore,
 	Store,
+	subscribeInStore,
 	timeTravel,
 } from "atom.io/internal"
-import type { Canonical, Json } from "atom.io/json"
 
 import type {
-	AtomToken,
 	disposeState,
 	getState,
 	makeMolecule,
 	moleculeFamily,
-	MutableAtomFamilyOptions,
-	MutableAtomFamilyToken,
-	MutableAtomOptions,
-	MutableAtomToken,
 	redo,
-	RegularAtomFamilyOptions,
-	RegularAtomFamilyToken,
-	RegularAtomOptions,
-	RegularAtomToken,
 	setState,
+	subscribe,
 	timeline,
 	undo,
 } from "."
-import { subscribe } from "."
 import type { atom, atomFamily } from "./atom"
 import type { selector, selectorFamily } from "./selector"
-import type { transaction } from "./transaction"
+import type { runTransaction, transaction } from "./transaction"
 
 export class Silo {
 	public store: Store
@@ -59,62 +51,44 @@ export class Silo {
 	public redo: typeof redo
 	public moleculeFamily: typeof moleculeFamily
 	public makeMolecule: typeof makeMolecule
+	public runTransaction: typeof runTransaction
 	public constructor(config: Store[`config`], fromStore: Store | null = null) {
 		const s = new Store(config, fromStore)
-		function _atom<T>(options: RegularAtomOptions<T>): RegularAtomToken<T>
-		function _atom<T extends Transceiver<any>, J extends Json.Serializable>(
-			options: MutableAtomOptions<T, J>,
-		): MutableAtomToken<T, J>
-		function _atom<T>(
-			options: MutableAtomOptions<any, any> | RegularAtomOptions<T>,
-		): AtomToken<T> {
-			return createStandaloneAtom(options, s)
-		}
-		function _atomFamily<
-			T extends Transceiver<any>,
-			J extends Json.Serializable,
-			K extends Canonical,
-		>(
-			options: MutableAtomFamilyOptions<T, J, K>,
-		): MutableAtomFamilyToken<T, J, K>
-		function _atomFamily<T, K extends Canonical>(
-			options: RegularAtomFamilyOptions<T, K>,
-		): RegularAtomFamilyToken<T, K>
-		function _atomFamily<T, K extends Canonical>(
-			options:
-				| MutableAtomFamilyOptions<any, any, any>
-				| RegularAtomFamilyOptions<T, K>,
-		): MutableAtomFamilyToken<any, any, any> | RegularAtomFamilyToken<T, K> {
-			return createAtomFamily(options, s)
-		}
 		this.store = s
-		this.atom = _atom
-		this.atomFamily = _atomFamily
-		this.selector = (options) => createStandaloneSelector(options, s) as any
-		this.selectorFamily = (options) => createSelectorFamily(options, s) as any
+		this.atom = ((options: Parameters<typeof atom>[0]) =>
+			createStandaloneAtom(s, options)) as typeof atom
+		this.atomFamily = ((options: Parameters<typeof atomFamily>[0]) =>
+			createAtomFamily(s, options)) as typeof atomFamily
+		this.selector = ((options: Parameters<typeof selector>[0]) =>
+			createStandaloneSelector(s, options)) as typeof selector
+		this.selectorFamily = ((options: Parameters<typeof selectorFamily>[0]) =>
+			createSelectorFamily(s, options)) as typeof selectorFamily
 		this.transaction = (options) => createTransaction(options, s)
 		this.timeline = (options) => createTimeline(options, s)
-		this.findState = (token, key) => findInStore(token, key, s) as any
+		this.findState = ((...params: Parameters<typeof findState>) =>
+			findInStore(s, ...params)) as typeof findState
 		this.getState = ((...params: Parameters<typeof getState>) =>
-			getFromStore(...params, s)) as typeof getState
+			getFromStore(s, ...params)) as typeof getState
 		this.setState = ((...params: Parameters<typeof setState>) => {
-			setIntoStore(...params, s)
+			setIntoStore(s, ...params)
 		}) as typeof setState
 		this.disposeState = ((...params: Parameters<typeof disposeState>) => {
-			disposeFromStore(...params, s)
+			disposeFromStore(s, ...params)
 		}) as typeof disposeState
-		this.subscribe = (token, handler, key) => subscribe(token, handler, key, s)
+		this.subscribe = ((...params: Parameters<typeof subscribe>) =>
+			subscribeInStore(s, ...params)) as typeof subscribe
 		this.undo = (token) => {
-			timeTravel(`undo`, token, s)
+			timeTravel(s, `undo`, token)
 		}
 		this.redo = (token) => {
-			timeTravel(`redo`, token, s)
+			timeTravel(s, `redo`, token)
 		}
-		this.moleculeFamily = ((...params: Parameters<typeof moleculeFamily>) => {
-			return createMoleculeFamily(...params, s)
-		}) as any
-		this.makeMolecule = ((...params: Parameters<typeof makeMolecule>) => {
+		this.moleculeFamily = ((options: Parameters<typeof moleculeFamily>[0]) => {
+			return createMoleculeFamily(s, options)
+		}) as typeof moleculeFamily
+		this.makeMolecule = (...params: Parameters<typeof makeMolecule>) => {
 			return makeMoleculeInStore(s, ...params)
-		}) as any
+		}
+		this.runTransaction = (token, id = arbitrary()) => actUponStore(token, id, s)
 	}
 }

package/src/subscribe.ts

@@ -1,11 +1,5 @@
-import type { Flat, Func, Store } from "atom.io/internal"
-import {
-	arbitrary,
-	IMPLICIT,
-	subscribeToState,
-	subscribeToTimeline,
-	subscribeToTransaction,
-} from "atom.io/internal"
+import type { Flat, Func } from "atom.io/internal"
+import { arbitrary, IMPLICIT, subscribeInStore } from "atom.io/internal"
 
 import type {
 	FamilyMetadata,
@@ -35,35 +29,21 @@ export function subscribe<T>(
 	token: ReadableToken<T>,
 	handleUpdate: UpdateHandler<T>,
 	key?: string,
-	store?: Store,
 ): () => void
 export function subscribe<F extends Func>(
 	token: TransactionToken<F>,
 	handleUpdate: TransactionUpdateHandler<F>,
 	key?: string,
-	store?: Store,
 ): () => void
 export function subscribe<M extends TimelineManageable>(
 	token: TimelineToken<M>,
 	handleUpdate: (update: TimelineUpdate<M> | `redo` | `undo`) => void,
 	key?: string,
-	store?: Store,
 ): () => void
 export function subscribe(
 	token: ReadableToken<any> | TimelineToken<any> | TransactionToken<any>,
 	handleUpdate: (update: any) => void,
 	key: string = arbitrary(),
-	store = IMPLICIT.STORE,
 ): () => void {
-	switch (token.type) {
-		case `atom`:
-		case `mutable_atom`:
-		case `readonly_selector`:
-		case `selector`:
-			return subscribeToState(token, handleUpdate, key, store)
-		case `transaction`:
-			return subscribeToTransaction(token, handleUpdate, key, store)
-		case `timeline`:
-			return subscribeToTimeline(token, handleUpdate, key, store)
-	}
+	return subscribeInStore(IMPLICIT.STORE, token, handleUpdate, key)
 }

package/src/timeline.ts

@@ -54,9 +54,9 @@ export const timeline = <ManagedAtom extends TimelineManageable>(
 }
 
 export const redo = (tl: TimelineToken<any>): void => {
-	timeTravel(`redo`, tl, IMPLICIT.STORE)
+	timeTravel(IMPLICIT.STORE, `redo`, tl)
 }
 
 export const undo = (tl: TimelineToken<any>): void => {
-	timeTravel(`undo`, tl, IMPLICIT.STORE)
+	timeTravel(IMPLICIT.STORE, `undo`, tl)
 }

package/web/dist/index.d.ts

@@ -0,0 +1,9 @@
+import { AtomEffect } from 'atom.io';
+
+type StringInterface<T> = {
+    stringify: (t: T) => string;
+    parse: (s: string) => T;
+};
+declare const persistSync: <T>(storage: Storage, { stringify, parse }: StringInterface<T>, key: string) => AtomEffect<T>;
+
+export { type StringInterface, persistSync };

package/{dist/chunk-H6EDLPKH.js → web/dist/index.js}

@@ -1,5 +1,7 @@
-// __unstable__/web-effects/src/storage.ts
-var persistAtom = (storage) => ({ stringify, parse }) => (key) => ({ setSelf, onSet }) => {
+import '../../dist/chunk-XWL6SNVU.js';
+
+// web/src/persist-sync.ts
+var persistSync = (storage, { stringify, parse }, key) => ({ setSelf, onSet }) => {
   const savedValue = storage.getItem(key);
   if (savedValue != null) setSelf(parse(savedValue));
   onSet(({ newValue }) => {
@@ -10,6 +12,5 @@ var persistAtom = (storage) => ({ stringify, parse }) => (key) => ({ setSelf, on
     storage.setItem(key, stringify(newValue));
   });
 };
-var lazyLocalStorageEffect = persistAtom(window.localStorage)(JSON);
 
-export { lazyLocalStorageEffect };
+export { persistSync };