anear-js-api 1.6.2 → 1.6.3

package/lib/state_machines/AnearEventMachine.js

@@ -204,7 +204,8 @@ const AnearEventMachineContext = (
   pendingCancelAction: null,  // ACTION to forward after cancellation completes: { participantId, appEventName, payload }
   consecutiveTimeoutCount: 0,  // Global counter tracking consecutive timeouts across all participants for dead-man switch
   consecutiveAllParticipantsTimeoutCount: 0,  // Counter tracking consecutive allParticipants timeouts where ALL participants timed out
-  eventStats: null  // Set on createAppEventMachine onDone (initial or rehydrated); createInitialEventStats() shape
+  eventStats: null,  // Set on createAppEventMachine onDone (initial or rehydrated); createInitialEventStats() shape
+  lastRenderResult: null  // { anyDisplaySent } from renderDisplay onDone; used to send noDisplaysSent on RENDERED and avoid re-render loops when all participants exited
 })
 
 const ActiveEventGlobalEvents = {
@@ -425,7 +426,7 @@ const ActiveEventStatesConfig = {
             input: ({ context, event }) => ({ context, event }),
             onDone: {
               target: 'notifyingPausedRenderComplete',
-              actions: ['clearParticipantTimeoutSuppression']
+              actions: ['setLastRenderResult', 'clearParticipantTimeoutSuppression']
               // v5 note: internal transitions are the default (v4 had `internal: true`)
             },
             onError: {
@@ -464,7 +465,7 @@ const ActiveEventStatesConfig = {
             input: ({ context, event }) => ({ context, event }),
             onDone: {
               target: 'notifyingRenderComplete',
-              actions: ['clearParticipantTimeoutSuppression']
+              actions: ['setLastRenderResult', 'clearParticipantTimeoutSuppression']
               // v5 note: internal transitions are the default (v4 had `internal: true`)
             },
             onError: {
@@ -580,7 +581,7 @@ const ActiveEventStatesConfig = {
             input: ({ context, event }) => ({ context, event }),
             onDone: {
               target: 'notifyingRenderComplete',
-              actions: ['clearParticipantTimeoutSuppression']
+              actions: ['setLastRenderResult', 'clearParticipantTimeoutSuppression']
               // v5 note: internal transitions are the default (v4 had `internal: true`)
             },
             onError: {
@@ -763,11 +764,11 @@ const ActiveEventStatesConfig = {
               {
                 guard: 'isParticipantsTimeoutActive',
                 target: 'notifyingRenderCompleteWithTimeout',
-                actions: ['setupParticipantsTimeout', 'setupCancelActionType', 'clearParticipantTimeoutSuppression']
+                actions: ['setLastRenderResult', 'setupParticipantsTimeout', 'setupCancelActionType', 'clearParticipantTimeoutSuppression']
               },
               {
                 target: 'notifyingRenderComplete',
-                actions: ['setupCancelActionType', 'clearParticipantTimeoutSuppression']
+                actions: ['setLastRenderResult', 'setupCancelActionType', 'clearParticipantTimeoutSuppression']
                 // v5 note: internal transitions are the default (v4 had `internal: true`)
               }
             ],
@@ -816,13 +817,13 @@ const ActiveEventStatesConfig = {
                   {
                     guard: 'isParticipantsTimeoutActive',
                     target: 'notifyingRenderComplete',
-                    actions: ['setupCancelActionType', 'clearParticipantTimeoutSuppression']
+                    actions: ['setLastRenderResult', 'setupCancelActionType', 'clearParticipantTimeoutSuppression']
                     // Note: We do NOT call setupParticipantsTimeout here because we're already in waitAllParticipantsResponse
                     // and the timer is still running from the parent state (preserved by nested state pattern).
                   },
                   {
                     target: '#waitingForActions',
-                    actions: ['setupCancelActionType', 'clearParticipantTimeoutSuppression', 'notifyAppMachineRendered']
+                    actions: ['setLastRenderResult', 'setupCancelActionType', 'clearParticipantTimeoutSuppression', 'notifyAppMachineRendered']
                   }
                 ],
                 onError: {
@@ -1474,6 +1475,10 @@ const AnearEventMachineFunctions = ({
         return { ...s, liveDurationMs: (s.liveDurationMs || 0) + add, liveStartedAt: null }
       }
     }),
+    setLastRenderResult: assign(({ event }) => {
+      const output = event?.output ?? event?.data
+      return { lastRenderResult: output && typeof output === 'object' ? output : null }
+    }),
     notifyAppMachineRendered: ({ context }) => {
       if (context.appEventMachine) {
         logger.debug('[AEM] Sending RENDERED to AppM')

package/lib/utils/AppMachineTransition.js

@@ -121,14 +121,12 @@ const AppMachineTransition = (anearEvent) => {
     }
 
     if (event.type === 'RENDERED') {
-      // Re-examine meta on RENDERED; send RENDER_DISPLAY only when state/context actually changed.
-      // Exception: eachParticipant states re-send once on RENDERED so participants who had a
-      // display queued (e.g. joined while another was publishing) still get the view. No opt-in.
-      const hasEachParticipant = (rawMeta && typeof rawMeta === 'object' && rawMeta.eachParticipant != null) ||
-        metaObjects.some(m => m && typeof m === 'object' && m.eachParticipant != null)
+      // RENDERED means "display processing done; AppM transitions out of the display state."
+      // Do not re-send RENDER_DISPLAY on RENDERED. New participants get their initial view via
+      // PARTICIPANT_ENTER flow, not by re-running eachParticipant here.
       const sameSignature = baseSignature === lastBaseSignature
-      if (sameSignature && !hasEachParticipant) {
-        logger.debug(`[AppMachineTransition] RENDERED re-examination: no change, skipping RENDER_DISPLAY stateName='${stateName}'`)
+      if (sameSignature) {
+        logger.debug(`[AppMachineTransition] RENDERED: no change, skipping RENDER_DISPLAY stateName='${stateName}'`)
         return
       }
       lastBaseSignature = baseSignature

package/lib/utils/DisplayEventProcessor.js

@@ -81,16 +81,18 @@ class DisplayEventProcessor {
       // ignore precompute errors; fall back to runtime values
     }
 
-    const publishPromises = displayEvents.map(event => {
-      const { publishPromise, timeout } = this._processSingle(event)
+    const results = displayEvents.map(event => this._processSingle(event))
+    const publishPromises = results.map(r => r.publishPromise)
+    const anyDisplaySent = results.some(r => r.displaySent === true)
+
+    results.forEach(({ timeout }) => {
       if (timeout) {
         participantsTimeout = timeout
       }
-      return publishPromise
     })
 
     return Promise.all(publishPromises).then(() => {
-      return { participantsTimeout, cancelActionType }
+      return { participantsTimeout, cancelActionType, anyDisplaySent }
     })
   }
 
@@ -141,6 +143,7 @@ class DisplayEventProcessor {
     // display event, but if not, it falls back to the viewer from the meta block.
     const displayViewer = viewer || appRenderContext.meta.viewer
 
+    let displaySent = false
     switch (displayViewer) {
       case 'allParticipants':
         const templateName = normalizedPath.replace(C.PugSuffix, '')
@@ -176,6 +179,7 @@ class DisplayEventProcessor {
           'PARTICIPANTS_DISPLAY',
           formattedDisplayMessage()
         )
+        displaySent = true
         break
 
       case 'spectators':
@@ -187,6 +191,7 @@ class DisplayEventProcessor {
         if (!this.spectatorsDisplayChannel) {
           logger.debug('[DisplayEventProcessor] spectatorsDisplayChannel is null; skipping SPECTATORS_DISPLAY publish')
           publishPromise = Promise.resolve()
+          displaySent = false
           break
         }
 
@@ -220,24 +225,29 @@ class DisplayEventProcessor {
           'SPECTATORS_DISPLAY',
           formattedDisplayMessage()
         )
+        displaySent = true
         break
 
-      case 'eachParticipant':
+      case 'eachParticipant': {
         const templateNameEach = normalizedPath.replace(C.PugSuffix, '')
         if (participantId === 'ALL_PARTICIPANTS') {
           // Legacy behavior - send to all participants (uses timeoutFn)
           logger.info(`[DisplayEventProcessor] RENDER_DISPLAY template=${templateNameEach} viewer=eachParticipant participantId=ALL_PARTICIPANTS`)
           publishPromise = this._processPrivateParticipantDisplays(template, templateRenderContext, timeoutFn)
+          displaySent = true // We attempt to send to all in index; at least one may receive
         } else if (participantId) {
           // Selective participant rendering - send to specific participant only (uses displayTimeout)
           logger.info(`[DisplayEventProcessor] RENDER_DISPLAY template=${templateNameEach} viewer=eachParticipant participantId=${participantId}`)
-          publishPromise = this._processSelectiveParticipantDisplay(template, templateRenderContext, null, participantId, displayTimeout)
+          const result = this._processSelectiveParticipantDisplayWithSent(template, templateRenderContext, null, participantId, displayTimeout)
+          publishPromise = result.promise
+          displaySent = result.displaySent
         } else {
           // Fallback - should not happen with unified approach
           logger.warn(`[DisplayEventProcessor] Unexpected participant display event without participantId`)
           publishPromise = Promise.resolve()
         }
         break
+      }
 
       case 'host':
         const templateNameHost = normalizedPath.replace(C.PugSuffix, '')
@@ -277,12 +287,13 @@ class DisplayEventProcessor {
           templateRenderContext,
           hostOwnMsecs !== null ? (() => hostOwnMsecs) : null
         )
+        displaySent = true
         break
 
       default:
         throw new Error(`Unknown display viewer: ${displayViewer}`)
     }
-    return { publishPromise, timeout }
+    return { publishPromise, timeout, displaySent }
   }
 
   _processHostDisplay(template, templateRenderContext, timeoutFn) {
@@ -329,30 +340,35 @@ class DisplayEventProcessor {
     return Promise.resolve()
   }
 
-  _processSelectiveParticipantDisplay(template, templateRenderContext, timeoutFn, participantId, displayTimeout = null) {
+  /**
+   * Returns { promise, displaySent } for selective participant display.
+   * When participant is not found (exited), we treat as delivered (displaySent: false) so the
+   * render cycle can complete and we avoid infinite RENDER_DISPLAY/RENDERED loops.
+   */
+  _processSelectiveParticipantDisplayWithSent(template, templateRenderContext, timeoutFn, participantId, displayTimeout = null) {
     const participantStruct = this.participantsIndex.get(participantId)
 
     if (!participantStruct) {
-      logger.warn(`[DisplayEventProcessor] Participant ${participantId} not found for selective display`)
-      return Promise.resolve()
+      logger.debug(`[DisplayEventProcessor] Participant ${participantId} not found for selective display (exited); treating as delivered`)
+      return { promise: Promise.resolve(), displaySent: false }
     }
 
     // Exclude the host from receiving displays targeted at participants
     if (participantStruct.info.isHost) {
       logger.warn(`[DisplayEventProcessor] Cannot send participant display to host ${participantId}`)
-      return Promise.resolve()
+      return { promise: Promise.resolve(), displaySent: false }
     }
 
     // Skip inactive participants (idle in open house events)
     if (participantStruct.info.active === false) {
       logger.debug(`[DisplayEventProcessor] Skipping display for inactive participant ${participantId}`)
-      return Promise.resolve()
+      return { promise: Promise.resolve(), displaySent: false }
     }
 
     const participantMachine = this.participantMachines[participantId]
     if (!participantMachine) {
-      logger.warn(`[DisplayEventProcessor] Participant machine not found for ${participantId}`)
-      return Promise.resolve()
+      logger.debug(`[DisplayEventProcessor] Participant machine not found for ${participantId} (exited); treating as delivered`)
+      return { promise: Promise.resolve(), displaySent: false }
     }
 
     // Use displayTimeout if available, otherwise fall back to timeoutFn
@@ -361,7 +377,12 @@ class DisplayEventProcessor {
       timeoutFn
 
     this._sendPrivateDisplay(participantMachine, participantId, template, templateRenderContext, effectiveTimeoutFn)
-    return Promise.resolve()
+    return { promise: Promise.resolve(), displaySent: true }
+  }
+
+  _processSelectiveParticipantDisplay(template, templateRenderContext, timeoutFn, participantId, displayTimeout = null) {
+    const { promise } = this._processSelectiveParticipantDisplayWithSent(template, templateRenderContext, timeoutFn, participantId, displayTimeout)
+    return promise
   }
 
   _sendPrivateDisplay(participantMachine, participantId, template, templateRenderContext, timeoutFn) {

package/package.json

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