anear-js-api 1.2.2 → 1.2.3

package/lib/state_machines/AnearEventMachine.js

@@ -166,7 +166,8 @@ const AnearEventMachineContext = (
   suppressParticipantTimeouts: false,  // Flag to suppress PARTICIPANT_TIMEOUT events (cleared when new timers are set up via render)
   eachParticipantCancelActionType: null,  // ACTION type that triggers cancellation for eachParticipant timeouts
   pendingCancelConfirmations: null,  // Set of participantIds waiting for TIMER_CANCELED confirmation
-  pendingCancelAction: null  // ACTION to forward after cancellation completes: { participantId, appEventName, payload }
+  pendingCancelAction: null,  // ACTION to forward after cancellation completes: { participantId, appEventName, payload }
+  consecutiveTimeoutCounts: {}  // { participantId: count } tracking consecutive timeouts per participant for dead-man switch
 })
 
 const ActiveEventGlobalEvents = {
@@ -278,7 +279,7 @@ const ActiveEventStatesConfig = {
       ],
       on: {
         ACTION: {
-          actions: ['processParticipantAction']
+          actions: ['resetParticipantTimeoutCount', 'processParticipantAction']
         },
         RENDER_DISPLAY: {
           target: '#createdRendering'
@@ -447,7 +448,7 @@ const ActiveEventStatesConfig = {
       initial: 'transitioning',
       on: {
         ACTION: {
-          actions: ['processParticipantAction']
+          actions: ['resetParticipantTimeoutCount', 'processParticipantAction']
         },
         RENDER_DISPLAY: {
           target: '#announceRendering'
@@ -629,6 +630,11 @@ const ActiveEventStatesConfig = {
         },
         CANCEL_ALL_PARTICIPANT_TIMEOUTS: {
           actions: 'cancelAllParticipantTimeouts'
+        },
+        // Handle PARTICIPANT_TIMEOUT even when in liveRendering state
+        // (events bubble up from child states, so we need to handle them here)
+        PARTICIPANT_TIMEOUT: {
+          actions: ['trackParticipantTimeout', 'processParticipantTimeout']
         }
       },
       states: {
@@ -681,7 +687,7 @@ const ActiveEventStatesConfig = {
             },
             // Forward per-participant timeouts (from APM) to the AppM
             PARTICIPANT_TIMEOUT: {
-              actions: ['processParticipantTimeout'],
+              actions: ['trackParticipantTimeout', 'processParticipantTimeout'],
               // v5 note: internal transitions are the default (v4 had `internal: true`)
             },
             TRIGGER_CANCEL_SEQUENCE: {
@@ -794,7 +800,7 @@ const ActiveEventStatesConfig = {
                 target: 'handleParticipantsTimeoutCanceled'
               },
               {
-                actions: ['processAndForwardAction', 'processParticipantResponse'],
+                actions: ['resetParticipantTimeoutCount', 'processAndForwardAction', 'processParticipantResponse'],
                 // v5 note: internal transitions are the default (v4 had `internal: true`)
               }
             ],
@@ -1831,6 +1837,17 @@ const AnearEventMachineFunctions = ({
       const eventName = getPresenceEventName(participant, 'UPDATE');
       context.appEventMachine.send({ type: eventName, data: event.data });
     },
+    resetParticipantTimeoutCount: assign(({ context, event }) => {
+      const participantId = event.data.participantId
+      // Reset consecutive timeout count when participant sends an action
+      if (context.consecutiveTimeoutCounts[participantId]) {
+        logger.debug(`[AEM] Resetting timeout count for participant ${participantId} (action received)`)
+        const newCounts = { ...context.consecutiveTimeoutCounts }
+        delete newCounts[participantId]
+        return { consecutiveTimeoutCounts: newCounts }
+      }
+      return {}
+    }),
     processParticipantAction: ({ context, event, self }) => {
       // event.data.participantId,
       // event.data.payload: {"appEventMachineACTION": {action event keys and values}}
@@ -1916,7 +1933,21 @@ const AnearEventMachineFunctions = ({
         }
       }
     }),
-    processParticipantTimeout: ({ context, event }) => {
+    trackParticipantTimeout: assign(({ context, event }) => {
+      const participantId = event.participantId
+      const currentCount = context.consecutiveTimeoutCounts[participantId] || 0
+      const newCount = currentCount + 1
+
+      logger.debug(`[AEM] Participant ${participantId} timeout count: ${currentCount} -> ${newCount}`)
+
+      return {
+        consecutiveTimeoutCounts: {
+          ...context.consecutiveTimeoutCounts,
+          [participantId]: newCount
+        }
+      }
+    }),
+    processParticipantTimeout: ({ context, event, self }) => {
       // Suppress PARTICIPANT_TIMEOUT events after cancelAllParticipantTimeouts() until new timers
       // are set up via render. This handles race conditions where an APM's timer fires just
       // before receiving CANCEL_TIMEOUT. The flag is cleared when renders complete (new timers set up).
@@ -1924,7 +1955,19 @@ const AnearEventMachineFunctions = ({
         logger.debug(`[AEM] Suppressing PARTICIPANT_TIMEOUT from ${event.participantId} (cancelled timers, waiting for new render)`)
         return
       }
-      context.appEventMachine.send({ type: 'PARTICIPANT_TIMEOUT', participantId: event.participantId })
+
+      const participantId = event.participantId
+      const timeoutCount = context.consecutiveTimeoutCounts[participantId] || 0
+      const maxConsecutiveTimeouts = C.DEAD_MAN_SWITCH.MAX_CONSECUTIVE_PARTICIPANT_TIMEOUTS
+
+      // Check dead-man switch: if participant has exceeded consecutive timeout threshold, cancel event
+      if (timeoutCount >= maxConsecutiveTimeouts) {
+        logger.warn(`[AEM] Dead-man switch triggered: Participant ${participantId} has ${timeoutCount} consecutive timeouts (threshold: ${maxConsecutiveTimeouts}). Auto-canceling event.`)
+        self.send({ type: 'CANCEL' })
+        return
+      }
+
+      context.appEventMachine.send({ type: 'PARTICIPANT_TIMEOUT', participantId })
     },
     setupParticipantsTimeout: assign(({ context, event }) => {
       // Only set up a new timeout if one is provided by the display render workflow
@@ -2001,11 +2044,20 @@ const AnearEventMachineFunctions = ({
         }
       };
     }),
-    sendActionsTimeoutToAppM: ({ context }) => {
+    sendActionsTimeoutToAppM: ({ context, self }) => {
       const { nonResponders, msecs } = context.participantsActionTimeout
       const nonResponderIds = [...nonResponders]
+      const allActiveParticipantIds = getActiveParticipantIds(context)
+
       logger.info(`[AEM] allParticipants timeout expired after ${msecs}ms. Non-responders: ${nonResponderIds.join(', ')}`)
 
+      // Dead-man switch: if all participants timed out, auto-cancel the event
+      if (nonResponders.size === allActiveParticipantIds.length && allActiveParticipantIds.length > 0) {
+        logger.warn(`[AEM] Dead-man switch triggered: All ${allActiveParticipantIds.length} participants timed out in allParticipants timeout. Auto-canceling event.`)
+        self.send({ type: 'CANCEL' })
+        return
+      }
+
       if (context.appEventMachine) {
         context.appEventMachine.send({ type: 'ACTIONS_TIMEOUT', timeout: msecs, nonResponderIds })
       }
@@ -2048,6 +2100,9 @@ const AnearEventMachineFunctions = ({
 
       logger.debug(`[AEM] cleaning up exiting participant ${participantId}`)
 
+      // Clean up timeout counts for exiting participant
+      const { [participantId]: removedTimeoutCount, ...remainingTimeoutCounts } = context.consecutiveTimeoutCounts
+
       if (participant) {
         const isOpenHouse = context.anearEvent.openHouse || false
 
@@ -2070,7 +2125,8 @@ const AnearEventMachineFunctions = ({
               ...context.participants,
               [participantId]: updatedParticipant
             },
-            participantMachines: remainingMachines
+            participantMachines: remainingMachines,
+            consecutiveTimeoutCounts: remainingTimeoutCounts
           }
         } else {
           // For non-open-house events: remove both participant and machine (existing behavior)
@@ -2086,11 +2142,14 @@ const AnearEventMachineFunctions = ({
 
           return {
             participants: remainingParticipants,
-            participantMachines: remainingMachines
+            participantMachines: remainingMachines,
+            consecutiveTimeoutCounts: remainingTimeoutCounts
           }
         }
       } else {
-        return {}
+        return {
+          consecutiveTimeoutCounts: remainingTimeoutCounts
+        }
       }
     }),
     notifyCoreServiceMachineExit: ({ context }) => {

package/lib/utils/Constants.js

@@ -16,6 +16,10 @@ module.exports = {
     RECONNECT: 30 * 1000, // 30 seconds
     BOOT_EXIT: 2 * 1000 // 5 seconds
   },
+  DEAD_MAN_SWITCH: {
+    // Maximum consecutive timeouts per participant before auto-canceling event
+    MAX_CONSECUTIVE_PARTICIPANT_TIMEOUTS: 4
+  },
   EventStates: {
     CREATED: 'created',
     STARTED: 'started',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "anear-js-api",
-  "version": "1.2.2",
+  "version": "1.2.3",
   "description": "Javascript Developer API for Anear Apps",
   "main": "lib/index.js",
   "scripts": {