atom.io 0.19.0 → 0.19.2

package/data/src/join.ts

@@ -73,7 +73,7 @@ export type JoinStateFamilies<
 						[string, Content] | null,
 						string
 					>
-			  }
+				}
 			: {}) & {
 			readonly [AB in ASide | BSide as AB extends ASide
 				? `${AB}KeyOf${Capitalize<BSide>}`
@@ -81,33 +81,33 @@ export type JoinStateFamilies<
 				string | null,
 				string
 			>
-	  }
+		}
 	: Cardinality extends `1:n`
-	  ? (Content extends Json.Object
+		? (Content extends Json.Object
 				? {
 						readonly [A in ASide as `${A}EntryOf${Capitalize<BSide>}`]: ReadonlySelectorFamily<
 							[string, Content] | null,
 							string
 						>
-				  } & {
+					} & {
 						readonly [B in BSide as `${B}EntriesOf${Capitalize<ASide>}`]: ReadonlySelectorFamily<
 							[string, Content][],
 							string
 						>
-				  }
+					}
 				: {}) & {
 				readonly [A in ASide as `${A}KeyOf${Capitalize<BSide>}`]: ReadonlySelectorFamily<
 					string | null,
 					string
 				>
-		  } & {
+			} & {
 				readonly [B in BSide as `${B}KeysOf${Capitalize<ASide>}`]: ReadonlySelectorFamily<
 					string[],
 					string
 				>
-		  }
-	  : Cardinality extends `n:n`
-		  ? (Content extends Json.Object
+			}
+		: Cardinality extends `n:n`
+			? (Content extends Json.Object
 					? {
 							readonly [AB in ASide | BSide as AB extends ASide
 								? `${AB}EntriesOf${Capitalize<BSide>}`
@@ -115,7 +115,7 @@ export type JoinStateFamilies<
 								[string, Content][],
 								string
 							>
-					  }
+						}
 					: {}) & {
 					readonly [AB in ASide | BSide as AB extends ASide
 						? `${AB}KeysOf${Capitalize<BSide>}`
@@ -123,8 +123,8 @@ export type JoinStateFamilies<
 						string[],
 						string
 					>
-			  }
-		  : never
+				}
+			: never
 
 export class Join<
 	const ASide extends string,
@@ -178,11 +178,13 @@ export class Join<
 		this.alternates.set(store.config.name, this)
 		this.transactors = {
 			get: (token) => getFromStore(token, store),
-			set: (token, value) => setIntoStore(token, value, store),
+			set: (token, value) => {
+				setIntoStore(token, value, store)
+			},
 			find: ((token, key) => findInStore(token, key, store)) as typeof findState,
 		}
-		const a: ASide = options.between[0]
-		const b: BSide = options.between[1]
+		const aSide: ASide = options.between[0]
+		const bSide: BSide = options.between[1]
 		const relatedKeysAtoms = createMutableAtomFamily<
 			SetRTX<string>,
 			SetRTXJson<string>,
@@ -305,12 +307,18 @@ export class Join<
 		}
 		const baseExternalStoreConfiguration: BaseExternalStoreConfiguration = {
 			getRelatedKeys: (key) => getRelatedKeys(this.transactors, key),
-			addRelation: (a, b) => addRelation(this.transactors, a, b),
-			deleteRelation: (a, b) => deleteRelation(this.transactors, a, b),
-			replaceRelationsSafely: (a, bs) =>
-				replaceRelationsSafely(this.transactors, a, bs),
-			replaceRelationsUnsafely: (a, bs) =>
-				replaceRelationsUnsafely(this.transactors, a, bs),
+			addRelation: (a, b) => {
+				addRelation(this.transactors, a, b)
+			},
+			deleteRelation: (a, b) => {
+				deleteRelation(this.transactors, a, b)
+			},
+			replaceRelationsSafely: (a, bs) => {
+				replaceRelationsSafely(this.transactors, a, bs)
+			},
+			replaceRelationsUnsafely: (a, bs) => {
+				replaceRelationsUnsafely(this.transactors, a, bs)
+			},
 			has: (a, b) => has(this.transactors, a, b),
 		}
 		let externalStore: ExternalStoreConfiguration<Content>
@@ -331,9 +339,12 @@ export class Join<
 				{ find, set },
 				key,
 				content,
-			) => set(find(contentAtoms, key), content)
-			const deleteContent: Write<(key: string) => void> = ({ find }, key) =>
+			) => {
+				set(find(contentAtoms, key), content)
+			}
+			const deleteContent: Write<(key: string) => void> = ({ find }, key) => {
 				dispose(find(contentAtoms, key))
+			}
 			const externalStoreWithContentConfiguration = {
 				getContent: (contentKey: string) => {
 					const content = getContent(this.transactors, contentKey)
@@ -435,8 +446,8 @@ export class Join<
 		switch (options.cardinality) {
 			case `1:1`: {
 				const findSingleRelatedKeyState = createSingleKeyStateFamily()
-				const stateKeyA = `${a}KeyOf${capitalize(b)}` as const
-				const stateKeyB = `${b}KeyOf${capitalize(a)}` as const
+				const stateKeyA = `${aSide}KeyOf${capitalize(bSide)}` as const
+				const stateKeyB = `${bSide}KeyOf${capitalize(aSide)}` as const
 				const baseStates = {
 					[stateKeyA]: findSingleRelatedKeyState,
 					[stateKeyB]: findSingleRelatedKeyState,
@@ -444,8 +455,8 @@ export class Join<
 				let states: JoinStateFamilies<ASide, BSide, Cardinality, Content>
 				if (defaultContent) {
 					const findSingleRelatedEntryState = createSingleEntryStateFamily()
-					const entriesStateKeyA = `${a}EntryOf${capitalize(b)}` as const
-					const entriesStateKeyB = `${b}EntryOf${capitalize(a)}` as const
+					const entriesStateKeyA = `${aSide}EntryOf${capitalize(bSide)}` as const
+					const entriesStateKeyB = `${bSide}EntryOf${capitalize(aSide)}` as const
 					const contentStates = {
 						[entriesStateKeyA]: findSingleRelatedEntryState,
 						[entriesStateKeyB]: findSingleRelatedEntryState,
@@ -461,8 +472,8 @@ export class Join<
 			case `1:n`: {
 				const findSingleRelatedKeyState = createSingleKeyStateFamily()
 				const findMultipleRelatedKeysState = getMultipleKeyStateFamily()
-				const stateKeyA = `${a}KeyOf${capitalize(b)}` as const
-				const stateKeyB = `${b}KeysOf${capitalize(a)}` as const
+				const stateKeyA = `${aSide}KeyOf${capitalize(bSide)}` as const
+				const stateKeyB = `${bSide}KeysOf${capitalize(aSide)}` as const
 				const baseStates = {
 					[stateKeyA]: findSingleRelatedKeyState,
 					[stateKeyB]: findMultipleRelatedKeysState,
@@ -471,8 +482,10 @@ export class Join<
 				if (defaultContent) {
 					const findSingleRelatedEntryState = createSingleEntryStateFamily()
 					const findMultipleRelatedEntriesState = getMultipleEntryStateFamily()
-					const entriesStateKeyA = `${a}EntryOf${capitalize(b)}` as const
-					const entriesStateKeyB = `${b}EntriesOf${capitalize(a)}` as const
+					const entriesStateKeyA = `${aSide}EntryOf${capitalize(bSide)}` as const
+					const entriesStateKeyB = `${bSide}EntriesOf${capitalize(
+						aSide,
+					)}` as const
 					const contentStates = {
 						[entriesStateKeyA]: findSingleRelatedEntryState,
 						[entriesStateKeyB]: findMultipleRelatedEntriesState,
@@ -487,8 +500,8 @@ export class Join<
 			}
 			default: {
 				const findMultipleRelatedKeysState = getMultipleKeyStateFamily()
-				const stateKeyA = `${a}KeysOf${capitalize(b)}` as const
-				const stateKeyB = `${b}KeysOf${capitalize(a)}` as const
+				const stateKeyA = `${aSide}KeysOf${capitalize(bSide)}` as const
+				const stateKeyB = `${bSide}KeysOf${capitalize(aSide)}` as const
 				const baseStates = {
 					[stateKeyA]: findMultipleRelatedKeysState,
 					[stateKeyB]: findMultipleRelatedKeysState,
@@ -496,8 +509,12 @@ export class Join<
 				let states: JoinStateFamilies<ASide, BSide, Cardinality, Content>
 				if (defaultContent) {
 					const findMultipleRelatedEntriesState = getMultipleEntryStateFamily()
-					const entriesStateKeyA = `${a}EntriesOf${capitalize(b)}` as const
-					const entriesStateKeyB = `${b}EntriesOf${capitalize(a)}` as const
+					const entriesStateKeyA = `${aSide}EntriesOf${capitalize(
+						bSide,
+					)}` as const
+					const entriesStateKeyB = `${bSide}EntriesOf${capitalize(
+						aSide,
+					)}` as const
 					const contentStates = {
 						[entriesStateKeyA]: findMultipleRelatedEntriesState,
 						[entriesStateKeyB]: findMultipleRelatedEntriesState,
@@ -588,18 +605,18 @@ export function getJoin<
 	store: Store,
 ): Join<ASide, BSide, Cardinality, Content> {
 	const joinMap = getJoinMap(store)
-	let join = joinMap.get(token.key)
-	if (join === undefined) {
+	let myJoin = joinMap.get(token.key)
+	if (myJoin === undefined) {
 		const rootJoinMap = getJoinMap(IMPLICIT.STORE)
-		join = rootJoinMap.get(token.key)?.in(store)
-		if (join === undefined) {
+		myJoin = rootJoinMap.get(token.key)?.in(store)
+		if (myJoin === undefined) {
 			throw new Error(
 				`Join "${token.key}" not found in store "${store.config.name}"`,
 			)
 		}
-		joinMap.set(token.key, join)
+		joinMap.set(token.key, myJoin)
 	}
-	return join
+	return myJoin
 }
 
 export type JoinStates<
@@ -615,47 +632,47 @@ export type JoinStates<
 						: `${AB}EntryOf${Capitalize<ASide>}`]: ReadonlySelectorToken<
 						[string, Content] | null
 					>
-			  }
+				}
 			: {}) & {
 			readonly [AB in ASide | BSide as AB extends ASide
 				? `${AB}KeyOf${Capitalize<BSide>}`
 				: `${AB}KeyOf${Capitalize<ASide>}`]: ReadonlySelectorToken<string | null>
-	  }
+		}
 	: Cardinality extends `1:n`
-	  ? (Content extends Json.Object
+		? (Content extends Json.Object
 				? {
 						readonly [A in ASide as `${A}EntryOf${Capitalize<BSide>}`]: ReadonlySelectorToken<
 							[string, Content] | null
 						>
-				  } & {
+					} & {
 						readonly [B in BSide as `${B}EntriesOf${Capitalize<ASide>}`]: ReadonlySelectorToken<
 							[string, Content][]
 						>
-				  }
+					}
 				: {}) & {
 				readonly [A in ASide as `${A}KeyOf${Capitalize<BSide>}`]: ReadonlySelectorToken<
 					string | null
 				>
-		  } & {
+			} & {
 				readonly [B in BSide as `${B}KeysOf${Capitalize<ASide>}`]: ReadonlySelectorToken<
 					string[]
 				>
-		  }
-	  : Cardinality extends `n:n`
-		  ? (Content extends Json.Object
+			}
+		: Cardinality extends `n:n`
+			? (Content extends Json.Object
 					? {
 							readonly [AB in ASide | BSide as AB extends ASide
 								? `${AB}EntriesOf${Capitalize<BSide>}`
 								: `${AB}EntriesOf${Capitalize<ASide>}`]: ReadonlySelectorToken<
 								[string, Content][]
 							>
-					  }
+						}
 					: {}) & {
 					readonly [AB in ASide | BSide as AB extends ASide
 						? `${AB}KeysOf${Capitalize<BSide>}`
 						: `${AB}KeysOf${Capitalize<ASide>}`]: ReadonlySelectorToken<string[]>
-			  }
-		  : never
+				}
+			: never
 
 export function findRelationsInStore<
 	ASide extends string,
@@ -667,7 +684,7 @@ export function findRelationsInStore<
 	key: string,
 	store: Store,
 ): JoinStates<ASide, BSide, Cardinality, Content> {
-	const join = getJoin(token, store)
+	const myJoin = getJoin(token, store)
 	let relations: JoinStates<ASide, BSide, Cardinality, Content>
 	switch (token.cardinality satisfies `1:1` | `1:n` | `n:n`) {
 		case `1:1`: {
@@ -675,27 +692,27 @@ export function findRelationsInStore<
 			const keyBA = `${token.b}KeyOf${capitalize(token.a)}`
 			relations = {
 				get [keyAB]() {
-					const familyAB = join.states[keyAB as any]
+					const familyAB = myJoin.states[keyAB as any]
 					const state = findInStore(familyAB, key, store)
 					return state
 				},
 				get [keyBA]() {
-					const familyBA = join.states[keyBA as any]
+					const familyBA = myJoin.states[keyBA as any]
 					const state = findInStore(familyBA, key, store)
 					return state
 				},
 			} as JoinStates<ASide, BSide, Cardinality, Content>
 			const entryAB = `${token.a}EntryOf${capitalize(token.b)}`
-			if (entryAB in join.states) {
+			if (entryAB in myJoin.states) {
 				const entryBA = `${token.b}EntryOf${capitalize(token.a)}`
 				Object.assign(relations, {
 					get [entryAB]() {
-						const familyAB = join.states[entryAB as any]
+						const familyAB = myJoin.states[entryAB as any]
 						const state = findInStore(familyAB, key, store)
 						return state
 					},
 					get [entryBA]() {
-						const familyBA = join.states[entryBA as any]
+						const familyBA = myJoin.states[entryBA as any]
 						const state = findInStore(familyBA, key, store)
 						return state
 					},
@@ -708,27 +725,27 @@ export function findRelationsInStore<
 			const keysBA = `${token.b}KeysOf${capitalize(token.a)}`
 			relations = {
 				get [keyAB]() {
-					const familyAB = join.states[keyAB as any]
+					const familyAB = myJoin.states[keyAB as any]
 					const state = findInStore(familyAB, key, store)
 					return state
 				},
 				get [keysBA]() {
-					const familyBA = join.states[keysBA as any]
+					const familyBA = myJoin.states[keysBA as any]
 					const state = findInStore(familyBA, key, store)
 					return state
 				},
 			} as JoinStates<ASide, BSide, Cardinality, Content>
 			const entryAB = `${token.a}EntryOf${capitalize(token.b)}`
-			if (entryAB in join.states) {
+			if (entryAB in myJoin.states) {
 				const entriesBA = `${token.b}EntriesOf${capitalize(token.a)}`
 				Object.assign(relations, {
 					get [entryAB]() {
-						const familyAB = join.states[entryAB as any]
+						const familyAB = myJoin.states[entryAB as any]
 						const state = findInStore(familyAB, key, store)
 						return state
 					},
 					get [entriesBA]() {
-						const familyBA = join.states[entriesBA as any]
+						const familyBA = myJoin.states[entriesBA as any]
 						const state = findInStore(familyBA, key, store)
 						return state
 					},
@@ -741,27 +758,27 @@ export function findRelationsInStore<
 			const keysBA = `${token.b}KeysOf${capitalize(token.a)}`
 			relations = {
 				get [keysAB]() {
-					const familyAB = join.states[keysAB as any]
+					const familyAB = myJoin.states[keysAB as any]
 					const state = findInStore(familyAB, key, store)
 					return state
 				},
 				get [keysBA]() {
-					const familyBA = join.states[keysBA as any]
+					const familyBA = myJoin.states[keysBA as any]
 					const state = findInStore(familyBA, key, store)
 					return state
 				},
 			} as JoinStates<ASide, BSide, Cardinality, Content>
 			const entriesAB = `${token.a}EntriesOf${capitalize(token.b)}`
-			if (entriesAB in join.states) {
+			if (entriesAB in myJoin.states) {
 				const entriesBA = `${token.b}EntriesOf${capitalize(token.a)}`
 				Object.assign(relations, {
 					get [entriesAB]() {
-						const familyAB = join.states[entriesAB as any]
+						const familyAB = myJoin.states[entriesAB as any]
 						const state = findInStore(familyAB, key, store)
 						return state
 					},
 					get [entriesBA]() {
-						const familyBA = join.states[entriesBA as any]
+						const familyBA = myJoin.states[entriesBA as any]
 						const state = findInStore(familyBA, key, store)
 						return state
 					},
@@ -794,15 +811,15 @@ export function editRelationsInStore<
 	change: (relations: Junction<ASide, BSide, Content>) => void,
 	store: Store,
 ): void {
-	const join = getJoin(token, store)
+	const myJoin = getJoin(token, store)
 	const target = newest(store)
 	if (isChildStore(target)) {
 		const { transactors } = target.transactionMeta
-		join.transact(transactors, ({ relations }) => {
+		myJoin.transact(transactors, ({ relations }) => {
 			change(relations)
 		})
 	} else {
-		change(join.relations)
+		change(myJoin.relations)
 	}
 }
 
@@ -822,8 +839,8 @@ export function getInternalRelationsFromStore(
 	token: JoinToken<any, any, any, any>,
 	store: Store,
 ): MutableAtomFamilyToken<SetRTX<string>, SetRTXJson<string>, string> {
-	const join = getJoin(token, store)
-	const family = join.core.findRelatedKeysState
+	const myJoin = getJoin(token, store)
+	const family = myJoin.core.findRelatedKeysState
 	return family
 }
 

package/dist/{chunk-YDOGCZ53.js → chunk-ATKDGVTV.js}

@@ -27,8 +27,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`,
@@ -43,9 +43,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`,
@@ -53,7 +53,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 {
@@ -61,7 +61,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(
@@ -70,7 +70,7 @@ function syncContinuity(continuity, socket, store) {
         continuityKey,
         `updates do not match`,
         optimisticUpdate,
-        confirmedUpdate2
+        confirmedUpdate
       );
       const reversedOptimisticUpdates = optimisticUpdates.toReversed();
       for (const subsequentOptimistic of reversedOptimisticUpdates) {
@@ -91,15 +91,15 @@ function syncContinuity(continuity, socket, store) {
         `undid zeroth optimistic update`,
         optimisticUpdate
       );
-      ingestTransactionUpdate(`newValue`, confirmedUpdate2, store);
+      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`,
@@ -121,7 +121,7 @@ function syncContinuity(continuity, socket, store) {
       `continuity`,
       continuityKey,
       `integrating confirmed update`,
-      { confirmedUpdate, confirmedUpdates, optimisticUpdates }
+      { confirmedUpdate: confirmed, confirmedUpdates, optimisticUpdates }
     );
     const zerothOptimisticUpdate = optimisticUpdates[0];
     if (zerothOptimisticUpdate) {
@@ -131,14 +131,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)) {
@@ -152,10 +152,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(
@@ -163,12 +163,12 @@ function syncContinuity(continuity, socket, store) {
             `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;
             },
@@ -185,48 +185,48 @@ function syncContinuity(continuity, socket, store) {
       );
       const continuityEpoch = getEpochNumberOfContinuity(continuityKey, store);
       const isRoot = 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})`
         );
-        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 !== 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`
           );
           setIntoStore(
             confirmedUpdateQueue,
             (queue) => {
-              queue.push(confirmedUpdate);
+              queue.push(confirmed);
               queue.sort((a, b) => a.epoch - b.epoch);
               return queue;
             },