atom.io 0.19.1 → 0.19.3

package/react-devtools/src/AtomIODevtools.tsx

@@ -67,7 +67,9 @@ export const AtomIODevtools = (): JSX.Element => {
 										type="button"
 										data-testid={`view-${viewOption}`}
 										className={viewOption === devtoolsView ? `active` : ``}
-										onClick={() => setDevtoolsView(viewOption)}
+										onClick={() => {
+											setDevtoolsView(viewOption)
+										}}
 										disabled={viewOption === devtoolsView}
 									>
 										{viewOption}

package/react-devtools/src/Button.tsx

@@ -12,7 +12,9 @@ export const OpenClose: FC<{
 			type="button"
 			data-testid={testid}
 			className={`carat ${isOpen ? `open` : `closed`}`}
-			onClick={() => setIsOpen((isOpen) => !isOpen)}
+			onClick={() => {
+				setIsOpen((prev) => !prev)
+			}}
 			disabled={disabled}
 		>
 			▶

package/react-devtools/src/StateIndex.tsx

@@ -59,8 +59,12 @@ export const StateIndexLeafNode: FC<{
 					disabled={isPrimitive}
 				/>
 				<label
-					onClick={() => console.log(node, getState(node))}
-					onKeyUp={() => console.log(node, getState(node))}
+					onClick={() => {
+						console.log(node, getState(node))
+					}}
+					onKeyUp={() => {
+						console.log(node, getState(node))
+					}}
 				>
 					<h2>{node.family?.subKey ?? node.key}</h2>
 					<span className="type detail">({stateType})</span>

package/react-devtools/src/TimelineIndex.tsx

@@ -42,14 +42,18 @@ export const TimelineLog: FC<{
 					<nav>
 						<button
 							type="button"
-							onClick={() => undo(token)}
+							onClick={() => {
+								undo(token)
+							}}
 							disabled={timeline.at === 0}
 						>
 							undo
 						</button>
 						<button
 							type="button"
-							onClick={() => redo(token)}
+							onClick={() => {
+								redo(token)
+							}}
 							disabled={timeline.at === timeline.history.length}
 						>
 							redo

package/react-devtools/src/TransactionIndex.tsx

@@ -4,7 +4,7 @@ import {
 	type TransactionToken,
 	type TransactionUpdate,
 	findState,
-	type ƒn,
+	type Func,
 } from "atom.io"
 import { useI, useO } from "atom.io/react"
 import type { FC } from "react"
@@ -18,9 +18,9 @@ import { button } from "./Button"
 import { article } from "./Updates"
 
 export const TransactionLog: FC<{
-	token: TransactionToken<ƒn>
+	token: TransactionToken<Func>
 	isOpenState: RegularAtomToken<boolean>
-	logState: ReadonlySelectorToken<TransactionUpdate<ƒn>[]>
+	logState: ReadonlySelectorToken<TransactionUpdate<Func>[]>
 }> = ({ token, isOpenState, logState }) => {
 	const log = useO(logState)
 	const isOpen = useO(isOpenState)

package/react-devtools/src/Updates.tsx

@@ -2,7 +2,7 @@ import type {
 	KeyedStateUpdate,
 	TimelineUpdate,
 	TransactionUpdate,
-	ƒn,
+	Func,
 } from "atom.io"
 import * as React from "react"
 
@@ -18,8 +18,12 @@ const AtomUpdateFC: React.FC<{
 		<article
 			key={atomUpdate.key}
 			className="node atom_update"
-			onClick={() => console.log(atomUpdate)}
-			onKeyUp={() => console.log(atomUpdate)}
+			onClick={() => {
+				console.log(atomUpdate)
+			}}
+			onKeyUp={() => {
+				console.log(atomUpdate)
+			}}
 		>
 			<span className="detail">{atomUpdate.key}: </span>
 			<span>
@@ -33,7 +37,7 @@ const AtomUpdateFC: React.FC<{
 
 const TransactionUpdateFC: React.FC<{
 	serialNumber: number
-	transactionUpdate: TransactionUpdate<ƒn>
+	transactionUpdate: TransactionUpdate<Func>
 }> = ({ serialNumber, transactionUpdate }) => {
 	return (
 		<article
@@ -51,8 +55,12 @@ const TransactionUpdateFC: React.FC<{
 							<article
 								key={`param` + index}
 								className="node transaction_param"
-								onClick={() => console.log(transactionUpdate)}
-								onKeyUp={() => console.log(transactionUpdate)}
+								onClick={() => {
+									console.log(transactionUpdate)
+								}}
+								onKeyUp={() => {
+									console.log(transactionUpdate)
+								}}
 							>
 								<span className="detail">{discoverType(param)}: </span>
 								<span className="summary">
@@ -85,13 +93,16 @@ const TransactionUpdateFC: React.FC<{
 					{transactionUpdate.updates
 						.filter((token) => !token.key.startsWith(`👁‍🗨`))
 						.map((update, index) => {
-							return `newValue` in update ? (
-								<article.AtomUpdate
-									key={`${transactionUpdate.key}:${index}:${update.key}`}
-									serialNumber={index}
-									atomUpdate={update}
-								/>
-							) : (
+							if (`newValue` in update) {
+								return (
+									<article.AtomUpdate
+										key={`${transactionUpdate.key}:${index}:${update.key}`}
+										serialNumber={index}
+										atomUpdate={update}
+									/>
+								)
+							}
+							return (
 								<TransactionUpdateFC
 									key={`${transactionUpdate.key}:${index}:${update.key}`}
 									serialNumber={index}

package/realtime/dist/index.cjs

@@ -24,6 +24,7 @@ var InvariantMap = class extends Map {
 var _SyncGroup = class _SyncGroup {
   constructor(key) {
     this.key = key;
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
     this.type = `continuity`;
     this.globals = [];
     this.actions = [];

package/realtime/dist/index.d.ts

@@ -8,7 +8,7 @@ declare class InvariantMap<K, V> extends Map<K, V> {
     set(key: K, value: V): this;
     clear(): void;
 }
-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>;
@@ -31,7 +31,7 @@ declare class SyncGroup {
     static create(key: string, builder: (group: SyncGroup) => SyncGroup): ContinuityToken;
     add(...atoms: AtomToken<any>[]): SyncGroup;
     add(...args: TransactionToken<any>[]): SyncGroup;
-    add<F extends AtomFamilyToken<any>, T extends F extends AtomFamilyToken<infer T> ? T : never>(family: AtomFamilyToken<T, any>, index: ReadableFamilyToken<Iterable<AtomToken<T>>, string>): SyncGroup;
+    add<F extends AtomFamilyToken<any>, T extends F extends AtomFamilyToken<infer U> ? U : never>(family: AtomFamilyToken<T, any>, index: ReadableFamilyToken<Iterable<AtomToken<T>>, string>): SyncGroup;
 }
 type ContinuityOptions = {
     key: string;

package/realtime/dist/index.js

@@ -1,4 +1,4 @@
-import '../../dist/chunk-U2IICNHQ.js';
+import '../../dist/chunk-F2X4B4VY.js';
 import { assignTransactionToContinuity, IMPLICIT, setEpochNumberOfContinuity, getUpdateToken } from 'atom.io/internal';
 import { atom, selectorFamily } from 'atom.io';
 import { join, getInternalRelations } from 'atom.io/data';
@@ -22,6 +22,7 @@ var InvariantMap = class extends Map {
 var _SyncGroup = class _SyncGroup {
   constructor(key) {
     this.key = key;
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
     this.type = `continuity`;
     this.globals = [];
     this.actions = [];

package/realtime/package.json

@@ -3,7 +3,7 @@
 	"type": "module",
 	"private": true,
 	"main": "dist/index.cjs",
-	"module": "dist/index.mjs",
+	"module": "dist/index.js",
 	"types": "dist/index.d.ts",
 	"exports": {
 		".": {

package/realtime/src/realtime-continuity.ts

@@ -32,7 +32,7 @@ export class InvariantMap<K, V> extends Map<K, V> {
 
 export type PerspectiveToken<
 	F extends AtomFamilyToken<any>,
-	T extends F extends AtomFamilyToken<infer T, any> ? T : never,
+	T extends F extends AtomFamilyToken<infer U, any> ? U : never,
 > = {
 	type: `realtime_perspective`
 	resourceAtoms: F
@@ -51,6 +51,7 @@ export type ContinuityToken = {
 }
 
 export class SyncGroup {
+	// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
 	protected type = `continuity` as const
 
 	protected globals: AtomToken<any>[] = []
@@ -76,7 +77,7 @@ export class SyncGroup {
 	public add(...args: TransactionToken<any>[]): SyncGroup
 	public add<
 		F extends AtomFamilyToken<any>,
-		T extends F extends AtomFamilyToken<infer T> ? T : never,
+		T extends F extends AtomFamilyToken<infer U> ? U : never,
 	>(
 		family: AtomFamilyToken<T, any>,
 		index: ReadableFamilyToken<Iterable<AtomToken<T>>, string>,
@@ -86,7 +87,7 @@ export class SyncGroup {
 			| readonly AtomToken<any>[]
 			| readonly TransactionToken<any>[]
 			| [AtomFamilyToken<any, any>, ReadableFamilyToken<Iterable<any>, string>]
-	): SyncGroup {
+	): this {
 		const zeroth = args[0]
 		if (zeroth.type === `atom` || zeroth.type === `mutable_atom`) {
 			const globals = args as AtomToken<any>[]

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,7 +1,7 @@
-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';
+import '../../dist/chunk-F2X4B4VY.js';
 import * as Internal from 'atom.io/internal';
 import { setIntoStore, getJsonToken, getUpdateToken } from 'atom.io/internal';
 import { parseJson } from 'atom.io/json';

package/realtime-client/package.json

@@ -3,7 +3,7 @@
 	"type": "module",
 	"private": true,
 	"main": "dist/index.cjs",
-	"module": "dist/index.mjs",
+	"module": "dist/index.js",
 	"types": "dist/index.d.ts",
 	"exports": {
 		".": {

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