atom.io 0.27.5 → 0.28.0

package/realtime-client/src/sync-continuity.ts

@@ -7,13 +7,15 @@ import {
 	getEpochNumberOfContinuity,
 	getFromStore,
 	getJsonToken,
+	growMoleculeInStore,
 	ingestTransactionUpdate,
+	initFamilyMemberInStore,
 	isRootStore,
 	setEpochNumberOfContinuity,
 	setIntoStore,
 	subscribeToTransaction,
 } from "atom.io/internal"
-import type { Json } from "atom.io/json"
+import { type Json, parseJson } from "atom.io/json"
 import type { ContinuityToken } from "atom.io/realtime"
 import {
 	confirmedUpdateQueue,
@@ -33,8 +35,8 @@ export function syncContinuity<F extends Func>(
 	const initializeContinuity = (epoch: number, payload: Json.Array) => {
 		socket.off(`continuity-init:${continuityKey}`, initializeContinuity)
 		let i = 0
-		let k: any = ``
-		let v: any = null
+		let k: any
+		let v: any
 		for (const x of payload) {
 			if (i % 2 === 0) {
 				k = x
@@ -316,14 +318,14 @@ export function syncContinuity<F extends Func>(
 
 	socket.on(`reveal:${continuityKey}`, (revealed: Json.Array) => {
 		let i = 0
-		let k: any = ``
-		let v: any = null
+		let k: any
+		let v: any
 		for (const x of revealed) {
 			if (i % 2 === 0) {
 				k = x
 			} else {
 				v = x
-				setIntoStore(k, v, store)
+				upsertState(k, v, store)
 			}
 			i++
 		}
@@ -345,3 +347,23 @@ export function syncContinuity<F extends Func>(
 		// socket.emit(`unsub:${continuityKey}`)
 	}
 }
+
+function upsertState<T>(
+	store: Store,
+	token: AtomIO.WritableToken<T>,
+	value: T,
+): void {
+	if (token.family) {
+		const family = store.families.get(token.family.key)
+		if (family) {
+			const molecule = store.molecules.get(token.family.subKey)
+			if (molecule) {
+				growMoleculeInStore(molecule, family, store)
+			} else if (store.config.lifespan === `immortal`) {
+				throw new Error(`No molecule found for key "${token.family.subKey}"`)
+			}
+			initFamilyMemberInStore(store, family, parseJson(token.family.subKey))
+		}
+	}
+	setIntoStore(store, token, value)
+}

package/realtime-server/dist/index.js

@@ -510,17 +510,23 @@ function realtimeContinuitySynchronizer({
           `seeing ${userKey} on new socket ${newSocketKey}`
         );
         if (newSocketKey === null) {
-          store.logger.error(
+          store.logger.warn(
             `\u274C`,
             `continuity`,
             continuityKey,
-            `Tried to create a synchronizer for a user (${userKey}) that is not connected to a socket.`
+            `User (${userKey}) is not connected to a socket, waiting for them to reappear.`
           );
           return;
         }
         const newSocketState = findInStore(store, socketAtoms, newSocketKey);
         const newSocket = getFromStore(store, newSocketState);
         socket = newSocket;
+        for (const unacknowledgedUpdate of userUnacknowledgedUpdates) {
+          socket?.emit(
+            `tx-new:${continuityKey}`,
+            unacknowledgedUpdate
+          );
+        }
       },
       `sync-continuity:${continuityKey}:${userKey}`,
       store
@@ -530,7 +536,7 @@ function realtimeContinuitySynchronizer({
       userUnacknowledgedQueues,
       userKey
     );
-    getFromStore(
+    const userUnacknowledgedUpdates = getFromStore(
       store,
       userUnacknowledgedQueue
     );
@@ -581,7 +587,8 @@ function realtimeContinuitySynchronizer({
       const initialPayload = [];
       for (const atom2 of continuity.globals) {
         const resourceToken = atom2.type === `mutable_atom` ? getJsonToken(store, atom2) : atom2;
-        initialPayload.push(resourceToken, getFromStore(store, atom2));
+        const resource = getFromStore(store, resourceToken);
+        initialPayload.push(resourceToken, resource);
       }
       for (const perspective of continuity.perspectives) {
         const { viewAtoms, resourceAtoms } = perspective;
@@ -605,7 +612,12 @@ function realtimeContinuitySynchronizer({
           transaction2,
           (update) => {
             try {
-              const visibleKeys = continuity.globals.map((atom2) => atom2.key).concat(
+              const visibleKeys = continuity.globals.map((atom2) => {
+                if (atom2.type === `atom`) {
+                  return atom2.key;
+                }
+                return getUpdateToken(atom2).key;
+              }).concat(
                 continuity.perspectives.flatMap((perspective) => {
                   const { viewAtoms } = perspective;
                   const userPerspectiveTokenState = findInStore(
@@ -631,6 +643,13 @@ function realtimeContinuitySynchronizer({
                 ...update,
                 updates: redactedUpdates
               };
+              setIntoStore(store, userUnacknowledgedQueue, (updates) => {
+                if (redactedUpdate) {
+                  updates.push(redactedUpdate);
+                  updates.sort((a, b) => a.epoch - b.epoch);
+                }
+                return updates;
+              });
               socket?.emit(
                 `tx-new:${continuityKey}`,
                 redactedUpdate
@@ -710,8 +729,25 @@ function realtimeContinuitySynchronizer({
     };
     socket.off(`tx-run:${continuityKey}`, fillTransactionRequest);
     socket.on(`tx-run:${continuityKey}`, fillTransactionRequest);
+    const trackClientAcknowledgement = (epoch) => {
+      store.logger.info(
+        `\u{1F44D}`,
+        `continuity`,
+        continuityKey,
+        `${userKey} acknowledged epoch ${epoch}`
+      );
+      const isUnacknowledged = userUnacknowledgedUpdates[0]?.epoch === epoch;
+      if (isUnacknowledged) {
+        setIntoStore(store, userUnacknowledgedQueue, (updates) => {
+          updates.shift();
+          return updates;
+        });
+      }
+    };
+    socket?.on(`ack:${continuityKey}`, trackClientAcknowledgement);
     return () => {
       for (const unsubscribe of unsubscribeFunctions) unsubscribe();
+      socket?.off(`ack:${continuityKey}`, trackClientAcknowledgement);
       unsubscribeFromPerspectives();
       socket?.off(`get:${continuityKey}`, sendInitialPayload);
       socket?.off(`tx-run:${continuityKey}`, fillTransactionRequest);

package/realtime-server/src/realtime-continuity-synchronizer.ts

@@ -5,8 +5,10 @@ import {
 	findInStore,
 	getFromStore,
 	getJsonToken,
+	getUpdateToken,
 	IMPLICIT,
 	isRootStore,
+	setIntoStore,
 	subscribeToState,
 	subscribeToTransaction,
 } from "atom.io/internal"
@@ -62,17 +64,23 @@ export function realtimeContinuitySynchronizer({
 					`seeing ${userKey} on new socket ${newSocketKey}`,
 				)
 				if (newSocketKey === null) {
-					store.logger.error(
+					store.logger.warn(
 						`❌`,
 						`continuity`,
 						continuityKey,
-						`Tried to create a synchronizer for a user (${userKey}) that is not connected to a socket.`,
+						`User (${userKey}) is not connected to a socket, waiting for them to reappear.`,
 					)
 					return
 				}
 				const newSocketState = findInStore(store, socketAtoms, newSocketKey)
 				const newSocket = getFromStore(store, newSocketState)
 				socket = newSocket
+				for (const unacknowledgedUpdate of userUnacknowledgedUpdates) {
+					socket?.emit(
+						`tx-new:${continuityKey}`,
+						unacknowledgedUpdate as Json.Serializable,
+					)
+				}
 			},
 			`sync-continuity:${continuityKey}:${userKey}`,
 			store,
@@ -142,7 +150,8 @@ export function realtimeContinuitySynchronizer({
 			for (const atom of continuity.globals) {
 				const resourceToken =
 					atom.type === `mutable_atom` ? getJsonToken(store, atom) : atom
-				initialPayload.push(resourceToken, getFromStore(store, atom))
+				const resource = getFromStore(store, resourceToken)
+				initialPayload.push(resourceToken, resource)
 			}
 			for (const perspective of continuity.perspectives) {
 				const { viewAtoms, resourceAtoms } = perspective
@@ -176,7 +185,12 @@ export function realtimeContinuitySynchronizer({
 					(update) => {
 						try {
 							const visibleKeys = continuity.globals
-								.map((atom) => atom.key)
+								.map((atom) => {
+									if (atom.type === `atom`) {
+										return atom.key
+									}
+									return getUpdateToken(atom).key
+								})
 								.concat(
 									continuity.perspectives.flatMap((perspective) => {
 										const { viewAtoms } = perspective
@@ -206,17 +220,13 @@ export function realtimeContinuitySynchronizer({
 								...update,
 								updates: redactedUpdates,
 							}
-							// setIntoStore(
-							// 	userUnacknowledgedQueue,
-							// 	(updates) => {
-							// 		if (redactedUpdate) {
-							// 			updates.push(redactedUpdate)
-							// 			updates.sort((a, b) => a.epoch - b.epoch)
-							// 		}
-							// 		return updates
-							// 	},
-							// 	store,
-							// )
+							setIntoStore(store, userUnacknowledgedQueue, (updates) => {
+								if (redactedUpdate) {
+									updates.push(redactedUpdate)
+									updates.sort((a, b) => a.epoch - b.epoch)
+								}
+								return updates
+							})
 
 							socket?.emit(
 								`tx-new:${continuityKey}`,
@@ -304,73 +314,27 @@ export function realtimeContinuitySynchronizer({
 		socket.off(`tx-run:${continuityKey}`, fillTransactionRequest)
 		socket.on(`tx-run:${continuityKey}`, fillTransactionRequest)
 
-		// let i = 0
-		// let n = 1
-		// let retryTimeout: NodeJS.Timeout | undefined
-		// const trackClientAcknowledgement = (epoch: number) => {
-		// 	store.logger.info(
-		// 		`👍`,
-		// 		`continuity`,
-		// 		continuityKey,
-		// 		`${userKey} acknowledged epoch ${epoch}`,
-		// 	)
-		// 	const isUnacknowledged = userUnacknowledgedUpdates[0]?.epoch === epoch
-		// 	if (isUnacknowledged) {
-		// 		setIntoStore(
-		// 			userUnacknowledgedQueue,
-		// 			(updates) => {
-		// 				updates.shift()
-		// 				return updates
-		// 			},
-		// 			store,
-		// 		)
-		// 	}
-		// }
-		// subscribeToState(
-		// 	userUnacknowledgedQueue,
-		// 	({ newValue }) => {
-		// 		if (newValue.length === 0) {
-		// 			clearInterval(retryTimeout)
-		// 			socket?.off(`ack:${continuityKey}`, trackClientAcknowledgement)
-		// 			retryTimeout = undefined
-		// 		}
-		// 		if (newValue.length > 0) {
-		// 			if (retryTimeout) {
-		// 				return
-		// 			}
-
-		// 			socket?.on(`ack:${continuityKey}`, trackClientAcknowledgement)
-
-		// 			retryTimeout = setInterval(() => {
-		// 				i++
-		// 				if (i === n) {
-		// 					n += i
-		// 					const toEmit = newValue[0]
-		// 					if (!toEmit) return
-		// 					store.logger.info(
-		// 						`🔄`,
-		// 						`continuity`,
-		// 						continuityKey,
-		// 						`${store.config.name} retrying ${userKey}`,
-		// 						socket?.id,
-		// 						newValue,
-		// 					)
-		// 					socket?.emit(
-		// 						`tx-new:${continuityKey}`,
-		// 						toEmit as Json.Serializable,
-		// 					)
-		// 				}
-		// 			}, 250)
-		// 		}
-		// 	},
-		// 	`sync-continuity:${continuityKey}:${userKey}`,
-		// 	store,
-		// )
+		const trackClientAcknowledgement = (epoch: number) => {
+			store.logger.info(
+				`👍`,
+				`continuity`,
+				continuityKey,
+				`${userKey} acknowledged epoch ${epoch}`,
+			)
+			const isUnacknowledged = userUnacknowledgedUpdates[0]?.epoch === epoch
+			if (isUnacknowledged) {
+				setIntoStore(store, userUnacknowledgedQueue, (updates) => {
+					updates.shift()
+					return updates
+				})
+			}
+		}
+		socket?.on(`ack:${continuityKey}`, trackClientAcknowledgement)
 
 		return () => {
 			// clearInterval(retryTimeout)
 			for (const unsubscribe of unsubscribeFunctions) unsubscribe()
-			// socket?.off(`ack:${continuityKey}`, trackClientAcknowledgement)
+			socket?.off(`ack:${continuityKey}`, trackClientAcknowledgement)
 			unsubscribeFromPerspectives()
 			socket?.off(`get:${continuityKey}`, sendInitialPayload)
 			socket?.off(`tx-run:${continuityKey}`, fillTransactionRequest)

package/realtime-testing/dist/index.d.ts

@@ -9,6 +9,7 @@ type TestSetupOptions = {
     server: (tools: {
         socket: SocketIO.Socket;
         silo: AtomIO.Silo;
+        enableLogging: () => void;
     }) => void;
 };
 type TestSetupOptions__SingleClient = TestSetupOptions & {
@@ -26,6 +27,7 @@ type RealtimeTestTools = {
 type RealtimeTestClient = RealtimeTestTools & {
     renderResult: RenderResult;
     prettyPrint: () => void;
+    enableLogging: () => void;
     socket: Socket;
 };
 type RealtimeTestClientBuilder = {

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(
@@ -47,7 +60,26 @@ 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();
@@ -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 = {
@@ -108,7 +128,26 @@ 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 = () => {
@@ -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/silo.ts

@@ -1,5 +1,7 @@
 import type { findState } from "atom.io/ephemeral"
 import {
+	actUponStore,
+	arbitrary,
 	createAtomFamily,
 	createMoleculeFamily,
 	createSelectorFamily,
@@ -30,7 +32,7 @@ import type {
 } 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
@@ -49,6 +51,7 @@ 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)
 		this.store = s
@@ -83,8 +86,9 @@ export class Silo {
 		this.moleculeFamily = ((options: Parameters<typeof moleculeFamily>[0]) => {
 			return createMoleculeFamily(s, options)
 		}) as typeof moleculeFamily
-		this.makeMolecule = ((...params: Parameters<typeof makeMolecule>) => {
+		this.makeMolecule = (...params: Parameters<typeof makeMolecule>) => {
 			return makeMoleculeInStore(s, ...params)
-		}) as typeof makeMolecule
+		}
+		this.runTransaction = (token, id = arbitrary()) => actUponStore(token, id, s)
 	}
 }

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 };