atom.io 0.19.1 → 0.19.2

package/realtime-client/dist/index.cjs

@@ -256,8 +256,8 @@ function syncContinuity(continuity, socket, store) {
   };
   socket.off(`continuity-init:${continuityKey}`);
   socket.on(`continuity-init:${continuityKey}`, initializeContinuity);
-  const registerAndAttemptConfirmedUpdate = (confirmedUpdate) => {
-    function reconcileEpoch(optimisticUpdate, confirmedUpdate2) {
+  const registerAndAttemptConfirmedUpdate = (confirmed) => {
+    function reconcileEpoch(optimisticUpdate, confirmedUpdate) {
       store.logger.info(
         `\u{1F9D1}\u200D\u2696\uFE0F`,
         `continuity`,
@@ -272,9 +272,9 @@ function syncContinuity(continuity, socket, store) {
         },
         store
       );
-      if (optimisticUpdate.id === confirmedUpdate2.id) {
+      if (optimisticUpdate.id === confirmedUpdate.id) {
         const clientResult = JSON.stringify(optimisticUpdate.updates);
-        const serverResult = JSON.stringify(confirmedUpdate2.updates);
+        const serverResult = JSON.stringify(confirmedUpdate.updates);
         if (clientResult === serverResult) {
           store.logger.info(
             `\u2705`,
@@ -282,7 +282,7 @@ function syncContinuity(continuity, socket, store) {
             continuityKey,
             `results for ${optimisticUpdate.id} match between client and server`
           );
-          socket.emit(`ack:${continuityKey}`, confirmedUpdate2.epoch);
+          socket.emit(`ack:${continuityKey}`, confirmedUpdate.epoch);
           return;
         }
       } else {
@@ -290,7 +290,7 @@ function syncContinuity(continuity, socket, store) {
           `\u274C`,
           `continuity`,
           continuityKey,
-          `thought update #${confirmedUpdate2.epoch} was ${optimisticUpdate.key}:${optimisticUpdate.id}, but it was actually ${confirmedUpdate2.key}:${confirmedUpdate2.id}`
+          `thought update #${confirmedUpdate.epoch} was ${optimisticUpdate.key}:${optimisticUpdate.id}, but it was actually ${confirmedUpdate.key}:${confirmedUpdate.id}`
         );
       }
       store.logger.info(
@@ -299,7 +299,7 @@ function syncContinuity(continuity, socket, store) {
         continuityKey,
         `updates do not match`,
         optimisticUpdate,
-        confirmedUpdate2
+        confirmedUpdate
       );
       const reversedOptimisticUpdates = optimisticUpdates.toReversed();
       for (const subsequentOptimistic of reversedOptimisticUpdates) {
@@ -320,15 +320,15 @@ function syncContinuity(continuity, socket, store) {
         `undid zeroth optimistic update`,
         optimisticUpdate
       );
-      Internal.ingestTransactionUpdate(`newValue`, confirmedUpdate2, store);
+      Internal.ingestTransactionUpdate(`newValue`, confirmedUpdate, store);
       store.logger.info(
         `\u23E9`,
         `continuity`,
         continuityKey,
         `applied confirmed update`,
-        confirmedUpdate2
+        confirmedUpdate
       );
-      socket.emit(`ack:${continuityKey}`, confirmedUpdate2.epoch);
+      socket.emit(`ack:${continuityKey}`, confirmedUpdate.epoch);
       for (const subsequentOptimistic of optimisticUpdates) {
         const token = {
           type: `transaction`,
@@ -350,7 +350,7 @@ function syncContinuity(continuity, socket, store) {
       `continuity`,
       continuityKey,
       `integrating confirmed update`,
-      { confirmedUpdate, confirmedUpdates, optimisticUpdates }
+      { confirmedUpdate: confirmed, confirmedUpdates, optimisticUpdates }
     );
     const zerothOptimisticUpdate = optimisticUpdates[0];
     if (zerothOptimisticUpdate) {
@@ -360,14 +360,14 @@ function syncContinuity(continuity, socket, store) {
         continuityKey,
         `has optimistic updates to reconcile`
       );
-      if (confirmedUpdate.epoch === zerothOptimisticUpdate.epoch) {
+      if (confirmed.epoch === zerothOptimisticUpdate.epoch) {
         store.logger.info(
           `\u{1F9D1}\u200D\u2696\uFE0F`,
           `continuity`,
           continuityKey,
-          `epoch of confirmed update #${confirmedUpdate.epoch} matches zeroth optimistic update`
+          `epoch of confirmed update #${confirmed.epoch} matches zeroth optimistic update`
         );
-        reconcileEpoch(zerothOptimisticUpdate, confirmedUpdate);
+        reconcileEpoch(zerothOptimisticUpdate, confirmed);
         for (const nextConfirmed of confirmedUpdates) {
           const nextOptimistic = optimisticUpdates[0];
           if (nextConfirmed.epoch === (nextOptimistic == null ? void 0 : nextOptimistic.epoch)) {
@@ -381,10 +381,10 @@ function syncContinuity(continuity, socket, store) {
           `\u{1F9D1}\u200D\u2696\uFE0F`,
           `continuity`,
           continuityKey,
-          `epoch of confirmed update #${confirmedUpdate.epoch} does not match zeroth optimistic update #${zerothOptimisticUpdate.epoch}`
+          `epoch of confirmed update #${confirmed.epoch} does not match zeroth optimistic update #${zerothOptimisticUpdate.epoch}`
         );
         const confirmedUpdateIsAlreadyEnqueued = confirmedUpdates.some(
-          (update) => update.epoch === confirmedUpdate.epoch
+          (update) => update.epoch === confirmed.epoch
         );
         if (!confirmedUpdateIsAlreadyEnqueued) {
           store.logger.info(
@@ -392,12 +392,12 @@ function syncContinuity(continuity, socket, store) {
             `continuity`,
             continuityKey,
             `pushing confirmed update to queue`,
-            confirmedUpdate
+            confirmed
           );
           Internal.setIntoStore(
             realtimeClient.confirmedUpdateQueue,
             (queue) => {
-              queue.push(confirmedUpdate);
+              queue.push(confirmed);
               queue.sort((a, b) => a.epoch - b.epoch);
               return queue;
             },
@@ -414,48 +414,48 @@ function syncContinuity(continuity, socket, store) {
       );
       const continuityEpoch = Internal.getEpochNumberOfContinuity(continuityKey, store);
       const isRoot = Internal.isRootStore(store);
-      if (isRoot && continuityEpoch === confirmedUpdate.epoch - 1) {
+      if (isRoot && continuityEpoch === confirmed.epoch - 1) {
         store.logger.info(
           `\u2705`,
           `continuity`,
           continuityKey,
-          `integrating update #${confirmedUpdate.epoch} (${confirmedUpdate.key} ${confirmedUpdate.id})`
+          `integrating update #${confirmed.epoch} (${confirmed.key} ${confirmed.id})`
         );
-        Internal.ingestTransactionUpdate(`newValue`, confirmedUpdate, store);
-        socket.emit(`ack:${continuityKey}`, confirmedUpdate.epoch);
-        Internal.setEpochNumberOfContinuity(continuityKey, confirmedUpdate.epoch, store);
+        Internal.ingestTransactionUpdate(`newValue`, confirmed, store);
+        socket.emit(`ack:${continuityKey}`, confirmed.epoch);
+        Internal.setEpochNumberOfContinuity(continuityKey, confirmed.epoch, store);
       } else if (isRoot && continuityEpoch !== void 0) {
         store.logger.info(
           `\u{1F9D1}\u200D\u2696\uFE0F`,
           `continuity`,
           continuityKey,
-          `received update #${confirmedUpdate.epoch} but still waiting for update #${continuityEpoch + 1}`,
+          `received update #${confirmed.epoch} but still waiting for update #${continuityEpoch + 1}`,
           {
             clientEpoch: continuityEpoch,
-            serverEpoch: confirmedUpdate.epoch
+            serverEpoch: confirmed.epoch
           }
         );
         const confirmedUpdateIsAlreadyEnqueued = confirmedUpdates.some(
-          (update) => update.epoch === confirmedUpdate.epoch
+          (update) => update.epoch === confirmed.epoch
         );
         if (confirmedUpdateIsAlreadyEnqueued) {
           store.logger.info(
             `\u{1F44D}`,
             `continuity`,
             continuityKey,
-            `confirmed update #${confirmedUpdate.epoch} is already enqueued`
+            `confirmed update #${confirmed.epoch} is already enqueued`
           );
         } else {
           store.logger.info(
             `\u{1F448}`,
             `continuity`,
             continuityKey,
-            `pushing confirmed update #${confirmedUpdate.epoch} to queue`
+            `pushing confirmed update #${confirmed.epoch} to queue`
           );
           Internal.setIntoStore(
             realtimeClient.confirmedUpdateQueue,
             (queue) => {
-              queue.push(confirmedUpdate);
+              queue.push(confirmed);
               queue.sort((a, b) => a.epoch - b.epoch);
               return queue;
             },

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

@@ -26,8 +26,8 @@ declare const myUsernameState: AtomIO.RegularAtomToken<string | null>;
 declare const optimisticUpdateQueue: AtomIO.RegularAtomToken<AtomIO.TransactionUpdate<any>[]>;
 declare const confirmedUpdateQueue: AtomIO.RegularAtomToken<AtomIO.TransactionUpdate<any>[]>;
 
-declare function serverAction<ƒ extends AtomIO.ƒn>(token: AtomIO.TransactionToken<ƒ>, socket: Socket, store: Internal.Store): () => void;
+declare function serverAction<F extends AtomIO.Func>(token: AtomIO.TransactionToken<F>, socket: Socket, store: Internal.Store): () => void;
 
-declare function syncContinuity<ƒ extends AtomIO.ƒn>(continuity: ContinuityToken, socket: Socket, store: Store): () => void;
+declare function syncContinuity<F extends AtomIO.Func>(continuity: ContinuityToken, socket: Socket, store: Store): () => void;
 
 export { confirmedUpdateQueue, myIdState, myIdState__INTERNAL, myUsernameState, optimisticUpdateQueue, pullAtom, pullAtomFamilyMember, pullMutableAtom, pullMutableAtomFamilyMember, pullSelector, pullSelectorFamilyMember, pushState, serverAction, syncContinuity };

package/realtime-client/dist/index.js

@@ -1,4 +1,4 @@
-export { syncContinuity } from '../../dist/chunk-YDOGCZ53.js';
+export { syncContinuity } from '../../dist/chunk-ATKDGVTV.js';
 export { confirmedUpdateQueue, myIdState, myIdState__INTERNAL, myUsernameState, optimisticUpdateQueue } from '../../dist/chunk-O47EQUM6.js';
 import '../../dist/chunk-BWWVY5O5.js';
 import '../../dist/chunk-U2IICNHQ.js';

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

@@ -2,8 +2,8 @@ import type * as AtomIO from "atom.io"
 import * as Internal from "atom.io/internal"
 import type { Socket } from "socket.io-client"
 
-export function serverAction<ƒ extends AtomIO.ƒn>(
-	token: AtomIO.TransactionToken<ƒ>,
+export function serverAction<F extends AtomIO.Func>(
+	token: AtomIO.TransactionToken<F>,
 	socket: Socket,
 	store: Internal.Store,
 ): () => void {

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

@@ -21,7 +21,7 @@ import {
 } from "atom.io/realtime-client"
 import type { Socket } from "socket.io-client"
 
-export function syncContinuity<ƒ extends AtomIO.ƒn>(
+export function syncContinuity<F extends AtomIO.Func>(
 	continuity: ContinuityToken,
 	socket: Socket,
 	store: Store,
@@ -54,7 +54,7 @@ export function syncContinuity<ƒ extends AtomIO.ƒn>(
 	socket.on(`continuity-init:${continuityKey}`, initializeContinuity)
 
 	const registerAndAttemptConfirmedUpdate = (
-		confirmedUpdate: AtomIO.TransactionUpdate<ƒ>,
+		confirmed: AtomIO.TransactionUpdate<F>,
 	) => {
 		function reconcileEpoch(
 			optimisticUpdate: AtomIO.TransactionUpdate<any>,
@@ -155,7 +155,7 @@ export function syncContinuity<ƒ extends AtomIO.ƒn>(
 			`continuity`,
 			continuityKey,
 			`integrating confirmed update`,
-			{ confirmedUpdate, confirmedUpdates, optimisticUpdates },
+			{ confirmedUpdate: confirmed, confirmedUpdates, optimisticUpdates },
 		)
 		const zerothOptimisticUpdate = optimisticUpdates[0]
 		if (zerothOptimisticUpdate) {
@@ -165,14 +165,14 @@ export function syncContinuity<ƒ extends AtomIO.ƒn>(
 				continuityKey,
 				`has optimistic updates to reconcile`,
 			)
-			if (confirmedUpdate.epoch === zerothOptimisticUpdate.epoch) {
+			if (confirmed.epoch === zerothOptimisticUpdate.epoch) {
 				store.logger.info(
 					`🧑‍⚖️`,
 					`continuity`,
 					continuityKey,
-					`epoch of confirmed update #${confirmedUpdate.epoch} matches zeroth optimistic update`,
+					`epoch of confirmed update #${confirmed.epoch} matches zeroth optimistic update`,
 				)
-				reconcileEpoch(zerothOptimisticUpdate, confirmedUpdate)
+				reconcileEpoch(zerothOptimisticUpdate, confirmed)
 				for (const nextConfirmed of confirmedUpdates) {
 					const nextOptimistic = optimisticUpdates[0]
 					if (nextConfirmed.epoch === nextOptimistic?.epoch) {
@@ -187,10 +187,10 @@ export function syncContinuity<ƒ extends AtomIO.ƒn>(
 					`🧑‍⚖️`,
 					`continuity`,
 					continuityKey,
-					`epoch of confirmed update #${confirmedUpdate.epoch} does not match zeroth optimistic update #${zerothOptimisticUpdate.epoch}`,
+					`epoch of confirmed update #${confirmed.epoch} does not match zeroth optimistic update #${zerothOptimisticUpdate.epoch}`,
 				)
 				const confirmedUpdateIsAlreadyEnqueued = confirmedUpdates.some(
-					(update) => update.epoch === confirmedUpdate.epoch,
+					(update) => update.epoch === confirmed.epoch,
 				)
 				if (!confirmedUpdateIsAlreadyEnqueued) {
 					store.logger.info(
@@ -198,12 +198,12 @@ export function syncContinuity<ƒ extends AtomIO.ƒn>(
 						`continuity`,
 						continuityKey,
 						`pushing confirmed update to queue`,
-						confirmedUpdate,
+						confirmed,
 					)
 					setIntoStore(
 						confirmedUpdateQueue,
 						(queue) => {
-							queue.push(confirmedUpdate)
+							queue.push(confirmed)
 							queue.sort((a, b) => a.epoch - b.epoch)
 							return queue
 						},
@@ -221,50 +221,50 @@ export function syncContinuity<ƒ extends AtomIO.ƒn>(
 			const continuityEpoch = getEpochNumberOfContinuity(continuityKey, store)
 			const isRoot = isRootStore(store)
 
-			if (isRoot && continuityEpoch === confirmedUpdate.epoch - 1) {
+			if (isRoot && continuityEpoch === confirmed.epoch - 1) {
 				store.logger.info(
 					`✅`,
 					`continuity`,
 					continuityKey,
-					`integrating update #${confirmedUpdate.epoch} (${confirmedUpdate.key} ${confirmedUpdate.id})`,
+					`integrating update #${confirmed.epoch} (${confirmed.key} ${confirmed.id})`,
 				)
-				ingestTransactionUpdate(`newValue`, confirmedUpdate, store)
-				socket.emit(`ack:${continuityKey}`, confirmedUpdate.epoch)
-				setEpochNumberOfContinuity(continuityKey, confirmedUpdate.epoch, store)
+				ingestTransactionUpdate(`newValue`, confirmed, store)
+				socket.emit(`ack:${continuityKey}`, confirmed.epoch)
+				setEpochNumberOfContinuity(continuityKey, confirmed.epoch, store)
 			} else if (isRoot && continuityEpoch !== undefined) {
 				store.logger.info(
 					`🧑‍⚖️`,
 					`continuity`,
 					continuityKey,
-					`received update #${
-						confirmedUpdate.epoch
-					} but still waiting for update #${continuityEpoch + 1}`,
+					`received update #${confirmed.epoch} but still waiting for update #${
+						continuityEpoch + 1
+					}`,
 					{
 						clientEpoch: continuityEpoch,
-						serverEpoch: confirmedUpdate.epoch,
+						serverEpoch: confirmed.epoch,
 					},
 				)
 				const confirmedUpdateIsAlreadyEnqueued = confirmedUpdates.some(
-					(update) => update.epoch === confirmedUpdate.epoch,
+					(update) => update.epoch === confirmed.epoch,
 				)
 				if (confirmedUpdateIsAlreadyEnqueued) {
 					store.logger.info(
 						`👍`,
 						`continuity`,
 						continuityKey,
-						`confirmed update #${confirmedUpdate.epoch} is already enqueued`,
+						`confirmed update #${confirmed.epoch} is already enqueued`,
 					)
 				} else {
 					store.logger.info(
 						`👈`,
 						`continuity`,
 						continuityKey,
-						`pushing confirmed update #${confirmedUpdate.epoch} to queue`,
+						`pushing confirmed update #${confirmed.epoch} to queue`,
 					)
 					setIntoStore(
 						confirmedUpdateQueue,
 						(queue) => {
-							queue.push(confirmedUpdate)
+							queue.push(confirmed)
 							queue.sort((a, b) => a.epoch - b.epoch)
 							return queue
 						},

package/realtime-react/dist/index.cjs

@@ -194,8 +194,8 @@ function syncContinuity(continuity, socket, store) {
   };
   socket.off(`continuity-init:${continuityKey}`);
   socket.on(`continuity-init:${continuityKey}`, initializeContinuity);
-  const registerAndAttemptConfirmedUpdate = (confirmedUpdate) => {
-    function reconcileEpoch(optimisticUpdate, confirmedUpdate2) {
+  const registerAndAttemptConfirmedUpdate = (confirmed) => {
+    function reconcileEpoch(optimisticUpdate, confirmedUpdate) {
       store.logger.info(
         `\u{1F9D1}\u200D\u2696\uFE0F`,
         `continuity`,
@@ -210,9 +210,9 @@ function syncContinuity(continuity, socket, store) {
         },
         store
       );
-      if (optimisticUpdate.id === confirmedUpdate2.id) {
+      if (optimisticUpdate.id === confirmedUpdate.id) {
         const clientResult = JSON.stringify(optimisticUpdate.updates);
-        const serverResult = JSON.stringify(confirmedUpdate2.updates);
+        const serverResult = JSON.stringify(confirmedUpdate.updates);
         if (clientResult === serverResult) {
           store.logger.info(
             `\u2705`,
@@ -220,7 +220,7 @@ function syncContinuity(continuity, socket, store) {
             continuityKey,
             `results for ${optimisticUpdate.id} match between client and server`
           );
-          socket.emit(`ack:${continuityKey}`, confirmedUpdate2.epoch);
+          socket.emit(`ack:${continuityKey}`, confirmedUpdate.epoch);
           return;
         }
       } else {
@@ -228,7 +228,7 @@ function syncContinuity(continuity, socket, store) {
           `\u274C`,
           `continuity`,
           continuityKey,
-          `thought update #${confirmedUpdate2.epoch} was ${optimisticUpdate.key}:${optimisticUpdate.id}, but it was actually ${confirmedUpdate2.key}:${confirmedUpdate2.id}`
+          `thought update #${confirmedUpdate.epoch} was ${optimisticUpdate.key}:${optimisticUpdate.id}, but it was actually ${confirmedUpdate.key}:${confirmedUpdate.id}`
         );
       }
       store.logger.info(
@@ -237,7 +237,7 @@ function syncContinuity(continuity, socket, store) {
         continuityKey,
         `updates do not match`,
         optimisticUpdate,
-        confirmedUpdate2
+        confirmedUpdate
       );
       const reversedOptimisticUpdates = optimisticUpdates.toReversed();
       for (const subsequentOptimistic of reversedOptimisticUpdates) {
@@ -258,15 +258,15 @@ function syncContinuity(continuity, socket, store) {
         `undid zeroth optimistic update`,
         optimisticUpdate
       );
-      internal.ingestTransactionUpdate(`newValue`, confirmedUpdate2, store);
+      internal.ingestTransactionUpdate(`newValue`, confirmedUpdate, store);
       store.logger.info(
         `\u23E9`,
         `continuity`,
         continuityKey,
         `applied confirmed update`,
-        confirmedUpdate2
+        confirmedUpdate
       );
-      socket.emit(`ack:${continuityKey}`, confirmedUpdate2.epoch);
+      socket.emit(`ack:${continuityKey}`, confirmedUpdate.epoch);
       for (const subsequentOptimistic of optimisticUpdates) {
         const token = {
           type: `transaction`,
@@ -288,7 +288,7 @@ function syncContinuity(continuity, socket, store) {
       `continuity`,
       continuityKey,
       `integrating confirmed update`,
-      { confirmedUpdate, confirmedUpdates, optimisticUpdates }
+      { confirmedUpdate: confirmed, confirmedUpdates, optimisticUpdates }
     );
     const zerothOptimisticUpdate = optimisticUpdates[0];
     if (zerothOptimisticUpdate) {
@@ -298,14 +298,14 @@ function syncContinuity(continuity, socket, store) {
         continuityKey,
         `has optimistic updates to reconcile`
       );
-      if (confirmedUpdate.epoch === zerothOptimisticUpdate.epoch) {
+      if (confirmed.epoch === zerothOptimisticUpdate.epoch) {
         store.logger.info(
           `\u{1F9D1}\u200D\u2696\uFE0F`,
           `continuity`,
           continuityKey,
-          `epoch of confirmed update #${confirmedUpdate.epoch} matches zeroth optimistic update`
+          `epoch of confirmed update #${confirmed.epoch} matches zeroth optimistic update`
         );
-        reconcileEpoch(zerothOptimisticUpdate, confirmedUpdate);
+        reconcileEpoch(zerothOptimisticUpdate, confirmed);
         for (const nextConfirmed of confirmedUpdates) {
           const nextOptimistic = optimisticUpdates[0];
           if (nextConfirmed.epoch === (nextOptimistic == null ? void 0 : nextOptimistic.epoch)) {
@@ -319,10 +319,10 @@ function syncContinuity(continuity, socket, store) {
           `\u{1F9D1}\u200D\u2696\uFE0F`,
           `continuity`,
           continuityKey,
-          `epoch of confirmed update #${confirmedUpdate.epoch} does not match zeroth optimistic update #${zerothOptimisticUpdate.epoch}`
+          `epoch of confirmed update #${confirmed.epoch} does not match zeroth optimistic update #${zerothOptimisticUpdate.epoch}`
         );
         const confirmedUpdateIsAlreadyEnqueued = confirmedUpdates.some(
-          (update) => update.epoch === confirmedUpdate.epoch
+          (update) => update.epoch === confirmed.epoch
         );
         if (!confirmedUpdateIsAlreadyEnqueued) {
           store.logger.info(
@@ -330,12 +330,12 @@ function syncContinuity(continuity, socket, store) {
             `continuity`,
             continuityKey,
             `pushing confirmed update to queue`,
-            confirmedUpdate
+            confirmed
           );
           internal.setIntoStore(
             RTC.confirmedUpdateQueue,
             (queue) => {
-              queue.push(confirmedUpdate);
+              queue.push(confirmed);
               queue.sort((a, b) => a.epoch - b.epoch);
               return queue;
             },
@@ -352,48 +352,48 @@ function syncContinuity(continuity, socket, store) {
       );
       const continuityEpoch = internal.getEpochNumberOfContinuity(continuityKey, store);
       const isRoot = internal.isRootStore(store);
-      if (isRoot && continuityEpoch === confirmedUpdate.epoch - 1) {
+      if (isRoot && continuityEpoch === confirmed.epoch - 1) {
         store.logger.info(
           `\u2705`,
           `continuity`,
           continuityKey,
-          `integrating update #${confirmedUpdate.epoch} (${confirmedUpdate.key} ${confirmedUpdate.id})`
+          `integrating update #${confirmed.epoch} (${confirmed.key} ${confirmed.id})`
         );
-        internal.ingestTransactionUpdate(`newValue`, confirmedUpdate, store);
-        socket.emit(`ack:${continuityKey}`, confirmedUpdate.epoch);
-        internal.setEpochNumberOfContinuity(continuityKey, confirmedUpdate.epoch, store);
+        internal.ingestTransactionUpdate(`newValue`, confirmed, store);
+        socket.emit(`ack:${continuityKey}`, confirmed.epoch);
+        internal.setEpochNumberOfContinuity(continuityKey, confirmed.epoch, store);
       } else if (isRoot && continuityEpoch !== void 0) {
         store.logger.info(
           `\u{1F9D1}\u200D\u2696\uFE0F`,
           `continuity`,
           continuityKey,
-          `received update #${confirmedUpdate.epoch} but still waiting for update #${continuityEpoch + 1}`,
+          `received update #${confirmed.epoch} but still waiting for update #${continuityEpoch + 1}`,
           {
             clientEpoch: continuityEpoch,
-            serverEpoch: confirmedUpdate.epoch
+            serverEpoch: confirmed.epoch
           }
         );
         const confirmedUpdateIsAlreadyEnqueued = confirmedUpdates.some(
-          (update) => update.epoch === confirmedUpdate.epoch
+          (update) => update.epoch === confirmed.epoch
         );
         if (confirmedUpdateIsAlreadyEnqueued) {
           store.logger.info(
             `\u{1F44D}`,
             `continuity`,
             continuityKey,
-            `confirmed update #${confirmedUpdate.epoch} is already enqueued`
+            `confirmed update #${confirmed.epoch} is already enqueued`
           );
         } else {
           store.logger.info(
             `\u{1F448}`,
             `continuity`,
             continuityKey,
-            `pushing confirmed update #${confirmedUpdate.epoch} to queue`
+            `pushing confirmed update #${confirmed.epoch} to queue`
           );
           internal.setIntoStore(
             RTC.confirmedUpdateQueue,
             (queue) => {
-              queue.push(confirmedUpdate);
+              queue.push(confirmed);
               queue.sort((a, b) => a.epoch - b.epoch);
               return queue;
             },

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

@@ -32,9 +32,9 @@ declare function usePullSelectorFamilyMember<T, K extends Json.Serializable, Key
 
 declare function usePush<J extends Json.Serializable>(token: AtomIO.WritableToken<J>): <New extends J>(next: New | ((old: J) => New)) => void;
 
-declare function useServerAction<ƒ extends AtomIO.ƒn>(token: AtomIO.TransactionToken<ƒ>): (...parameters: Parameters<ƒ>) => ReturnType<ƒ>;
+declare function useServerAction<F extends AtomIO.Func>(token: AtomIO.TransactionToken<F>): (...parameters: Parameters<F>) => ReturnType<F>;
 
-type PerspectiveToken<F extends AtomFamilyToken<any>, T extends F extends AtomFamilyToken<infer T, any> ? T : never> = {
+type PerspectiveToken<F extends AtomFamilyToken<any>, T extends F extends AtomFamilyToken<infer U, any> ? U : never> = {
     type: `realtime_perspective`;
     resourceAtoms: F;
     viewAtoms: ReadableFamilyToken<ReadableToken<T>[], string>;

package/realtime-react/dist/index.js

@@ -1,4 +1,4 @@
-import { syncContinuity } from '../../dist/chunk-YDOGCZ53.js';
+import { syncContinuity } from '../../dist/chunk-ATKDGVTV.js';
 import '../../dist/chunk-U2IICNHQ.js';
 import { useI, StoreContext, useO } from 'atom.io/react';
 import * as RTC from 'atom.io/realtime-client';

package/realtime-react/src/use-server-action.ts

@@ -6,9 +6,9 @@ import * as React from "react"
 
 import { useRealtimeService } from "./use-realtime-service"
 
-export function useServerAction<ƒ extends AtomIO.ƒn>(
-	token: AtomIO.TransactionToken<ƒ>,
-): (...parameters: Parameters<ƒ>) => ReturnType<ƒ> {
+export function useServerAction<F extends AtomIO.Func>(
+	token: AtomIO.TransactionToken<F>,
+): (...parameters: Parameters<F>) => ReturnType<F> {
 	const store = React.useContext(StoreContext)
 
 	useRealtimeService(`tx:${token.key}`, (socket) =>