atom.io 0.31.0 → 0.32.0

package/realtime-client/dist/index.js

@@ -1,510 +1,4 @@
+export { confirmedUpdateQueue, myIdState, myIdState__INTERNAL, myUsernameState, optimisticUpdateQueue, pullAtom, pullAtomFamilyMember, pullMutableAtom, pullMutableAtomFamilyMember, pullSelector, pullSelectorFamilyMember, pushState, serverAction, syncContinuity, useConcealState, useRegisterAndAttemptConfirmedUpdate, useRevealState } from '../../dist/chunk-Z2UJW4NQ.js';
+import '../../dist/chunk-4LWKCEW3.js';
+import '../../dist/chunk-GY2XQYZY.js';
 import '../../dist/chunk-XWL6SNVU.js';
-import * as Internal from 'atom.io/internal';
-import { setIntoStore, getEpochNumberOfContinuity, isRootStore, ingestTransactionUpdate, setEpochNumberOfContinuity, disposeAtom, getJsonToken, getUpdateToken, getFromStore, assignTransactionToContinuity, subscribeToTransaction, actUponStore } from 'atom.io/internal';
-import { confirmedUpdateQueue, optimisticUpdateQueue } from 'atom.io/realtime-client';
-import { parseJson } from 'atom.io/json';
-import * as AtomIO from 'atom.io';
-import { persistSync } from 'atom.io/web';
-
-var useRegisterAndAttemptConfirmedUpdate = (store, continuityKey, socket, optimisticUpdates, confirmedUpdates) => (confirmed) => {
-  function reconcileEpoch(optimisticUpdate, confirmedUpdate) {
-    store.logger.info(
-      `\u{1F9D1}\u200D\u2696\uFE0F`,
-      `continuity`,
-      continuityKey,
-      `reconciling updates`
-    );
-    setIntoStore(store, optimisticUpdateQueue, (queue) => {
-      queue.shift();
-      return queue;
-    });
-    if (optimisticUpdate.id === confirmedUpdate.id) {
-      const clientResult = JSON.stringify(optimisticUpdate.updates);
-      const serverResult = JSON.stringify(confirmedUpdate.updates);
-      if (clientResult === serverResult) {
-        store.logger.info(
-          `\u2705`,
-          `continuity`,
-          continuityKey,
-          `results for ${optimisticUpdate.id} match between client and server`
-        );
-        socket.emit(`ack:${continuityKey}`, confirmedUpdate.epoch);
-        return;
-      }
-    } else {
-      store.logger.info(
-        `\u274C`,
-        `continuity`,
-        continuityKey,
-        `thought update #${confirmedUpdate.epoch} was ${optimisticUpdate.key}:${optimisticUpdate.id}, but it was actually ${confirmedUpdate.key}:${confirmedUpdate.id}`
-      );
-    }
-    store.logger.info(
-      `\u{1F9D1}\u200D\u2696\uFE0F`,
-      `continuity`,
-      continuityKey,
-      `updates do not match`,
-      optimisticUpdate,
-      confirmedUpdate
-    );
-    const reversedOptimisticUpdates = optimisticUpdates.toReversed();
-    for (const subsequentOptimistic of reversedOptimisticUpdates) {
-      ingestTransactionUpdate(`oldValue`, subsequentOptimistic, store);
-    }
-    store.logger.info(
-      `\u23EA`,
-      `continuity`,
-      continuityKey,
-      `undid optimistic updates:`,
-      reversedOptimisticUpdates
-    );
-    ingestTransactionUpdate(`oldValue`, optimisticUpdate, store);
-    store.logger.info(
-      `\u23EA`,
-      `continuity`,
-      continuityKey,
-      `undid zeroth optimistic update`,
-      optimisticUpdate
-    );
-    ingestTransactionUpdate(`newValue`, confirmedUpdate, store);
-    store.logger.info(
-      `\u23E9`,
-      `continuity`,
-      continuityKey,
-      `applied confirmed update`,
-      confirmedUpdate
-    );
-    socket.emit(`ack:${continuityKey}`, confirmedUpdate.epoch);
-    for (const subsequentOptimistic of optimisticUpdates) {
-      const token = {
-        type: `transaction`,
-        key: subsequentOptimistic.key
-      };
-      const { id, params } = subsequentOptimistic;
-      actUponStore(token, id, store)(...params);
-    }
-    store.logger.info(
-      `\u23E9`,
-      `continuity`,
-      continuityKey,
-      `reapplied subsequent optimistic updates:`,
-      optimisticUpdates
-    );
-  }
-  store.logger.info(
-    `\u{1F9D1}\u200D\u2696\uFE0F`,
-    `continuity`,
-    continuityKey,
-    `integrating confirmed update`,
-    { confirmedUpdate: confirmed, confirmedUpdates, optimisticUpdates }
-  );
-  const zerothOptimisticUpdate = optimisticUpdates[0];
-  if (zerothOptimisticUpdate) {
-    store.logger.info(
-      `\u{1F9D1}\u200D\u2696\uFE0F`,
-      `continuity`,
-      continuityKey,
-      `has optimistic updates to reconcile`
-    );
-    if (confirmed.epoch === zerothOptimisticUpdate.epoch) {
-      store.logger.info(
-        `\u{1F9D1}\u200D\u2696\uFE0F`,
-        `continuity`,
-        continuityKey,
-        `epoch of confirmed update #${confirmed.epoch} matches zeroth optimistic update`
-      );
-      reconcileEpoch(zerothOptimisticUpdate, confirmed);
-      for (const nextConfirmed of confirmedUpdates) {
-        const nextOptimistic = optimisticUpdates[0];
-        if (nextConfirmed.epoch === nextOptimistic?.epoch) {
-          reconcileEpoch(nextOptimistic, nextConfirmed);
-        } else {
-          break;
-        }
-      }
-    } else {
-      store.logger.info(
-        `\u{1F9D1}\u200D\u2696\uFE0F`,
-        `continuity`,
-        continuityKey,
-        `epoch of confirmed update #${confirmed.epoch} does not match zeroth optimistic update #${zerothOptimisticUpdate.epoch}`
-      );
-      const confirmedUpdateIsAlreadyEnqueued = confirmedUpdates.some(
-        (update) => update.epoch === confirmed.epoch
-      );
-      if (!confirmedUpdateIsAlreadyEnqueued) {
-        store.logger.info(
-          `\u{1F448}`,
-          `continuity`,
-          continuityKey,
-          `pushing confirmed update to queue`,
-          confirmed
-        );
-        setIntoStore(store, confirmedUpdateQueue, (queue) => {
-          queue.push(confirmed);
-          queue.sort((a, b) => a.epoch - b.epoch);
-          return queue;
-        });
-      }
-    }
-  } else {
-    store.logger.info(
-      `\u{1F9D1}\u200D\u2696\uFE0F`,
-      `continuity`,
-      continuityKey,
-      `has no optimistic updates to deal with`
-    );
-    const continuityEpoch = getEpochNumberOfContinuity(continuityKey, store);
-    const isRoot = isRootStore(store);
-    if (isRoot && continuityEpoch === confirmed.epoch - 1) {
-      store.logger.info(
-        `\u2705`,
-        `continuity`,
-        continuityKey,
-        `integrating update #${confirmed.epoch} (${confirmed.key} ${confirmed.id})`
-      );
-      ingestTransactionUpdate(`newValue`, confirmed, store);
-      socket.emit(`ack:${continuityKey}`, confirmed.epoch);
-      setEpochNumberOfContinuity(continuityKey, confirmed.epoch, store);
-    } else if (isRoot && continuityEpoch !== undefined) {
-      store.logger.info(
-        `\u{1F9D1}\u200D\u2696\uFE0F`,
-        `continuity`,
-        continuityKey,
-        `received update #${confirmed.epoch} but still waiting for update #${continuityEpoch + 1}`,
-        {
-          clientEpoch: continuityEpoch,
-          serverEpoch: confirmed.epoch
-        }
-      );
-      const confirmedUpdateIsAlreadyEnqueued = confirmedUpdates.some(
-        (update) => update.epoch === confirmed.epoch
-      );
-      if (confirmedUpdateIsAlreadyEnqueued) {
-        store.logger.info(
-          `\u{1F44D}`,
-          `continuity`,
-          continuityKey,
-          `confirmed update #${confirmed.epoch} is already enqueued`
-        );
-      } else {
-        store.logger.info(
-          `\u{1F448}`,
-          `continuity`,
-          continuityKey,
-          `pushing confirmed update #${confirmed.epoch} to queue`
-        );
-        setIntoStore(store, confirmedUpdateQueue, (queue) => {
-          queue.push(confirmed);
-          queue.sort((a, b) => a.epoch - b.epoch);
-          return queue;
-        });
-      }
-    }
-  }
-};
-function useConcealState(store) {
-  return (concealed) => {
-    for (const token of concealed) {
-      disposeAtom(token, store);
-    }
-  };
-}
-function useRevealState(store) {
-  return (revealed) => {
-    let i = 0;
-    let k;
-    let v;
-    for (const x of revealed) {
-      if (i % 2 === 0) {
-        k = x;
-      } else {
-        v = x;
-        setIntoStore(store, k, v);
-      }
-      i++;
-    }
-  };
-}
-function pullAtom(token, socket, store) {
-  const setServedValue = (data) => {
-    setIntoStore(store, token, data);
-  };
-  socket.on(`serve:${token.key}`, setServedValue);
-  socket.emit(`sub:${token.key}`);
-  return () => {
-    socket.off(`serve:${token.key}`, setServedValue);
-    socket.emit(`unsub:${token.key}`);
-  };
-}
-function pullAtomFamilyMember(token, socket, store) {
-  if (!(`family` in token)) {
-    console.error(`Token is not a family member:`, token);
-    return () => {
-    };
-  }
-  const { key: familyKey, subKey: serializedSubKey } = token.family;
-  const subKey = parseJson(serializedSubKey);
-  socket?.on(`serve:${token.key}`, (data) => {
-    setIntoStore(store, token, data);
-  });
-  socket?.emit(`sub:${familyKey}`, subKey);
-  return () => {
-    socket?.off(`serve:${token.key}`);
-    socket?.emit(`unsub:${token.key}`);
-  };
-}
-function pullMutableAtom(token, socket, store) {
-  const jsonToken = getJsonToken(store, token);
-  const updateToken = getUpdateToken(token);
-  socket.on(`init:${token.key}`, (data) => {
-    setIntoStore(store, jsonToken, data);
-  });
-  socket.on(
-    `next:${token.key}`,
-    (data) => {
-      setIntoStore(store, updateToken, data);
-    }
-  );
-  socket.emit(`sub:${token.key}`);
-  return () => {
-    socket.off(`init:${token.key}`);
-    socket.off(`next:${token.key}`);
-    socket.emit(`unsub:${token.key}`);
-  };
-}
-function pullMutableAtomFamilyMember(token, socket, store) {
-  if (!(`family` in token)) {
-    console.error(`Token is not a family member:`, token);
-    return () => {
-    };
-  }
-  const { key: familyKey, subKey: serializedSubKey } = token.family;
-  const subKey = parseJson(serializedSubKey);
-  socket.on(`init:${token.key}`, (data) => {
-    const jsonToken = getJsonToken(store, token);
-    setIntoStore(store, jsonToken, data);
-  });
-  socket.on(
-    `next:${token.key}`,
-    (data) => {
-      const trackerToken = getUpdateToken(token);
-      setIntoStore(store, trackerToken, data);
-    }
-  );
-  socket.emit(`sub:${familyKey}`, subKey);
-  return () => {
-    socket.off(`serve:${token.key}`);
-    socket.emit(`unsub:${token.key}`);
-  };
-}
-
-// realtime-client/src/pull-selector.ts
-function pullSelector(token, socket, store) {
-  const atomKeys = store.selectorAtoms.getRelatedKeys(token.key);
-  const unsubscribes = [];
-  if (atomKeys) {
-    for (const atomKey of atomKeys) {
-      const atom3 = store.atoms.get(atomKey);
-      if (!atom3) {
-        continue;
-      }
-      switch (atom3.type) {
-        case `atom`: {
-          unsubscribes.push(pullAtom(atom3, socket, store));
-          break;
-        }
-        case `mutable_atom`: {
-          unsubscribes.push(pullMutableAtom(atom3, socket, store));
-          break;
-        }
-      }
-    }
-  }
-  return () => {
-    for (const unsubscribe of unsubscribes) {
-      unsubscribe();
-    }
-  };
-}
-
-// realtime-client/src/pull-selector-family-member.ts
-function pullSelectorFamilyMember(token, socket, store) {
-  if (!(`family` in token)) {
-    console.error(`Token is not a family member:`, token);
-    return () => {
-    };
-  }
-  const atomKeys = store.selectorAtoms.getRelatedKeys(token.key);
-  const unsubscribes = [];
-  if (atomKeys) {
-    for (const atomKey of atomKeys) {
-      const atom3 = store.atoms.get(atomKey);
-      if (!atom3) {
-        continue;
-      }
-      switch (atom3.type) {
-        case `atom`: {
-          unsubscribes.push(pullAtomFamilyMember(atom3, socket, store));
-          break;
-        }
-        case `mutable_atom`: {
-          unsubscribes.push(pullMutableAtomFamilyMember(atom3, socket, store));
-          break;
-        }
-      }
-    }
-  }
-  return () => {
-    for (const unsubscribe of unsubscribes) {
-      unsubscribe();
-    }
-  };
-}
-function pushState(token, socket, store) {
-  socket.emit(`claim:${token.key}`);
-  Internal.subscribeToState(
-    token,
-    ({ newValue }) => {
-      socket.emit(`pub:${token.key}`, newValue);
-    },
-    `push`,
-    store
-  );
-  return () => {
-    socket.off(`pub:${token.key}`);
-    socket.emit(`unclaim:${token.key}`);
-  };
-}
-var myIdState__INTERNAL = AtomIO.atom({
-  key: `mySocketId__INTERNAL`,
-  default: undefined
-});
-var myIdState = AtomIO.selector({
-  key: `mySocketId`,
-  get: ({ get }) => get(myIdState__INTERNAL)
-});
-var myUsernameState = AtomIO.atom({
-  key: `myName`,
-  default: null,
-  effects: typeof window === `undefined` ? [] : [persistSync(window.localStorage, JSON, `myUsername`)]
-});
-var optimisticUpdateQueue2 = AtomIO.atom({
-  key: `updateQueue`,
-  default: []
-});
-var confirmedUpdateQueue2 = AtomIO.atom(
-  {
-    key: `serverConfirmedUpdateQueue`,
-    default: []
-  }
-);
-function serverAction(token, socket, store) {
-  const unsubscribeFromLocalUpdates = Internal.subscribeToTransaction(
-    token,
-    (clientUpdate) => {
-      socket.emit(`tx-run:${token.key}`, clientUpdate);
-    },
-    `tx-run:${token.key}:${socket.id}`,
-    store
-  );
-  return () => {
-    unsubscribeFromLocalUpdates();
-  };
-}
-function syncContinuity(continuity, socket, store) {
-  const continuityKey = continuity.key;
-  const optimisticUpdates = getFromStore(store, optimisticUpdateQueue);
-  const confirmedUpdates = getFromStore(store, confirmedUpdateQueue);
-  const initializeContinuity = (epoch, payload) => {
-    socket.off(`continuity-init:${continuityKey}`, initializeContinuity);
-    let i = 0;
-    let k;
-    let v;
-    for (const x of payload) {
-      if (i % 2 === 0) {
-        k = x;
-      } else {
-        v = x;
-        if (`type` in k && k.type === `mutable_atom`) {
-          k = getJsonToken(store, k);
-        }
-        setIntoStore(store, k, v);
-      }
-      i++;
-    }
-    setEpochNumberOfContinuity(continuityKey, epoch, store);
-  };
-  socket.off(`continuity-init:${continuityKey}`);
-  socket.on(`continuity-init:${continuityKey}`, initializeContinuity);
-  const registerAndAttemptConfirmedUpdate = useRegisterAndAttemptConfirmedUpdate(
-    store,
-    continuityKey,
-    socket,
-    optimisticUpdates,
-    confirmedUpdates
-  );
-  socket.off(`tx-new:${continuityKey}`);
-  socket.on(`tx-new:${continuityKey}`, registerAndAttemptConfirmedUpdate);
-  const unsubscribeFunctions = continuity.actions.map((transaction) => {
-    assignTransactionToContinuity(continuityKey, transaction.key, store);
-    const unsubscribeFromTransactionUpdates = subscribeToTransaction(
-      transaction,
-      (clientUpdate) => {
-        store.logger.info(
-          `\u{1F91E}`,
-          `continuity`,
-          continuityKey,
-          `enqueuing optimistic update`
-        );
-        const optimisticUpdateIndex = optimisticUpdates.findIndex(
-          (update) => update.id === clientUpdate.id
-        );
-        if (optimisticUpdateIndex === -1) {
-          store.logger.info(
-            `\u{1F91E}`,
-            `continuity`,
-            continuityKey,
-            `enqueuing new optimistic update`
-          );
-          setIntoStore(store, optimisticUpdateQueue, (queue) => {
-            queue.push(clientUpdate);
-            queue.sort((a, b) => a.epoch - b.epoch);
-            return queue;
-          });
-        } else {
-          store.logger.info(
-            `\u{1F91E}`,
-            `continuity`,
-            continuityKey,
-            `replacing existing optimistic update at index ${optimisticUpdateIndex}`
-          );
-          setIntoStore(store, optimisticUpdateQueue, (queue) => {
-            queue[optimisticUpdateIndex] = clientUpdate;
-            return queue;
-          });
-        }
-        socket.emit(`tx-run:${continuityKey}`, {
-          id: clientUpdate.id,
-          key: transaction.key,
-          params: clientUpdate.params
-        });
-      },
-      `tx-run:${continuityKey}`,
-      store
-    );
-    return unsubscribeFromTransactionUpdates;
-  });
-  const revealState = useRevealState(store);
-  const concealState = useConcealState(store);
-  socket.on(`reveal:${continuityKey}`, revealState);
-  socket.on(`conceal:${continuityKey}`, concealState);
-  socket.emit(`get:${continuityKey}`);
-  return () => {
-    socket.off(`continuity-init:${continuityKey}`);
-    socket.off(`tx-new:${continuityKey}`);
-    for (const unsubscribe of unsubscribeFunctions) unsubscribe();
-  };
-}
-
-export { confirmedUpdateQueue2 as confirmedUpdateQueue, myIdState, myIdState__INTERNAL, myUsernameState, optimisticUpdateQueue2 as optimisticUpdateQueue, pullAtom, pullAtomFamilyMember, pullMutableAtom, pullMutableAtomFamilyMember, pullSelector, pullSelectorFamilyMember, pushState, serverAction, syncContinuity, useConcealState, useRegisterAndAttemptConfirmedUpdate, useRevealState };

package/realtime-client/src/continuity/register-and-attempt-confirmed-update.ts

@@ -102,7 +102,7 @@ export const useRegisterAndAttemptConfirmedUpdate =
 					key: subsequentOptimistic.key,
 				} as const
 				const { id, params } = subsequentOptimistic
-				actUponStore(token, id, store)(...params)
+				actUponStore(store, token, id)(...params)
 			}
 			store.logger.info(
 				`⏩`,
@@ -177,7 +177,7 @@ export const useRegisterAndAttemptConfirmedUpdate =
 				continuityKey,
 				`has no optimistic updates to deal with`,
 			)
-			const continuityEpoch = getEpochNumberOfContinuity(continuityKey, store)
+			const continuityEpoch = getEpochNumberOfContinuity(store, continuityKey)
 			const isRoot = isRootStore(store)
 
 			if (isRoot && continuityEpoch === confirmed.epoch - 1) {
@@ -189,7 +189,7 @@ export const useRegisterAndAttemptConfirmedUpdate =
 				)
 				ingestTransactionUpdate(`newValue`, confirmed, store)
 				socket.emit(`ack:${continuityKey}`, confirmed.epoch)
-				setEpochNumberOfContinuity(continuityKey, confirmed.epoch, store)
+				setEpochNumberOfContinuity(store, continuityKey, confirmed.epoch)
 			} else if (isRoot && continuityEpoch !== undefined) {
 				store.logger.info(
 					`🧑‍⚖️`,

package/realtime-client/src/continuity/use-conceal-state.ts

@@ -5,7 +5,7 @@ import { disposeAtom } from "atom.io/internal"
 export function useConcealState(store: Store) {
 	return (concealed: AtomToken<unknown>[]): void => {
 		for (const token of concealed) {
-			disposeAtom(token, store)
+			disposeAtom(store, token)
 		}
 	}
 }

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

@@ -7,9 +7,9 @@ import type { Socket } from "socket.io-client"
 /* eslint-disable no-console */
 
 export function pullAtomFamilyMember<J extends Json.Serializable>(
-	token: AtomIO.RegularAtomToken<J>,
-	socket: Socket,
 	store: Store,
+	socket: Socket,
+	token: AtomIO.RegularAtomToken<J>,
 ): () => void {
 	if (!(`family` in token)) {
 		console.error(`Token is not a family member:`, token)

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

@@ -4,9 +4,9 @@ import type { Json } from "atom.io/json"
 import type { Socket } from "socket.io-client"
 
 export function pullAtom<J extends Json.Serializable>(
-	token: AtomIO.RegularAtomToken<J>,
-	socket: Socket,
 	store: Store,
+	socket: Socket,
+	token: AtomIO.RegularAtomToken<J>,
 ): () => void {
 	const setServedValue = (data: J) => {
 		setIntoStore(store, token, data)

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

@@ -11,9 +11,9 @@ export function pullMutableAtomFamilyMember<
 	T extends Transceiver<any>,
 	J extends Json.Serializable,
 >(
-	token: AtomIO.MutableAtomToken<T, J>,
-	socket: Socket,
 	store: Store,
+	socket: Socket,
+	token: AtomIO.MutableAtomToken<T, J>,
 ): () => void {
 	if (!(`family` in token)) {
 		console.error(`Token is not a family member:`, token)

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

@@ -8,9 +8,9 @@ export function pullMutableAtom<
 	T extends Transceiver<any>,
 	J extends Json.Serializable,
 >(
-	token: AtomIO.MutableAtomToken<T, J>,
-	socket: Socket,
 	store: Store,
+	socket: Socket,
+	token: AtomIO.MutableAtomToken<T, J>,
 ): () => void {
 	const jsonToken = getJsonToken(store, token)
 	const updateToken = getUpdateToken(token)

package/realtime-client/src/pull-selector-family-member.ts

@@ -8,9 +8,9 @@ import { pullMutableAtomFamilyMember } from "./pull-mutable-atom-family-member"
 /* eslint-disable no-console */
 
 export function pullSelectorFamilyMember<T>(
-	token: AtomIO.SelectorToken<T>,
-	socket: Socket,
 	store: Store,
+	socket: Socket,
+	token: AtomIO.SelectorToken<T>,
 ): () => void {
 	if (!(`family` in token)) {
 		console.error(`Token is not a family member:`, token)
@@ -26,11 +26,11 @@ export function pullSelectorFamilyMember<T>(
 			}
 			switch (atom.type) {
 				case `atom`: {
-					unsubscribes.push(pullAtomFamilyMember(atom, socket, store))
+					unsubscribes.push(pullAtomFamilyMember(store, socket, atom))
 					break
 				}
 				case `mutable_atom`: {
-					unsubscribes.push(pullMutableAtomFamilyMember(atom, socket, store))
+					unsubscribes.push(pullMutableAtomFamilyMember(store, socket, atom))
 					break
 				}
 			}

package/realtime-client/src/pull-selector.ts

@@ -6,9 +6,9 @@ import { pullAtom } from "./pull-atom"
 import { pullMutableAtom } from "./pull-mutable-atom"
 
 export function pullSelector<T>(
-	token: AtomIO.SelectorToken<T>,
-	socket: Socket,
 	store: Store,
+	socket: Socket,
+	token: AtomIO.SelectorToken<T>,
 ): () => void {
 	const atomKeys = store.selectorAtoms.getRelatedKeys(token.key)
 	const unsubscribes: Array<() => void> = []
@@ -20,11 +20,11 @@ export function pullSelector<T>(
 			}
 			switch (atom.type) {
 				case `atom`: {
-					unsubscribes.push(pullAtom(atom, socket, store))
+					unsubscribes.push(pullAtom(store, socket, atom))
 					break
 				}
 				case `mutable_atom`: {
-					unsubscribes.push(pullMutableAtom(atom, socket, store))
+					unsubscribes.push(pullMutableAtom(store, socket, atom))
 					break
 				}
 			}

package/realtime-client/src/push-state.ts

@@ -4,19 +4,14 @@ import type { Json } from "atom.io/json"
 import type { Socket } from "socket.io-client"
 
 export function pushState<J extends Json.Serializable>(
-	token: AtomIO.WritableToken<J>,
-	socket: Socket,
 	store: Internal.Store,
+	socket: Socket,
+	token: AtomIO.WritableToken<J>,
 ): () => void {
 	socket.emit(`claim:${token.key}`)
-	Internal.subscribeToState(
-		token,
-		({ newValue }) => {
-			socket.emit(`pub:${token.key}`, newValue)
-		},
-		`push`,
-		store,
-	)
+	Internal.subscribeToState(store, token, `push`, ({ newValue }) => {
+		socket.emit(`pub:${token.key}`, newValue)
+	})
 	return () => {
 		socket.off(`pub:${token.key}`)
 		socket.emit(`unclaim:${token.key}`)

package/realtime-client/src/server-action.ts

@@ -3,17 +3,17 @@ import * as Internal from "atom.io/internal"
 import type { Socket } from "socket.io-client"
 
 export function serverAction<F extends Internal.Func>(
-	token: AtomIO.TransactionToken<F>,
-	socket: Socket,
 	store: Internal.Store,
+	socket: Socket,
+	token: AtomIO.TransactionToken<F>,
 ): () => void {
 	const unsubscribeFromLocalUpdates = Internal.subscribeToTransaction(
+		store,
 		token,
+		`tx-run:${token.key}:${socket.id}`,
 		(clientUpdate) => {
 			socket.emit(`tx-run:${token.key}`, clientUpdate)
 		},
-		`tx-run:${token.key}:${socket.id}`,
-		store,
 	)
 
 	return () => {