atom.io 0.19.0 → 0.19.2

package/react-devtools/src/AtomIODevtools.tsx

@@ -53,7 +53,7 @@ export const AtomIODevtools = (): JSX.Element => {
 								borderColor: `#0000`,
 								maxHeight: 28,
 								maxWidth: 33,
-						  }
+							}
 				}
 			>
 				{devtoolsAreOpen ? (
@@ -65,8 +65,11 @@ export const AtomIODevtools = (): JSX.Element => {
 									<button
 										key={viewOption}
 										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

@@ -5,12 +5,16 @@ export const OpenClose: FC<{
 	isOpen: boolean
 	setIsOpen: (next: Modify<boolean> | boolean) => void
 	disabled?: boolean
-}> = ({ isOpen, setIsOpen, disabled }) => {
+	testid: string
+}> = ({ isOpen, setIsOpen, disabled, testid }) => {
 	return (
 		<button
 			type="button"
+			data-testid={testid}
 			className={`carat ${isOpen ? `open` : `closed`}`}
-			onClick={() => setIsOpen((isOpen) => !isOpen)}
+			onClick={() => {
+				setIsOpen((prev) => !prev)
+			}}
 			disabled={disabled}
 		>
 			▶

package/react-devtools/src/StateEditor.tsx

@@ -3,9 +3,7 @@ import { useI, useO } from "atom.io/react"
 import type { FC } from "react"
 
 import { fallback } from "~/packages/anvl/src/function"
-import { Join } from "~/packages/anvl/src/join"
 import { isJson } from "~/packages/anvl/src/refinement"
-import { RelationEditor } from "~/packages/hamr/react-data-designer/src"
 import { ElasticInput } from "~/packages/hamr/react-elastic-input/src"
 import { JsonEditor } from "~/packages/hamr/react-json-editor/src"
 
@@ -16,19 +14,20 @@ export const StateEditor: FC<{
 	const data = useO(token)
 	return isJson(data) ? (
 		<JsonEditor data={data} set={set} schema={true} />
-	) : data instanceof Join ? (
-		<RelationEditor data={data} set={set} />
 	) : (
 		<div className="json_editor">
 			<ElasticInput
 				value={
-					data instanceof Set
-						? `Set { ${JSON.stringify([...data]).slice(1, -1)} }`
-						: data instanceof Map
-						  ? `Map ` + JSON.stringify([...data])
-						  : Object.getPrototypeOf(data).constructor.name +
-							  ` ` +
-							  fallback(() => JSON.stringify(data), `?`)
+					data !== null &&
+					typeof data === `object` &&
+					`toJson` in data &&
+					typeof data.toJson === `function`
+						? JSON.stringify(data.toJson())
+						: data instanceof Set
+							? `Set { ${JSON.stringify([...data]).slice(1, -1)} }`
+							: Object.getPrototypeOf(data).constructor.name +
+								` ` +
+								fallback(() => JSON.stringify(data), `?`)
 				}
 				disabled={true}
 			/>
@@ -53,11 +52,9 @@ export const ReadonlySelectorViewer: FC<{
 				value={
 					data instanceof Set
 						? `Set ` + JSON.stringify([...data])
-						: data instanceof Map
-						  ? `Map ` + JSON.stringify([...data])
-						  : Object.getPrototypeOf(data).constructor.name +
-							  ` ` +
-							  JSON.stringify(data)
+						: Object.getPrototypeOf(data).constructor.name +
+							` ` +
+							JSON.stringify(data)
 				}
 				disabled={true}
 			/>

package/react-devtools/src/StateIndex.tsx

@@ -1,9 +1,10 @@
 import type {
+	AtomToken,
 	ReadonlySelectorToken,
 	RegularAtomToken,
 	WritableSelectorToken,
 } from "atom.io"
-import { getState, selectorFamily } from "atom.io"
+import { findState, getState, selectorFamily } from "atom.io"
 import type { FamilyNode, WritableTokenIndex } from "atom.io/introspection"
 import { useI, useO } from "atom.io/react"
 import type { FC } from "react"
@@ -34,8 +35,8 @@ const findStateTypeState = selectorFamily<string, { key: string }>({
 
 export const StateIndexLeafNode: FC<{
 	node:
+		| AtomToken<unknown>
 		| ReadonlySelectorToken<unknown>
-		| RegularAtomToken<unknown>
 		| WritableSelectorToken<unknown>
 	isOpenState: RegularAtomToken<boolean>
 	typeState: ReadonlySelectorToken<string>
@@ -53,17 +54,22 @@ export const StateIndexLeafNode: FC<{
 			<header>
 				<button.OpenClose
 					isOpen={isOpen && !isPrimitive}
+					testid={`open-close-state-${node.key}`}
 					setIsOpen={setIsOpen}
 					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>
 				</label>
-				{isPrimitive ? <StoreEditor token={node} /> : null}
+				<StoreEditor token={node} />
 			</header>
 			{isOpen && !isPrimitive ? (
 				<main>
@@ -75,8 +81,8 @@ export const StateIndexLeafNode: FC<{
 }
 export const StateIndexTreeNode: FC<{
 	node: FamilyNode<
+		| AtomToken<unknown>
 		| ReadonlySelectorToken<unknown>
-		| RegularAtomToken<unknown>
 		| WritableSelectorToken<unknown>
 	>
 	isOpenState: RegularAtomToken<boolean>
@@ -84,13 +90,17 @@ export const StateIndexTreeNode: FC<{
 	const setIsOpen = useI(isOpenState)
 	const isOpen = useO(isOpenState)
 	for (const [key, childNode] of recordToEntries(node.familyMembers)) {
-		findViewIsOpenState(key)
-		findStateTypeState(childNode)
+		findState(findViewIsOpenState, key)
+		findState(findStateTypeState, childNode)
 	}
 	return (
 		<>
 			<header>
-				<button.OpenClose isOpen={isOpen} setIsOpen={setIsOpen} />
+				<button.OpenClose
+					isOpen={isOpen}
+					testid={`open-close-state-family-${node.key}`}
+					setIsOpen={setIsOpen}
+				/>
 				<label>
 					<h2>{node.key}</h2>
 					<span className="type detail"> (family)</span>
@@ -101,10 +111,10 @@ export const StateIndexTreeNode: FC<{
 						<StateIndexNode
 							key={key}
 							node={childNode}
-							isOpenState={findViewIsOpenState(childNode.key)}
-							typeState={findStateTypeState(childNode)}
+							isOpenState={findState(findViewIsOpenState, childNode.key)}
+							typeState={findState(findStateTypeState, childNode)}
 						/>
-				  ))
+					))
 				: null}
 		</>
 	)
@@ -112,18 +122,15 @@ export const StateIndexTreeNode: FC<{
 
 export const StateIndexNode: FC<{
 	node: WritableTokenIndex<
+		| AtomToken<unknown>
 		| ReadonlySelectorToken<unknown>
-		| RegularAtomToken<unknown>
 		| WritableSelectorToken<unknown>
 	>[string]
 	isOpenState: RegularAtomToken<boolean>
 	typeState: ReadonlySelectorToken<string>
 }> = ({ node, isOpenState, typeState }) => {
-	if (node.key.startsWith(`👁‍🗨`)) {
-		return null
-	}
 	return (
-		<section className="node state">
+		<section className="node state" data-testid={`state-${node.key}`}>
 			{`type` in node ? (
 				<StateIndexLeafNode
 					node={node}
@@ -140,15 +147,15 @@ export const StateIndexNode: FC<{
 export const StateIndex: FC<{
 	tokenIndex: ReadonlySelectorToken<
 		WritableTokenIndex<
+			| AtomToken<unknown>
 			| ReadonlySelectorToken<unknown>
-			| RegularAtomToken<unknown>
 			| WritableSelectorToken<unknown>
 		>
 	>
 }> = ({ tokenIndex }) => {
 	const tokenIds = useO(tokenIndex)
 	return (
-		<article className="index state_index">
+		<article className="index state_index" data-testid="state-index">
 			{Object.entries(tokenIds)
 				.filter(([key]) => !key.startsWith(`👁‍🗨`))
 				.sort()
@@ -157,8 +164,8 @@ export const StateIndex: FC<{
 						<StateIndexNode
 							key={key}
 							node={node}
-							isOpenState={findViewIsOpenState(node.key)}
-							typeState={findStateTypeState(node)}
+							isOpenState={findState(findViewIsOpenState, node.key)}
+							typeState={findState(findStateTypeState, node)}
 						/>
 					)
 				})}

package/react-devtools/src/TimelineIndex.tsx

@@ -26,9 +26,13 @@ export const TimelineLog: FC<{
 	const setIsOpen = useI(isOpenState)
 
 	return (
-		<section className="node timeline_log">
+		<section className="node timeline_log" data-testid={`timeline-${token.key}`}>
 			<header>
-				<button.OpenClose isOpen={isOpen} setIsOpen={setIsOpen} />
+				<button.OpenClose
+					isOpen={isOpen}
+					testid={`open-close-timeline-${token.key}`}
+					setIsOpen={setIsOpen}
+				/>
 				<label>
 					<h2>{token.key}</h2>
 					<span className="detail length">
@@ -38,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
@@ -58,7 +66,10 @@ export const TimelineLog: FC<{
 					{timeline.history.map((update, index) => (
 						<Fragment key={update.key + index + timeline.at}>
 							{index === timeline.at ? <YouAreHere /> : null}
-							<article.TimelineUpdate timelineUpdate={update} />
+							<article.TimelineUpdate
+								timelineUpdate={update}
+								serialNumber={index}
+							/>
 							{index === timeline.history.length - 1 &&
 							timeline.at === timeline.history.length ? (
 								<YouAreHere />
@@ -74,7 +85,7 @@ export const TimelineLog: FC<{
 export const TimelineIndex: FC = () => {
 	const tokenIds = useO(timelineIndex)
 	return (
-		<article className="index timeline_index">
+		<article className="index timeline_index" data-testid="timeline-index">
 			{tokenIds
 				.filter((token) => !token.key.startsWith(`👁‍🗨`))
 				.map((token) => {

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,18 +18,25 @@ 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)
 	const setIsOpen = useI(isOpenState)
 
 	return (
-		<section className="node transaction_log">
+		<section
+			className="node transaction_log"
+			data-testid={`transaction-${token.key}`}
+		>
 			<header>
-				<button.OpenClose isOpen={isOpen} setIsOpen={setIsOpen} />
+				<button.OpenClose
+					isOpen={isOpen}
+					testid={`open-close-transaction-${token.key}`}
+					setIsOpen={setIsOpen}
+				/>
 				<label>
 					<h2>{token.key}</h2>
 					<span className="detail length">({log.length})</span>
@@ -53,7 +60,7 @@ export const TransactionLog: FC<{
 export const TransactionIndex: FC = () => {
 	const tokenIds = useO(transactionIndex)
 	return (
-		<article className="index transaction_index">
+		<article className="index transaction_index" data-testid="transaction-index">
 			{tokenIds
 				.filter((token) => !token.key.startsWith(`👁‍🗨`))
 				.map((token) => {

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,10 +37,13 @@ const AtomUpdateFC: React.FC<{
 
 const TransactionUpdateFC: React.FC<{
 	serialNumber: number
-	transactionUpdate: TransactionUpdate<ƒn>
+	transactionUpdate: TransactionUpdate<Func>
 }> = ({ serialNumber, transactionUpdate }) => {
 	return (
-		<article className="node transaction_update">
+		<article
+			className="node transaction_update"
+			data-testid={`transaction-update-${transactionUpdate.key}-${serialNumber}`}
+		>
 			<header>
 				<h4>{serialNumber}</h4>
 			</header>
@@ -48,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">
@@ -104,9 +115,13 @@ const TransactionUpdateFC: React.FC<{
 
 export const TimelineUpdateFC: React.FC<{
 	timelineUpdate: TimelineUpdate<any>
-}> = ({ timelineUpdate }) => {
+	serialNumber: number
+}> = ({ timelineUpdate, serialNumber }) => {
 	return (
-		<article className="node timeline_update">
+		<article
+			className="node timeline_update"
+			data-testid={`timeline-update-${timelineUpdate.key}-${serialNumber}`}
+		>
 			<header>
 				<h4>
 					{timelineUpdate.timestamp}: {timelineUpdate.type} ({timelineUpdate.key}

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

@@ -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/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;
             },