anear-js-api 0.5.2 → 0.5.4

package/lib/state_machines/AnearEventMachine.js

@@ -34,6 +34,11 @@ const getAllParticipantIds = (context) => {
   return Object.keys(context.participants);
 };
 
+const getPresenceEventName = (participant, presenceAction) => {
+  const role = participant && participant.isHost ? 'HOST' : 'PARTICIPANT';
+  return `${role}_${presenceAction}`;
+};
+
 const RealtimeMessaging = require('../utils/RealtimeMessaging')
 const AppMachineTransition = require('../utils/AppMachineTransition')
 const DisplayEventProcessor = require('../utils/DisplayEventProcessor')
@@ -51,7 +56,8 @@ const AnearEventMachineContext = (
   pugTemplates,
   pugHelpers,
   appEventMachineFactory,
-  appParticipantMachineFactory
+  appParticipantMachineFactory,
+  rehydrate = false
 ) => ({
   anearEvent,
   coreServiceMachine,
@@ -59,6 +65,7 @@ const AnearEventMachineContext = (
   pugHelpers,
   appEventMachineFactory,
   appParticipantMachineFactory,
+  rehydrate,
   appEventMachine: null,
   eventChannel: null,               // event control messages
   actionsChannel: null,             // participant presence/live actions
@@ -72,11 +79,14 @@ const AnearEventMachineContext = (
 const DeferredStates = [
   'PARTICIPANT_ENTER',
   'PARTICIPANT_LEAVE',
+  'PARTICIPANT_UPDATE',
   'SPECTATOR_ENTER',
   'PARTICIPANT_TIMEOUT',
   'ACTION',
   'CANCEL',
-  'CLOSE'
+  'CLOSE',
+  'SAVE',
+  'PAUSE'
 ]
 
 const DeferredStatesPlus = (...additionalStates) => DeferredStates.concat(additionalStates)
@@ -94,6 +104,10 @@ const ActiveEventGlobalEvents = {
   CANCEL: {
     // appM does an abrupt shutdown of the event
     target: '#canceled'
+  },
+  APPM_FINAL: {
+    // AppM reached a root-level final → cleanup only (no ANAPI transition)
+    target: '#activeEvent.shutdownOnly'
   }
 }
 
@@ -186,10 +200,6 @@ const ActiveEventStatesConfig = {
           target: '#createdRendering'
         },
         PARTICIPANT_LEAVE: [
-          {
-            cond: 'isHostLeaving',
-            actions: ['sendHostExitToAppMachine', 'sendExitToParticipantMachine']
-          },
           {
             cond: 'isPermanentLeave',
             actions: ['sendExitToAppMachine', 'sendExitToParticipantMachine']
@@ -198,6 +208,25 @@ const ActiveEventStatesConfig = {
             actions: ['processDisconnectEvents']
           }
         ],
+        PARTICIPANT_UPDATE: [
+          // In the future, the AnearBrowser may periodically send presence updates to the AEM
+          // which will include latitude/longitude direction, etc. for Apps that require this
+          // level of approved user location tracking.  These types of explicit presence.updates
+          // will include a type field in the event payload to indicate the type of update.
+          // Otherwise, the Realtime messaging system in the mobile client browser may be
+          // sending this presence updated implicityly without a type because it has detected
+          // that the user left the event and came back.  If we receive this and the participant exists,
+          // this is a PARTICIPANT_RECONNECT scenario.   The User likely navigated away from the
+          // event and came back.  We need to update the AppM with a PARTICIPANT_RECONNECT event
+          // so they can refresh the view for the returning participant.
+          {
+            cond: 'isReconnectUpdate',
+            actions: 'processReconnectEvents'
+          },
+          {
+            actions: ['updateParticipantGeoLocation', 'processUpdateEvents']
+          }
+        ],
         PARTICIPANT_ENTER: [
           {
             cond: 'participantExists',
@@ -224,6 +253,42 @@ const ActiveEventStatesConfig = {
             },
             START: {
               target: '#activeEvent.live'
+            },
+            PAUSE: {
+              target: '#pausingEvent'
+            },
+            SAVE: {
+              target: 'savingAppEventContext'
+            }
+          }
+        },
+        pausingEvent: {
+          id: 'pausingEvent',
+          deferred: DeferredStates,
+          invoke: {
+            src: 'saveAppEventContext',
+            onDone: {
+              actions: ['sendPausedAckToAppMachine'],
+              target: '#waitingAnnounce',
+              internal: true
+            },
+            onError: {
+              target: '#activeEvent.failure'
+            }
+          }
+        },
+        savingAppEventContext: {
+          id: 'savingAppEventContext',
+          invoke: {
+            src: 'saveAppEventContext',
+            onDone: {
+              actions: ['sendSavedAckToAppMachine'],
+              target: '#waitingAnnounce',
+              internal: true
+            },
+            onError: {
+              // If save fails, log and remain in waitingAnnounce; AppM may retry/handle error UI
+              target: '#waitingAnnounce'
             }
           }
         },
@@ -265,10 +330,6 @@ const ActiveEventStatesConfig = {
           target: '#announceRendering'
         },
         PARTICIPANT_LEAVE: [
-          {
-            cond: 'isHostLeaving',
-            actions: ['sendHostExitToAppMachine', 'sendExitToParticipantMachine']
-          },
           {
             cond: 'isPermanentLeave',
             actions: ['sendExitToAppMachine', 'sendExitToParticipantMachine']
@@ -289,6 +350,9 @@ const ActiveEventStatesConfig = {
             target: '#newParticipantJoining'
           }
         ],
+        BOOT_PARTICIPANT: {
+          actions: 'sendBootEventToParticipantMachine'
+        },
         SPECTATOR_ENTER: {
           actions: 'sendSpectatorEnterToAppEventMachine'
         }
@@ -385,10 +449,6 @@ const ActiveEventStatesConfig = {
           target: '#liveRendering'
         },
         PARTICIPANT_LEAVE: [
-          {
-            cond: 'isHostLeaving',
-            actions: ['sendHostExitToAppMachine', 'sendExitToParticipantMachine']
-          },
           {
             cond: 'isPermanentLeave',
             actions: ['sendExitToAppMachine', 'sendExitToParticipantMachine']
@@ -407,8 +467,8 @@ const ActiveEventStatesConfig = {
             target: '.participantEntering'
           }
         ],
-        PAUSE: {
-          target: 'paused'
+        BOOT_PARTICIPANT: {
+          actions: 'sendBootEventToParticipantMachine'
         }
       },
       states: {
@@ -491,8 +551,8 @@ const ActiveEventStatesConfig = {
             },
             PARTICIPANT_LEAVE: [
               {
-                cond: 'isHostLeaving',
-                actions: ['removeLeavingParticipantFromTimeout', 'sendHostExitToAppMachine', 'sendExitToParticipantMachine']
+                cond: 'isBooting',
+                actions: ['removeLeavingParticipantFromTimeout', 'sendExitToParticipantMachine']
               },
               {
                 cond: 'isPermanentLeave',
@@ -539,29 +599,6 @@ const ActiveEventStatesConfig = {
         }
       }
     },
-    paused: {
-      initial: 'transitioning',
-      states: {
-        transitioning: {
-          deferred: DeferredStatesPlus('RESUME', 'CLOSE'),
-          invoke: {
-            src: 'transitionToPaused',
-            onDone: {
-              target: 'waitingForResume'
-            },
-            onError: {
-              target: '#activeEvent.failure'
-            }
-          }
-        },
-        waitingForResume: {
-          on: {
-            RESUME: '#activeEvent.live',
-            CLOSE: '#activeEvent.closeEvent'
-          }
-        }
-      }
-    },
     closeEvent: {
       id: 'closeEvent',
       initial: 'notifyingParticipants',
@@ -631,7 +668,7 @@ const ActiveEventStatesConfig = {
           }
         },
         finalizing: {
-          deferred: DeferredStates,
+          // canceled path does ANAPI transition to canceled, then detaches
           invoke: {
             src: 'eventTransitionCanceled',
             onDone: 'detaching',
@@ -652,6 +689,42 @@ const ActiveEventStatesConfig = {
         }
       }
     },
+    shutdownOnly: {
+      id: 'shutdownOnly',
+      initial: 'notifyingParticipants',
+      states: {
+        notifyingParticipants: {
+          entry: 'sendParticipantExitEvents',
+          always: 'waitForParticipantsToExit'
+        },
+        waitForParticipantsToExit: {
+          entry: context => logger.debug(`[AEM] Entering waitForParticipantsToExit with ${getAllParticipantIds(context).length} participants`),
+          always: [
+            {
+              cond: context => getAllParticipantIds(context).length === 0,
+              target: 'detaching'
+            }
+          ],
+          on: {
+            PARTICIPANT_LEAVE: {
+              actions: () => logger.debug('[AEM] Ignoring PARTICIPANT_LEAVE during orchestrated shutdown.')
+            }
+          }
+        },
+        detaching: {
+          deferred: DeferredStates,
+          invoke: {
+            src: 'detachChannels',
+            onDone: {
+              target: '#activeEvent.doneExit'
+            },
+            onError: {
+              target: '#activeEvent.failure'
+            }
+          }
+        }
+      }
+    },
     review: {
       on: {
         NEXT: 'reward'
@@ -708,7 +781,10 @@ const CreateEventChannelsAndAppMachineConfig = {
   states: {
     setupEventChannel: {
       // get(eventChannelName) and setup state-change callbacks
-      entry: [(c,e) => logger.debug(`[AEM] === NEW EVENT ${c.anearEvent.id} ===`), 'createEventChannel'],
+      entry: [(c,e) => {
+        const eventType = c.rehydrate ? 'LOAD_EVENT' : 'CREATE_EVENT'
+        logger.debug(`[AEM] === ${eventType} ${c.anearEvent.id} ===`)
+      }, 'createEventChannel'],
       invoke: {
         src: 'attachToEventChannel',
         onDone: {
@@ -720,7 +796,18 @@ const CreateEventChannelsAndAppMachineConfig = {
         }
       },
       on: {
-        ATTACHED: {
+        ATTACHED: 'enterEventPresence'
+      }
+    },
+    enterEventPresence: {
+      invoke: {
+        src: 'enterEventPresence',
+        onDone: {
+          actions: ['subscribeToEventMessages'],
+          target: 'setupParticipantsDisplayChannel',
+          internal: true
+        },
+        onError: {
           actions: ['subscribeToEventMessages'],
           target: 'setupParticipantsDisplayChannel'
         }
@@ -782,9 +869,16 @@ const CreateEventChannelsAndAppMachineConfig = {
       }
     },
     createAppEventMachine: {
-      entry: ['createAppEventMachine'],
-      always: {
-        target: '#activeEvent'
+      invoke: {
+        src: 'createAppEventMachine',
+        onDone: {
+          actions: ['setAppEventMachine'],
+          target: '#activeEvent',
+          internal: true
+        },
+        onError: {
+          target: '#activeEvent.failure'
+        }
       }
     }
   }
@@ -806,12 +900,20 @@ const AnearEventMachineStatesConfig = eventId => ({
 
 const AnearEventMachineFunctions = ({
   actions: {
-    createAppEventMachine: assign({
-      appEventMachine: context => {
-        const machine = context.appEventMachineFactory(context.anearEvent)
-        const service = interpret(machine)
-        service.subscribe(AppMachineTransition(context.anearEvent))
-        return service.start()
+    sendPausedAckToAppMachine: (context, _event) => {
+      if (context.appEventMachine) {
+        context.appEventMachine.send('PAUSED')
+      }
+    },
+    sendSavedAckToAppMachine: (context, _event) => {
+      if (context.appEventMachine) {
+        context.appEventMachine.send('SAVED')
+      }
+    },
+    setAppEventMachine: assign({
+      appEventMachine: (context, event) => {
+        const service = event.data.service
+        return service
       }
     }),
     notifyAppMachineRendered: (context, event) => {
@@ -924,8 +1026,7 @@ const AnearEventMachineFunctions = ({
         return;
       }
 
-      const isHost = anearParticipant.isHost;
-      const eventName = isHost ? 'HOST_ENTER' : 'PARTICIPANT_ENTER';
+      const eventName = getPresenceEventName(anearParticipant, 'ENTER');
       const eventPayload = { participant: participantInfo };
 
       logger.debug(`[AEM] Sending ${eventName} for ${anearParticipant.id}`);
@@ -934,11 +1035,10 @@ const AnearEventMachineFunctions = ({
     processDisconnectEvents: (context, event) => {
       const participantId = event.data.id;
       const participant = context.participants[participantId];
-      const isHost = participant && participant.isHost;
-      const eventName = isHost ? 'HOST_DISCONNECT' : 'PARTICIPANT_DISCONNECT';
+      const eventName = getPresenceEventName(participant, 'DISCONNECT');
       const participantMachine = context.participantMachines[participantId];
 
-      logger.debug(`[AEM] processing disconnect for ${participantId}. Is host? ${isHost}`);
+      logger.debug(`[AEM] processing ${eventName} for ${participantId}`);
       if (participantMachine) {
         participantMachine.send('PARTICIPANT_DISCONNECT');
       }
@@ -947,31 +1047,79 @@ const AnearEventMachineFunctions = ({
     processReconnectEvents: (context, event) => {
       const participantId = event.data.id;
       const participant = context.participants[participantId];
-      const isHost = participant && participant.isHost;
-      const eventName = isHost ? 'HOST_RECONNECT' : 'PARTICIPANT_RECONNECT';
+      const eventName = getPresenceEventName(participant, 'RECONNECT');
       const participantMachine = context.participantMachines[participantId];
 
-      logger.debug(`[AEM] processing reconnect for ${participantId}. Is host? ${isHost}`);
+      logger.debug(`[AEM] processing ${eventName} for ${participantId}`);
       if (participantMachine) {
         participantMachine.send('PARTICIPANT_RECONNECT');
       }
       context.appEventMachine.send(eventName, { participantId });
     },
+    updateParticipantGeoLocation: assign({
+      participants: (context, event) => {
+        const { id, geoLocation } = event.data;
+        const participantInfoToUpdate = context.participants[id];
+
+        if (!participantInfoToUpdate) return context.participants;
+
+        // Create a new, updated info object
+        const updatedParticipantInfo = {
+          ...participantInfoToUpdate,
+          geoLocation
+        };
+
+        // Return a new participants object with the updated participant info
+        return {
+          ...context.participants,
+          [id]: updatedParticipantInfo
+        };
+      }
+    }),
+    processUpdateEvents: (context, event) => {
+      const { id } = event.data;
+      // NOTE: get the full AnearParticipant object from the AEM instance,
+      // NOT the plain info object from the context.
+      const participant = context.participants[id];
+
+      if (!participant) return;
+
+      const eventName = getPresenceEventName(participant, 'UPDATE');
+      const participantMachine = context.participantMachines[id];
+
+      // AppM gets the role-specific event
+      const appMPayload = { type: eventName, participant };
+
+      logger.debug(`[AEM] processing ${eventName} for ${id}`);
+      if (participantMachine) {
+        // APM always gets the generic event
+        const apmPayload = { type: 'PARTICIPANT_UPDATE', participant };
+        participantMachine.send(apmPayload);
+      }
+      context.appEventMachine.send(appMPayload);
+    },
     sendExitToAppMachine: (context, event) => {
-      // coming from an action channel message, event.data.id
       const participantId = event.data.id;
-      const participantInfo = context.participants[participantId];
-      if (participantInfo) {
-        logger.debug(`[AEM] sending PARTICIPANT_EXIT to AppM for participant ${participantId}`);
-        context.appEventMachine.send('PARTICIPANT_EXIT', { participantId });
+      const participant = context.participants[participantId];
+      if (participant) {
+        const eventName = getPresenceEventName(participant, 'EXIT');
+        logger.debug(`[AEM] sending ${eventName} to AppM for participant ${participantId}`);
+        context.appEventMachine.send(eventName, { participantId });
       } else {
         logger.warn(`[AEM] Participant info not found for id ${participantId} during sendExitToAppMachine`);
       }
     },
-    sendHostExitToAppMachine: (context, event) => {
-      const participantId = event.data.id;
-      logger.debug(`[AEM] sending HOST_EXIT to AppM for host ${participantId}`);
-      context.appEventMachine.send('HOST_EXIT', { participantId });
+    sendBootEventToParticipantMachine: (context, event) => {
+      const { participantId, reason } = event.data;
+      const participantMachine = context.participantMachines[participantId];
+      if (participantMachine) {
+        participantMachine.send({
+          type: 'BOOT_PARTICIPANT',
+          data: { reason }
+        })
+      } else {
+        logger.warn(`[AEM] Participant machine not found for id ${participantId} during sendBootEventToParticipantMachine`);
+      }
     },
     sendExitToParticipantMachine: (context, event) => {
       // coming from an action channel message, event.data.id
@@ -986,18 +1134,27 @@ const AnearEventMachineFunctions = ({
     sendParticipantExitEvents: context => {
       Object.values(context.participantMachines).forEach(pm => pm.send('PARTICIPANT_EXIT'))
     },
+    updateParticipantPresence: (context, event) => {
+      const participantId = event.data.id;
+      const participant = context.participants[participantId];
+      const participantMachine = context.participantMachines[participantId];
 
+      if (!participant) {
+        logger.warn(`[AEM] Participant info not found for id ${participantId} during updateParticipantPresence`);
+        return;
+      }
 
-    updateParticipantPresence: (context, event) => {
-      // lookup the participantMachine and update its context
-      const participantMachine = context.participantMachines[event.data.id]
+      // APM always gets the generic event
       if (participantMachine) {
         // opportunity to send presence data update like geoLocation, and
         // to inform app that a participant still has interest in the possibly long
         // running, light-participation event
-        participantMachine.send('PARTICIPANT_UPDATE', event.data)
+        participantMachine.send('PARTICIPANT_UPDATE', event.data);
       }
-      context.appEventMachine.send('PARTICIPANT_UPDATE', event.data)
+
+      // AppM gets the role-specific event
+      const eventName = getPresenceEventName(participant, 'UPDATE');
+      context.appEventMachine.send(eventName, event.data);
     },
     processParticipantAction: (context, event) => {
       // event.data.participantId,
@@ -1053,16 +1210,23 @@ const AnearEventMachineFunctions = ({
       { participantId: event.participantId }
     ),
     setupParticipantsTimeout: assign((context, event) => {
-      const timeoutMsecs = event.data.participantsTimeout.msecs
-      const allParticipantIds = getPlayingParticipantIds(context)
-      logger.debug(`[AEM] Starting participants action timeout for ${timeoutMsecs}ms. Responders: ${allParticipantIds.join(', ')}`)
+      // Only set up a new timeout if one is provided in the event data.
+      // This prevents overwriting an existing timeout during a simple re-render.
+      if (event.data && event.data.participantsTimeout) {
+        const timeoutMsecs = event.data.participantsTimeout.msecs
+        const allParticipantIds = getPlayingParticipantIds(context)
+        logger.debug(`[AEM] Starting participants action timeout for ${timeoutMsecs}ms. Responders: ${allParticipantIds.join(', ')}`)
 
-      return {
-        participantsActionTimeout: {
-          msecs: timeoutMsecs,
-          nonResponders: new Set(allParticipantIds)
+        return {
+          participantsActionTimeout: {
+            msecs: timeoutMsecs,
+            startedAt: Date.now(),
+            nonResponders: new Set(allParticipantIds)
+          }
         }
       }
+      // If no timeout data, return empty object to not change context
+      return {};
     }),
     processParticipantResponse: assign((context, event) => {
       const participantId = event.data.participantId
@@ -1078,17 +1242,24 @@ const AnearEventMachineFunctions = ({
       }
     }),
     removeLeavingParticipantFromTimeout: assign((context, event) => {
-      const participantId = event.data.id
-      const { nonResponders, ...rest } = context.participantsActionTimeout
-      const newNonResponders = new Set(nonResponders)
-      newNonResponders.delete(participantId)
+      const participantId = event.data.id;
+      const participant = context.participants[participantId];
+
+      // If there's no active timeout, or if the leaving participant is the host, do nothing.
+      if (!context.participantsActionTimeout || (participant && participant.isHost)) {
+        return {};
+      }
+
+      const { nonResponders, ...rest } = context.participantsActionTimeout;
+      const newNonResponders = new Set(nonResponders);
+      newNonResponders.delete(participantId);
 
       return {
         participantsActionTimeout: {
           ...rest,
           nonResponders: newNonResponders
         }
-      }
+      };
     }),
     sendActionsTimeoutToAppM: (context, _event) => {
       const { nonResponders, msecs } = context.participantsActionTimeout
@@ -1139,6 +1310,63 @@ const AnearEventMachineFunctions = ({
     logInvalidParticipantEnter: (c, e) => logger.info("[AEM] Error: Unexepected PARTICIPANT_ENTER with id: ", e.data.id),
   },
   services: {
+    saveAppEventContext: async (context, event) => {
+      // Events like PAUSE/SAVE are sent as send('PAUSE', { appmContext: {...} })
+      // event.appmContext -> { context, resumeEvent }
+      const appmContext = event?.appmContext || {}
+      const payload = {
+        eventId: context.anearEvent.id,
+        savedAt: new Date().toISOString(),
+        ...appmContext
+      }
+      await AnearApi.saveAppEventContext(context.anearEvent.id, payload)
+      return 'done'
+    },
+    enterEventPresence: async (context, _event) => {
+      const data = { actor: 'AEM', eventId: context.anearEvent.id, start: Date.now() }
+      await RealtimeMessaging.setPresence(context.eventChannel, data)
+      return { service: started }
+    },
+    createAppEventMachine: async (context, _event) => {
+      // Build the AppM, optionally rehydrating from saved app_event_context
+      const baseMachine = context.appEventMachineFactory(context.anearEvent)
+
+      let machineToStart = baseMachine
+      let resumeEvent = null
+
+      if (context.rehydrate) {
+        try {
+          const { appmContext } = await AnearApi.getLatestAppEventContext(context.anearEvent.id)
+          if (appmContext && typeof appmContext === 'object') {
+            const savedContext = appmContext.context
+            resumeEvent = appmContext.resumeEvent
+            if (savedContext && typeof savedContext === 'object') {
+              machineToStart = baseMachine.withContext(savedContext)
+            }
+          }
+        } catch (e) {
+          // Log and proceed without rehydration
+          logger.warn('[AEM] Failed to fetch or parse app_event_context. Starting clean.', e)
+        }
+      }
+
+      const service = interpret(machineToStart)
+      service.subscribe(AppMachineTransition(context.anearEvent))
+      // Auto-cleanup when AppM final: notify AEM
+      try {
+        service.onDone(() => {
+          logger.debug('[AEM] AppM reached final state, sending APPM_FINAL for cleanup-only shutdown')
+          context.anearEvent.send('APPM_FINAL')
+        })
+      } catch (_e) {}
+      const started = service.start()
+
+      if (resumeEvent && resumeEvent.type) {
+        started.send(resumeEvent)
+      }
+
+      return { service: started }
+    },
     renderDisplay: async (context, event) => {
       const displayEventProcessor = new DisplayEventProcessor(context)
 
@@ -1201,9 +1429,6 @@ const AnearEventMachineFunctions = ({
     transitionToCanceled: (context, event) => {
       return AnearApi.transitionEvent(context.anearEvent.id, 'canceled')
     },
-    transitionToPaused: (context, event) => {
-      return AnearApi.transitionEvent(context.anearEvent.id, 'paused')
-    },
     eventTransitionClosed: async (context, event) => {
       // This service handles the transition of the event to 'closed' via AnearApi
       // and the publishing of the 'EVENT_TRANSITION' message to ABRs.
@@ -1224,6 +1449,10 @@ const AnearEventMachineFunctions = ({
     }
   },
   guards: {
+    isReconnectUpdate: (context, event) => {
+      // participant exists and event.data.type is undefined
+      return context.participants[event.data.id] && !event.data.type
+    },
     isPermanentLeave: (context, event) => {
       // The remote client has left the event.  This is a permanent exit
       // from the event
@@ -1237,18 +1466,18 @@ const AnearEventMachineFunctions = ({
           return false
       }
     },
-    isHostLeaving: (context, event) => {
-      const participantId = event.data.id;
-      const participant = context.participants[participantId];
-      return participant && participant.isHost;
+    isBooting: (_c, event) => {
+      return event.data.type === 'BOOTED'
     },
     participantExists: (context, event) => !!context.participants[event.data.id],
-    eventCreatorIsHost: (context, event) => context.anearEvent.hosted,
-    isOpenHouseEvent: (context, event) => context.anearEvent.openHouse || false,
+    eventCreatorIsHost: (context, _e) => context.anearEvent.hosted,
+    isOpenHouseEvent: (context, _e) => context.anearEvent.openHouse || false,
     isParticipantsTimeoutActive: (context, event) => {
-      return event.data && event.data.participantsTimeout && event.data.participantsTimeout.msecs > 0
+      const isStartingNewTimeout = event.data && event.data.participantsTimeout && event.data.participantsTimeout.msecs > 0;
+      const isTimeoutAlreadyRunning = context.participantsActionTimeout !== null;
+      return isStartingNewTimeout || isTimeoutAlreadyRunning;
     },
-    allParticipantsResponded: (context, event) => {
+    allParticipantsResponded: (context, _e) => {
       return context.participantsActionTimeout && context.participantsActionTimeout.nonResponders.size === 0
     }
   },
@@ -1258,7 +1487,7 @@ const AnearEventMachineFunctions = ({
     timeoutEventAnnounce: context => C.TIMEOUT_MSECS.ANNOUNCE,
     timeoutEventStart: context => C.TIMEOUT_MSECS.START,
     timeoutRendered: context => C.TIMEOUT_MSECS.RENDERED_EVENT_DELAY,
-    participantsActionTimeout: (context, event) => {
+    participantsActionTimeout: (context, _e) => {
       return context.participantsActionTimeout.msecs
     }
   }
@@ -1269,7 +1498,8 @@ const AnearEventMachine = (anearEvent, {
   pugTemplates,
   appEventMachineFactory,
   appParticipantMachineFactory,
-  imageAssetsUrl
+  imageAssetsUrl,
+  rehydrate = false
 }) => {
   const expandedConfig = {predictableActionArguments: true, ...AnearEventMachineStatesConfig(anearEvent.id)}
 
@@ -1282,7 +1512,8 @@ const AnearEventMachine = (anearEvent, {
     pugTemplates,
     pugHelpers,
     appEventMachineFactory,
-    appParticipantMachineFactory
+    appParticipantMachineFactory,
+    rehydrate
   )
 
   const service = interpret(eventMachine.withContext(anearEventMachineContext))