anear-js-api 2.1.1 → 2.2.1

package/lib/state_machines/AnearEventMachine.js

@@ -24,7 +24,6 @@
  *  - Constructed by ACSM with:
  *      - `anearEvent`       → the event JSON model (id, appId, metadata)
  *      - `appEventMachineFactory`
- *      - `appParticipantMachineFactory` (optional)
  *      - ACSM context fields:
  *          - `appData`          (app metadata from ANAPI)
  *          - `pugTemplates`     (preloaded, compiled templates)
@@ -52,7 +51,7 @@
  *  1. AEM is created and started by the ACSM in response to CREATE_EVENT or LOAD_EVENT.
  *  2. AEM configures its event-scoped Ably channels and subscriptions.
  *  3. AEM wires realtime messages (presence, actions, host commands) into the
- *     AppEventMachine and optional participant machines.
+ *     AppEventMachine.
  *  4. On state changes, AEM:
  *       - Renders the appropriate Pug templates using `context.pugTemplates`.
  *       - Publishes updated views and state snapshots out via Ably (participants,
@@ -140,7 +139,6 @@ const DisplayEventProcessor = require('../utils/DisplayEventProcessor')
 const PugHelpers = require('../utils/PugHelpers')
 
 const AnearApi = require('../api/AnearApi')
-const AnearParticipantMachine = require('../state_machines/AnearParticipantMachine')
 const AnearParticipant = require('../models/AnearParticipant')
 
 const CurrentDateTimestamp = _ => new Date().getTime()
@@ -179,7 +177,6 @@ const AnearEventMachineContext = (
   pugTemplates,
   pugHelpers,
   appEventMachineFactory,
-  appParticipantMachineFactory,
   rehydrate = false
 ) => ({
   anearEvent,
@@ -187,7 +184,6 @@ const AnearEventMachineContext = (
   pugTemplates,
   pugHelpers,
   appEventMachineFactory,
-  appParticipantMachineFactory,
   rehydrate,
   appEventMachine: null,
   appMachineTransition: null,
@@ -196,11 +192,10 @@ const AnearEventMachineContext = (
   participantsDisplayChannel: null, // display all participants
   spectatorsDisplayChannel: null,    // display all spectators
   participants: {},
-  participantMachines: {},
+  participantPrivateChannels: {},
+  exitedParticipantPrivateChannels: [],
   participantsActionTimeout: null,
-  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 }
   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
@@ -209,10 +204,6 @@ const AnearEventMachineContext = (
 })
 
 const ActiveEventGlobalEvents = {
-  PARTICIPANT_MACHINE_EXIT: {
-    // the AnearParticipantMachine has hit its final state
-    actions: ['cleanupExitingParticipant']
-  },
   RESTART: {
     // Hosted apps can request a rewind back to ANNOUNCE without terminating the event.
     target: '#activeEvent.restartEvent'
@@ -249,16 +240,19 @@ const ActiveEventStatesConfig = {
           invoke: {
             src: 'getAttachedCreatorOrHost',
             input: ({ context, event }) => ({ context, event }),
-            onDone: {
-              // v5 note: onDone of a fromPromise actor provides the resolved value on `event.output`.
-              // event.output.anearParticipant will be null if no presence enter
-              // was available on actions channel via get().  We must wait for
-              // the undeferred PARTICIPANT_ENTER instead.  But if get() DID
-              // return the creator presence, then an APM will be created
-              // and we goto waiting for the PARTICIPANT_MACHINE_READY
-              actions: ['startNewParticipantMachine'],
-              target: 'waiting'
-            },
+            onDone: [
+              {
+                // If actions-channel presence.get() found creator/host, register now.
+                guard: 'hasAttachedCreatorOrHost',
+                actions: ['startNewParticipantSession', 'sendEnterToAppMachine'],
+                target: '#eventCreated'
+              },
+              {
+                // No creator/host found yet via presence.get(); wait for PARTICIPANT_ENTER.
+                actions: ['logWaitingForCreatorPresence'],
+                target: '#waiting'
+              }
+            ],
             onError: {
               target: '#failure'
             }
@@ -274,10 +268,6 @@ const ActiveEventStatesConfig = {
                 PARTICIPANT_ENTER: {
                   actions: 'logCreatorEnter',
                   target: '#waiting.fetching'
-                },
-                PARTICIPANT_MACHINE_READY: {
-                  actions: ['logAPMReady', 'sendEnterToAppMachine'],
-                  target: '#eventCreated'
                 }
               }
             },
@@ -289,8 +279,8 @@ const ActiveEventStatesConfig = {
                 onDone: {
                   // v5 note: onDone of a fromPromise actor provides the resolved value on `event.output`.
                   // event.output.anearParticipant available in actions
-                  actions: ['startNewParticipantMachine'],
-                  target: '#waiting.creatorStatus'
+                  actions: ['startNewParticipantSession', 'sendEnterToAppMachine'],
+                  target: '#eventCreated'
                 },
                 onError: {
                   target: '#activeEvent.failure'
@@ -327,7 +317,7 @@ const ActiveEventStatesConfig = {
         PARTICIPANT_LEAVE: [
           {
             guard: 'isPermanentLeave',
-            actions: ['sendExitToAppMachine', 'sendExitToParticipantMachine']
+            actions: ['sendExitToAppMachine', 'handleParticipantExit']
           },
           {
             actions: ['processDisconnectEvents', 'setParticipantIdle']
@@ -508,7 +498,7 @@ const ActiveEventStatesConfig = {
         PARTICIPANT_LEAVE: [
           {
             guard: 'isPermanentLeave',
-            actions: ['sendExitToAppMachine', 'sendExitToParticipantMachine']
+            actions: ['sendExitToAppMachine', 'handleParticipantExit']
           },
           {
             actions: ['processDisconnectEvents', 'setParticipantIdle']
@@ -532,7 +522,7 @@ const ActiveEventStatesConfig = {
           }
         ],
         BOOT_PARTICIPANT: {
-          actions: 'sendBootEventToParticipantMachine'
+          actions: 'sendBootEventToParticipant'
         },
         CANCEL_ALL_PARTICIPANT_TIMEOUTS: {
           actions: 'cancelAllParticipantTimeouts'
@@ -590,16 +580,15 @@ const ActiveEventStatesConfig = {
           }
         },
         newParticipantJoining: {
-          // a PARTICIPANT_ENTER received from a new user JOIN click. create an AnearParticipantMachine instance.
-          // This machine tracks presence, geo-location (when approved by mobile participant),
-          // manages active/idle state for long-running events, and manages any ACTION timeouts.
+          // A PARTICIPANT_ENTER received from a new user JOIN click.
+          // Fetch participant and register direct session in AEM.
           id: 'newParticipantJoining',
           invoke: {
             src: 'fetchParticipantData',
             input: ({ context, event }) => ({ context, event }),
             onDone: {
-              actions: ['startNewParticipantMachine'],
-              target: '#waitParticipantReady'
+              actions: ['startNewParticipantSession', 'sendEnterToAppMachine'],
+              target: '#waitingToStart'
             },
             onError: {
               target: '#activeEvent.failure'
@@ -614,16 +603,6 @@ const ActiveEventStatesConfig = {
             }
           }
         },
-        waitParticipantReady: {
-          id: 'waitParticipantReady',
-          on: {
-            PARTICIPANT_MACHINE_READY: {
-              actions: ['sendEnterToAppMachine'],
-              target: '#waitingToStart',
-              // v5 note: internal transitions are the default (v4 had `internal: true`)
-            }
-          }
-        }
       }
     },
     live: {
@@ -645,7 +624,7 @@ const ActiveEventStatesConfig = {
         PARTICIPANT_LEAVE: [
           {
             guard: 'isPermanentLeave',
-            actions: ['sendExitToAppMachine', 'sendExitToParticipantMachine']
+            actions: ['sendExitToAppMachine', 'handleParticipantExit']
           },
           {
             actions: ['processDisconnectEvents', 'setParticipantIdle']
@@ -670,16 +649,9 @@ const ActiveEventStatesConfig = {
           actions: 'sendSpectatorEnterToAppEventMachine'
         },
         BOOT_PARTICIPANT: {
-          actions: 'sendBootEventToParticipantMachine'
+          actions: 'sendBootEventToParticipant'
         },
-        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']
-        }
+        CANCEL_ALL_PARTICIPANT_TIMEOUTS: {}
       },
       states: {
         transitioning: {
@@ -705,54 +677,13 @@ const ActiveEventStatesConfig = {
           },
           initial: 'idle',
           states: {
-            idle: {},
-            waitingForCancelConfirmations: {
-              // Note: Setup actions are called in the transitions that lead here, not in entry
-              // This allows different setup for declarative cancel (TRIGGER_CANCEL_SEQUENCE) vs manual cancel (CANCEL_ALL_PARTICIPANT_TIMEOUTS)
-              on: {
-                TIMER_CANCELED: {
-                  actions: ['removeFromPendingCancelConfirmations']
-                },
-                PARTICIPANT_EXIT: {
-                  actions: ['removeFromPendingCancelConfirmations']
-                },
-                // Drop only ACTION and PARTICIPANT_TIMEOUT events during cancellation wait
-                // All other events (presence events, etc.) will bubble up to parent handlers
-                ACTION: {
-                  actions: ['dropEventDuringCancellation']
-                },
-                PARTICIPANT_TIMEOUT: {
-                  actions: ['dropEventDuringCancellation']
-                }
-              },
-              always: {
-                guard: 'allCancelConfirmationsReceived',
-                actions: ['forwardPendingCancelActionIfExists', 'clearCancelState'],
-                target: '#waitingForActions.idle'
-              }
-            }
+            idle: {}
           },
           on: {
             ACTION: {
               actions: ['resetParticipantTimeoutCount', 'processParticipantAction']
             },
-            // Forward per-participant timeouts (from APM) to the AppM
-            PARTICIPANT_TIMEOUT: {
-              actions: ['trackParticipantTimeout', 'processParticipantTimeout'],
-              // v5 note: internal transitions are the default (v4 had `internal: true`)
-            },
-            CANCEL_ALL_PARTICIPANT_TIMEOUTS: {
-              actions: ['setupPendingCancelConfirmationsForManualCancel', 'sendCancelTimeoutToAllAPMs'],
-              target: '.waitingForCancelConfirmations'
-            },
-            TRIGGER_CANCEL_SEQUENCE: {
-              actions: ['sendCancelTimeoutToAllAPMs', 'setupPendingCancelConfirmations'],
-              target: '.waitingForCancelConfirmations'
-            },
-            TIMER_CANCELED: {
-              // Ignore if not in cancellation state (defensive)
-              actions: []
-            }
+            CANCEL_ALL_PARTICIPANT_TIMEOUTS: {}
           }
         },
         liveRendering: {
@@ -764,11 +695,11 @@ const ActiveEventStatesConfig = {
               {
                 guard: 'isParticipantsTimeoutActive',
                 target: 'notifyingRenderCompleteWithTimeout',
-                actions: ['setLastRenderResult', 'setupParticipantsTimeout', 'setupCancelActionType', 'clearParticipantTimeoutSuppression']
+                actions: ['setLastRenderResult', 'setupParticipantsTimeout', 'setupCancelActionType']
               },
               {
                 target: 'notifyingRenderComplete',
-                actions: ['setLastRenderResult', 'setupCancelActionType', 'clearParticipantTimeoutSuppression']
+                actions: ['setLastRenderResult', 'setupCancelActionType']
                 // v5 note: internal transitions are the default (v4 had `internal: true`)
               }
             ],
@@ -817,13 +748,13 @@ const ActiveEventStatesConfig = {
                   {
                     guard: 'isParticipantsTimeoutActive',
                     target: 'notifyingRenderComplete',
-                    actions: ['setLastRenderResult', 'setupCancelActionType', 'clearParticipantTimeoutSuppression']
+                    actions: ['setLastRenderResult', 'setupCancelActionType']
                     // 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: ['setLastRenderResult', 'setupCancelActionType', 'clearParticipantTimeoutSuppression', 'notifyAppMachineRendered']
+                    actions: ['setLastRenderResult', 'setupCancelActionType', 'notifyAppMachineRendered']
                   }
                 ],
                 onError: {
@@ -872,11 +803,11 @@ const ActiveEventStatesConfig = {
             PARTICIPANT_LEAVE: [
               {
                 guard: 'isBooting',
-                actions: ['removeLeavingParticipantFromTimeout', 'sendExitToParticipantMachine']
+                actions: ['removeLeavingParticipantFromTimeout', 'handleParticipantExit']
               },
               {
                 guard: 'isPermanentLeave',
-                actions: ['removeLeavingParticipantFromTimeout', 'sendExitToAppMachine', 'sendExitToParticipantMachine']
+                actions: ['removeLeavingParticipantFromTimeout', 'sendExitToAppMachine', 'handleParticipantExit']
               },
               {
                 actions: ['processDisconnectEvents']
@@ -893,33 +824,21 @@ const ActiveEventStatesConfig = {
           always: 'waitingForActions'
         },
         participantEntering: {
-          // a PARTICIPANT_ENTER received from a new user JOIN click. Unless already exists,
-          // create an AnearParticipantMachine instance.
-          // This machine tracks presence, geo-location (when approved by mobile participant),
-          // manages active/idle state for long-running events, and manages any ACTION timeouts.
+          // a PARTICIPANT_ENTER received from a new user JOIN click.
+          // Register direct participant session in AEM unless already exists.
           id: 'participantEntering',
           invoke: {
             src: 'fetchParticipantData',
             input: ({ context, event }) => ({ context, event }),
             onDone: {
-              actions: ['startNewParticipantMachine'],
-              target: '#waitParticipantJoined',
+              actions: ['startNewParticipantSession', 'sendEnterToAppMachine'],
+              target: 'waitingForActions',
             },
             onError: {
               target: '#activeEvent.failure'
             }
           }
         },
-        waitParticipantJoined: {
-          id: 'waitParticipantJoined',
-          on: {
-            PARTICIPANT_MACHINE_READY: {
-              actions: ['sendEnterToAppMachine'],
-              target: 'waitingForActions',
-              // v5 note: internal transitions are the default (v4 had `internal: true`)
-            }
-          }
-        }
       }
     },
     restartEvent: {
@@ -990,10 +909,10 @@ const ActiveEventStatesConfig = {
                 // This implies they are not waiting for any game-over screen.
                 // Clean them up immediately without waiting.
                 guard: 'isPermanentLeave',
-                actions: ['cleanupExitingParticipant', (c, e) => logger.debug(`[AEM] Participant ${e.data.id} permanently left during closeEvent shutdown.`)]
+                actions: ['handleParticipantExit', (c, e) => logger.debug(`[AEM] Participant ${e.data.id} permanently left during closeEvent shutdown.`)]
               },
               {
-                actions: ['cleanupExitingParticipant', (c, e) => logger.debug(`[AEM] Participant ${e.data.id} left during closeEvent shutdown.`)]
+                actions: ['handleParticipantExit', (c, e) => logger.debug(`[AEM] Participant ${e.data.id} left during closeEvent shutdown.`)]
               }
             ]
           }
@@ -1061,11 +980,11 @@ const ActiveEventStatesConfig = {
                 // This implies they are not waiting for any game-over screen.
                 // Clean them up immediately without waiting.
                 guard: 'isPermanentLeave',
-                actions: ['cleanupExitingParticipant', (c, e) => logger.debug(`[AEM] Participant ${e.data.id} permanently left during canceled shutdown.`)]
+                actions: ['handleParticipantExit', (c, e) => logger.debug(`[AEM] Participant ${e.data.id} permanently left during canceled shutdown.`)]
               },
               {
                 // Standard leave (e.g. disconnect). Clean them up too.
-                actions: ['cleanupExitingParticipant', (c, e) => logger.debug(`[AEM] Participant ${e.data.id} left during canceled shutdown.`)]
+                actions: ['handleParticipantExit', (c, e) => logger.debug(`[AEM] Participant ${e.data.id} left during canceled shutdown.`)]
               }
             ]
           }
@@ -1130,10 +1049,10 @@ const ActiveEventStatesConfig = {
             PARTICIPANT_LEAVE: [
               {
                 guard: 'isPermanentLeave',
-                actions: ['cleanupExitingParticipant', (c, e) => logger.debug(`[AEM] Participant ${e.data.id} permanently left during shutdownOnly.`)]
+                actions: ['handleParticipantExit', (c, e) => logger.debug(`[AEM] Participant ${e.data.id} permanently left during shutdownOnly.`)]
               },
               {
-                actions: ['cleanupExitingParticipant', (c, e) => logger.debug(`[AEM] Participant ${e.data.id} left during shutdownOnly.`)]
+                actions: ['handleParticipantExit', (c, e) => logger.debug(`[AEM] Participant ${e.data.id} left during shutdownOnly.`)]
               }
             ]
           }
@@ -1197,10 +1116,10 @@ const ActiveEventStatesConfig = {
             PARTICIPANT_LEAVE: [
               {
                 guard: 'isPermanentLeave',
-                actions: ['cleanupExitingParticipant', (c, e) => logger.debug(`[AEM] Participant ${e.data.id} permanently left during suspending.`)]
+                actions: ['handleParticipantExit', (c, e) => logger.debug(`[AEM] Participant ${e.data.id} permanently left during suspending.`)]
               },
               {
-                actions: ['cleanupExitingParticipant', (c, e) => logger.debug(`[AEM] Participant ${e.data.id} left during suspending.`)]
+                actions: ['handleParticipantExit', (c, e) => logger.debug(`[AEM] Participant ${e.data.id} left during suspending.`)]
               }
             ]
           }
@@ -1556,27 +1475,28 @@ const AnearEventMachineFunctions = ({
         self
       )
     }),
-    startNewParticipantMachine: assign(({ context, event }) => {
+    startNewParticipantSession: assign(({ context, event, self }) => {
       const anearParticipant = event?.output?.anearParticipant ?? event?.data?.anearParticipant
 
       if (!anearParticipant) return {}
 
       const existingParticipant = context.participants[anearParticipant.id]
       const isOpenHouse = context.anearEvent.openHouse || false
+      const privateChannelName = anearParticipant.privateChannelName
+      const privateChannel = privateChannelName ? RealtimeMessaging.getChannel(privateChannelName, self) : null
 
       // For open house events: allow machine recreation if participant exists but has no machine (reconnect scenario)
       if (existingParticipant) {
-        if (isOpenHouse && !context.participantMachines[anearParticipant.id]) {
-          // Open house reconnect: participant exists but machine was removed, recreate it
-          logger.debug(`[AEM] recreating participant machine for reconnect: ${anearParticipant.id}`)
-          const service = AnearParticipantMachine(anearParticipant, context)
+        if (isOpenHouse && !context.participantPrivateChannels[anearParticipant.id]) {
+          // Open house reconnect: participant exists but private channel was removed, recreate it
+          logger.debug(`[AEM] recreating participant private channel for reconnect: ${anearParticipant.id}`)
           const now = Date.now()
           const participantInfo = anearParticipant.participantInfo
 
           return {
-            participantMachines: {
-              ...context.participantMachines,
-              [anearParticipant.id]: service.start()
+            participantPrivateChannels: {
+              ...context.participantPrivateChannels,
+              [anearParticipant.id]: privateChannel
             },
             participants: {
               ...context.participants,
@@ -1595,17 +1515,12 @@ const AnearEventMachineFunctions = ({
         }
       }
 
-      logger.debug("[AEM] starting new participant machine for: ", anearParticipant)
-
-      const service = AnearParticipantMachine(
-        anearParticipant,
-        context
-      )
+      logger.debug('[AEM] registering participant session for: ', anearParticipant)
 
       return {
-        participantMachines: {
-          ...context.participantMachines,
-          [anearParticipant.id]: service.start()
+        participantPrivateChannels: {
+          ...context.participantPrivateChannels,
+          [anearParticipant.id]: privateChannel
         },
         participants: {
           ...context.participants,
@@ -1631,7 +1546,10 @@ const AnearEventMachineFunctions = ({
       )
     },
     sendEnterToAppMachine: ({ context, event }) => {
-      const anearParticipant = event.data?.anearParticipant ?? event.anearParticipant;
+      const anearParticipant =
+        event?.output?.anearParticipant ??
+        event?.data?.anearParticipant ??
+        event?.anearParticipant;
 
       if (!anearParticipant) {
         logger.error('[AEM] sendEnterToAppMachine was called without an anearParticipant in the event', event);
@@ -1654,25 +1572,17 @@ const AnearEventMachineFunctions = ({
       const participantId = event.data.id;
       const participant = context.participants[participantId];
       const eventName = getPresenceEventName(participant, 'DISCONNECT');
-      const participantMachine = context.participantMachines[participantId];
       const participantName = getParticipantName(context, participantId);
 
       logger.info(`[AEM] Event ${context.anearEvent.id} ${eventName} participantId=${participantId} name=${participantName}`);
-      if (participantMachine) {
-        participantMachine.send({ type: 'PARTICIPANT_DISCONNECT' });
-      }
       context.appEventMachine.send({ type: eventName, participantId });
     },
     processReconnectEvents: ({ context, event }) => {
       const participantId = event.data.id;
       const participant = context.participants[participantId];
       const eventName = getPresenceEventName(participant, 'RECONNECT');
-      const participantMachine = context.participantMachines[participantId];
 
       logger.info(`[AEM] Event ${context.anearEvent.id} ${eventName} participantId=${participantId}`);
-      if (participantMachine) {
-        participantMachine.send({ type: 'PARTICIPANT_RECONNECT' });
-      }
       if (context.appEventMachine) {
         // Send participant info (including updated geoLocation) to AppM
         const reconnectEvent = { type: eventName, participantId, participant }
@@ -1763,17 +1673,11 @@ const AnearEventMachineFunctions = ({
       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);
-      }
       if (context.appEventMachine) {
         context.appEventMachine.send(appMPayload);
       }
@@ -1790,72 +1694,98 @@ const AnearEventMachineFunctions = ({
         logger.warn(`[AEM] Participant info not found for id ${participantId} during sendExitToAppMachine`);
       }
     },
-    sendBootEventToParticipantMachine: ({ context, event }) => {
+    sendBootEventToParticipant: ({ context, event }) => {
       const { participantId, reason } = event.data;
-      const participantMachine = context.participantMachines[participantId];
-      if (participantMachine) {
-        participantMachine.send({
-          type: 'BOOT_PARTICIPANT',
-          data: { reason }
-        })
+      const participantChannel = context.participantPrivateChannels[participantId]
+      if (participantChannel) {
+        const payload = {
+          content: {
+            reason: reason || 'You have been removed from the event.'
+          }
+        }
+        EventStats.recordPublish(context.eventStats, participantChannel, 'FORCE_SHUTDOWN', payload)
+        RealtimeMessaging.publish(participantChannel, 'FORCE_SHUTDOWN', payload)
       } else {
-        logger.warn(`[AEM] Participant machine not found for id ${participantId} during sendBootEventToParticipantMachine`);
+        logger.warn(`[AEM] Participant private channel not found for id ${participantId} during BOOT_PARTICIPANT`)
       }
     },
-    sendExitToParticipantMachine: ({ context, event }) => {
-      // coming from an action channel message, event.data.id
-      const participantMachine = context.participantMachines[event.data.id]
-      if (participantMachine) {
-        logger.debug("[AEM] sending PARTICIPANT_EXIT to ", participantMachine.id)
-        participantMachine.send({ type: 'PARTICIPANT_EXIT' })
-      } else {
-        logger.warn(`[AEM] Participant machine not found for id ${event.data.id} during sendExitToParticipantMachine`)
+    handleParticipantExit: assign(({ context, event }) => {
+      const participantId = event?.participantId || event?.data?.id
+      if (!participantId) return {}
+
+      const participant = context.participants[participantId]
+      const {
+        [participantId]: participantChannel,
+        ...remainingChannels
+      } = context.participantPrivateChannels
+
+      // Participant-initiated exits should not be treated as a forced boot.
+      // ABR explicit exit flow already performs local teardown/navigation.
+
+      if (!participant) {
+        return {
+          participantPrivateChannels: remainingChannels,
+          exitedParticipantPrivateChannels: participantChannel
+            ? [...(context.exitedParticipantPrivateChannels || []), participantChannel]
+            : (context.exitedParticipantPrivateChannels || [])
+        }
       }
-    },
-    sendParticipantExitEvents: ({ context }) => {
-      Object.values(context.participantMachines).forEach(pm => pm.send({ type: 'PARTICIPANT_EXIT' }))
-    },
-    cancelAllParticipantTimeouts: assign(({ context }) => {
-      // Send CANCEL_TIMEOUT to all participant machines to cancel any active
-      // participant-level timeouts. This is useful when a game event (e.g., LIAR call)
-      // should immediately cancel all individual participant timeouts.
-      // APMs that are not in waitParticipantResponse state will benignly ignore this event.
-      logger.info(`[AEM] Event ${context.anearEvent.id} cancelling all participant timeouts (manual) for ${Object.keys(context.participantMachines).length} participants`)
-      Object.values(context.participantMachines).forEach(pm => pm.send({ type: 'CANCEL_TIMEOUT' }))
-
-      // Note: If we're in waitAllParticipantsResponse state, the nested state's handler
-      // will also handle this event and cancel the allParticipants timeout.
-
-      // Set suppression flag to ignore stale PARTICIPANT_TIMEOUT events from cancelled timers.
-      // This flag will be cleared when new timers are set up (via render completion).
+
+      const isOpenHouse = context.anearEvent.openHouse || false
+      if (isOpenHouse) {
+        const now = Date.now()
+        return {
+          participants: {
+            ...context.participants,
+            [participantId]: {
+              ...participant,
+              active: false,
+              idleAt: now
+            }
+          },
+          participantPrivateChannels: remainingChannels,
+          exitedParticipantPrivateChannels: participantChannel
+            ? [...(context.exitedParticipantPrivateChannels || []), participantChannel]
+            : (context.exitedParticipantPrivateChannels || [])
+        }
+      }
+
+      const {
+        [participantId]: _removedParticipant,
+        ...remainingParticipants
+      } = context.participants
+
       return {
-        suppressParticipantTimeouts: true
+        participants: remainingParticipants,
+        participantPrivateChannels: remainingChannels,
+        exitedParticipantPrivateChannels: participantChannel
+          ? [...(context.exitedParticipantPrivateChannels || []), participantChannel]
+          : (context.exitedParticipantPrivateChannels || [])
       }
     }),
-    sendCancelTimeoutToAllAPMs: ({ context }) => {
-      const participantCount = Object.keys(context.participantMachines).length
-      const actionName = context.eachParticipantCancelActionType || 'unknown'
-      logger.info(`[AEM] Event ${context.anearEvent.id} sending CANCEL_TIMEOUT to all ${participantCount} APMs for ACTION ${actionName}`)
-      Object.values(context.participantMachines).forEach(pm => {
-        pm.send({ type: 'CANCEL_TIMEOUT' })
-      })
-    },
+    sendParticipantExitEvents: assign(({ context }) => {
+      // Normal event shutdown (close/cancel/suspend) should not look like a boot.
+      // Keep last rendered display visible; clients will observe EVENT_TRANSITION and channel detach.
+      return {
+        participants: {},
+        // Preserve private channel references so detachChannels can detach them during shutdown.
+        participantPrivateChannels: context.participantPrivateChannels
+      }
+    }),
+    cancelAllParticipantTimeouts: assign(() => ({
+      participantsActionTimeout: null,
+      pendingCancelAction: null
+    })),
+    sendCancelTimeoutToAllAPMs: () => {},
     setupPendingCancelConfirmations: assign(({ context, event }) => {
-      // Get all active participants with timers (participants in waitParticipantResponse state)
-      const activeParticipantIds = getActiveParticipantIds(context)
-      const pendingConfirmations = new Set(activeParticipantIds)
-
       const participantName = getParticipantName(context, event.data.participantId)
-      logger.info(`[AEM] Event ${context.anearEvent.id} starting cancellation sequence for ACTION ${event.data.appEventName} from participantId=${event.data.participantId} name=${participantName}, waiting for ${pendingConfirmations.size} confirmations`)
-
+      logger.info(`[AEM] Event ${context.anearEvent.id} cancellation requested by participantId=${event.data.participantId} name=${participantName}`)
       return {
-        pendingCancelConfirmations: pendingConfirmations,
         pendingCancelAction: {
           participantId: event.data.participantId,
           appEventName: event.data.appEventName,
           payload: event.data.payload
-        },
-        suppressParticipantTimeouts: true  // Drop PARTICIPANT_TIMEOUT events
+        }
       }
     }),
     setupPendingCancelConfirmationsForManualCancel: assign(({ context }) => {
@@ -1865,25 +1795,10 @@ const AnearEventMachineFunctions = ({
 
       logger.info(`[AEM] Event ${context.anearEvent.id} starting manual cancellation sequence, waiting for ${pendingConfirmations.size} confirmations`)
 
-      return {
-        pendingCancelConfirmations: pendingConfirmations,
-        pendingCancelAction: null, // No ACTION to forward for manual cancel
-        suppressParticipantTimeouts: true  // Drop PARTICIPANT_TIMEOUT events
-      }
+      return { pendingCancelAction: null }
     }),
     removeFromPendingCancelConfirmations: assign(({ context, event }) => {
-      const participantId = event.participantId || event.data?.id
-      if (!context.pendingCancelConfirmations || !participantId) return {}
-
-      const newPending = new Set(context.pendingCancelConfirmations)
-      newPending.delete(participantId)
-      const remaining = newPending.size
-
-      logger.debug(`[AEM] TIMER_CANCELED received from ${participantId}. ${remaining} confirmations remaining.`)
-
-      return {
-        pendingCancelConfirmations: newPending
-      }
+      return {}
     }),
     forwardPendingCancelAction: ({ context }) => {
       if (!context.pendingCancelAction) {
@@ -1904,27 +1819,15 @@ const AnearEventMachineFunctions = ({
       // Forward to AppM
       context.appEventMachine.send({ type: appEventName, ...actionEventPayload })
 
-      // Forward to APM
-      const participantMachine = context.participantMachines[participantId]
-      if (participantMachine) {
-        participantMachine.send({ type: 'ACTION', ...actionEventPayload })
-      } else {
-        logger.warn(`[AEM] Participant machine not found for ${participantId} when forwarding cancel ACTION`)
-      }
     },
     clearCancelState: assign({
-      pendingCancelConfirmations: null,
-      pendingCancelAction: null,
-      suppressParticipantTimeouts: false
+      pendingCancelAction: null
     }),
     dropEventDuringCancellation: ({ context, event }) => {
-      // Drop/ignore ACTION and PARTICIPANT_TIMEOUT events received during cancellation wait
-      // All other events (presence events, etc.) are not handled here and will bubble up to parent handlers
+      // Drop/ignore events received during cancellation wait.
       logger.debug(`[AEM] Dropping ${event.type} event during cancellation wait`)
     },
-    clearParticipantTimeoutSuppression: assign({
-      suppressParticipantTimeouts: false
-    }),
+    clearParticipantTimeoutSuppression: assign({}),
     setupCancelActionType: assign(({ context, event }) => {
       const cancelActionType =
         (event && event.output && event.output.cancelActionType) ||
@@ -1942,21 +1845,12 @@ const AnearEventMachineFunctions = ({
     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;
       }
 
-      // 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({ type: 'PARTICIPANT_UPDATE', data: event.data });
-      }
-
       // AppM gets the role-specific event
       const eventName = getPresenceEventName(participant, 'UPDATE');
       context.appEventMachine.send({ type: eventName, data: event.data });
@@ -1975,7 +1869,7 @@ const AnearEventMachineFunctions = ({
       }
       return updates
     }),
-    processParticipantAction: ({ context, event, self }) => {
+    processParticipantAction: ({ context, event }) => {
       // event.data.participantId,
       // event.data.payload: {"appEventMachineACTION": {action event keys and values}}
       //   e.g.  {"MOVE":{"x":1, "y":2}}
@@ -1988,32 +1882,11 @@ const AnearEventMachineFunctions = ({
       logger.info(`[AEM] Event ${context.anearEvent.id} ACTION participantId=${participantId} name=${participantName} action=${appEventName}`)
       logger.debug(`[AEM] eachParticipantCancelActionType is: ${context.eachParticipantCancelActionType}`)
 
-      // Check if this ACTION should trigger cancellation for eachParticipant timeout
-      if (context.eachParticipantCancelActionType === appEventName) {
-        logger.info(`[AEM] Event ${context.anearEvent.id} intercepting cancel ACTION ${appEventName} from participantId=${participantId} name=${participantName} (eachParticipant timeout)`)
-        // Trigger cancellation sequence via self-send
-        self.send({
-          type: 'TRIGGER_CANCEL_SEQUENCE',
-          data: {
-            participantId,
-            appEventName,
-            payload,
-            event  // Store original event for reference
-          }
-        })
-        return  // Don't forward yet, wait for cancellation to complete
-      }
-
-      // Normal flow: forward immediately
       const actionEventPayload = {
         participantId,
         payload
       }
 
-      const participantMachine = context.participantMachines[participantId]
-
-      participantMachine.send({ type: 'ACTION', ...actionEventPayload })
-
       context.appEventMachine.send({ type: appEventName, ...actionEventPayload })
     },
     processAndForwardAction: ({ context, event }) => {
@@ -2041,12 +1914,7 @@ const AnearEventMachineFunctions = ({
       };
       context.appEventMachine.send({ type: appEventName, ...appM_Payload });
 
-      // Forward to APM (without the flag)
-      const participantMachine = context.participantMachines[participantId];
-      if (participantMachine) {
-        const apm_Payload = { participantId, payload };
-        participantMachine.send({ type: 'ACTION', ...apm_Payload });
-      }
+      // AEM no longer forwards ACTION to participant child machines.
     },
     storeCancelActionForAllParticipants: assign(({ context, event }) => {
       const participantId = event.data.participantId
@@ -2075,31 +1943,7 @@ const AnearEventMachineFunctions = ({
         consecutiveTimeoutCount: newCount
       }
     }),
-    processParticipantTimeout: ({ context, event, self }) => {
-      const participantId = event.participantId || event.data?.participantId
-      // 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).
-      if (context.suppressParticipantTimeouts) {
-        logger.debug(`[AEM] Suppressing PARTICIPANT_TIMEOUT from ${participantId} (cancelled timers, waiting for new render)`)
-        return
-      }
-
-      const participantName = getParticipantName(context, participantId)
-      logger.info(`[AEM] Event ${context.anearEvent.id} PARTICIPANT_TIMEOUT participantId=${participantId} name=${participantName}`)
-      const timeoutCount = context.consecutiveTimeoutCount || 0
-      const maxConsecutiveTimeouts = C.DEAD_MAN_SWITCH.MAX_CONSECUTIVE_PARTICIPANT_TIMEOUTS
-
-      // Check dead-man switch: if global consecutive timeout threshold reached, cancel event
-      // This detects when the game is "dead" (no actions happening) across all participants
-      if (timeoutCount >= maxConsecutiveTimeouts) {
-        logger.warn(`[AEM] Dead-man switch triggered: ${timeoutCount} consecutive timeouts across all participants (threshold: ${maxConsecutiveTimeouts}). Auto-canceling event.`)
-        self.send({ type: 'CANCEL' })
-        return
-      }
-
-      context.appEventMachine.send({ type: 'PARTICIPANT_TIMEOUT', participantId })
-    },
+    processParticipantTimeout: () => {},
     setupParticipantsTimeout: assign(({ context, event }) => {
       // Only set up a new timeout if one is provided by the display render workflow
       // AND we don't already have an active timeout (i.e., we're entering from waitingForActions,
@@ -2251,12 +2095,6 @@ const AnearEventMachineFunctions = ({
       // Forward to AppM
       context.appEventMachine.send({ type: appEventName, ...actionEventPayload })
 
-      // Forward to APM
-      const participantMachine = context.participantMachines[participantId]
-      if (participantMachine) {
-        participantMachine.send({ type: 'ACTION', ...actionEventPayload })
-      }
-
       const participantName = getParticipantName(context, participantId)
       logger.info(`[AEM] Event ${context.anearEvent.id} forwarded cancel ACTION ${appEventName} from participantId=${participantId} name=${participantName} after allParticipants cancellation`)
 
@@ -2267,54 +2105,41 @@ const AnearEventMachineFunctions = ({
       participantsActionTimeout: null
     }),
     cleanupExitingParticipant: assign(({ context, event }) => {
-      const { participantId } = event
+      const participantId = event?.participantId || event?.data?.id
+      if (!participantId) return {}
       const participant = context.participants[participantId]
+      const {
+        [participantId]: _removedChannel,
+        ...remainingChannels
+      } = context.participantPrivateChannels
 
-      logger.debug(`[AEM] cleaning up exiting participant ${participantId}`)
-
-      if (participant) {
-        const isOpenHouse = context.anearEvent.openHouse || false
-
-        if (isOpenHouse) {
-          // For open house events: preserve participant with active: false, only remove machine
-          const {
-            [participantId]: removedMachine,
-            ...remainingMachines
-          } = context.participantMachines
-
-          const now = Date.now()
-          const updatedParticipant = {
-            ...participant,
-            active: false,
-            idleAt: now
-          }
-
-          return {
-            participants: {
-              ...context.participants,
-              [participantId]: updatedParticipant
-            },
-            participantMachines: remainingMachines
-          }
-        } else {
-          // For non-open-house events: remove both participant and machine (existing behavior)
-          const {
-            [participantId]: removedParticipant,
-            ...remainingParticipants
-          } = context.participants
-
-          const {
-            [participantId]: removedMachine,
-            ...remainingMachines
-          } = context.participantMachines
+      if (!participant) {
+        return { participantPrivateChannels: remainingChannels }
+      }
 
-          return {
-            participants: remainingParticipants,
-            participantMachines: remainingMachines
-          }
+      const isOpenHouse = context.anearEvent.openHouse || false
+      if (isOpenHouse) {
+        const now = Date.now()
+        return {
+          participants: {
+            ...context.participants,
+            [participantId]: {
+              ...participant,
+              active: false,
+              idleAt: now
+            }
+          },
+          participantPrivateChannels: remainingChannels
         }
-      } else {
-        return {}
+      }
+
+      const {
+        [participantId]: _removedParticipant,
+        ...remainingParticipants
+      } = context.participants
+      return {
+        participants: remainingParticipants,
+        participantPrivateChannels: remainingChannels
       }
     }),
     notifyCoreServiceMachineExit: ({ context }) => {
@@ -2322,7 +2147,8 @@ const AnearEventMachineFunctions = ({
       context.coreServiceMachine.send({ type: 'EVENT_MACHINE_EXIT', eventId: context.anearEvent.id })
     },
     logCreatorEnter: ({ event }) => logger.debug("[AEM] got creator PARTICIPANT_ENTER: ", event.data.id),
-    logAPMReady: ({ event }) => logger.debug("[AEM] PARTICIPANT_MACHINE_READY for: ", event.data.anearParticipant.id),
+    logWaitingForCreatorPresence: ({ context }) => logger.debug(`[AEM] Event ${context.anearEvent.id} creator/host not found via actions presence.get(); waiting for PARTICIPANT_ENTER`),
+    logAPMReady: () => logger.debug('[AEM] participant session registered'),
     logInvalidParticipantEnter: ({ context, event }) => logger.info(`[AEM] Event ${context.anearEvent.id} unexpected PARTICIPANT_ENTER participantId=${event.data.id}`),
     logDeferringAppmFinal: ({ context }) => logger.info(`[AEM] Event ${context.anearEvent.id} deferring APPM_FINAL (already transitioning to terminated)`),
     logImplicitShutdownWarning: (_c, _e) => {
@@ -2599,7 +2425,25 @@ const AnearEventMachineFunctions = ({
         context.participantsDisplayChannel,
       ]
       if (context.spectatorsDisplayChannel) channels.push(context.spectatorsDisplayChannel)
-      await RealtimeMessaging.detachAll(channels)
+      Object.values(context.participantPrivateChannels || {}).forEach(ch => {
+        if (ch) channels.push(ch)
+      })
+      Object.values(context.exitedParticipantPrivateChannels || {}).forEach(ch => {
+        if (ch) channels.push(ch)
+      })
+
+      const uniqueChannels = Array.from(new Set(channels.filter(Boolean)))
+      const attachedChannels = uniqueChannels.filter((ch) => ch?.state === 'attached')
+      const nonAttachedChannels = uniqueChannels.filter((ch) => ch?.state !== 'attached')
+
+      logger.debug(
+        `[AEM] detachChannels total=${uniqueChannels.length} attached=${attachedChannels.length} skipped=${nonAttachedChannels.length}`
+      )
+      nonAttachedChannels.forEach((ch) => {
+        logger.debug(`[AEM] detachChannels skipping channel ${ch.name} state=${(ch?.state || 'unknown').toUpperCase()}`)
+      })
+
+      await RealtimeMessaging.detachAll(attachedChannels)
       return 'done'
     }),
     fetchParticipantData: fromPromise(async ({ input }) => {
@@ -2694,6 +2538,10 @@ const AnearEventMachineFunctions = ({
     })
   },
   guards: {
+    hasAttachedCreatorOrHost: ({ event }) => {
+      const anearParticipant = event?.output?.anearParticipant ?? event?.data?.anearParticipant
+      return !!anearParticipant
+    },
     isReconnectUpdate: ({ context, event }) => {
       // participant exists and event.data.type is undefined
       return context.participants[event.data.id] && !event.data.type
@@ -2719,9 +2567,9 @@ const AnearEventMachineFunctions = ({
       const participantId = event.data.id
       const isOpenHouse = context.anearEvent.openHouse || false
       const participantExists = !!context.participants[participantId]
-      const machineExists = !!context.participantMachines[participantId]
-      // For open house events: participant exists but machine was removed (idle state)
-      return isOpenHouse && participantExists && !machineExists
+      const channelExists = !!context.participantPrivateChannels[participantId]
+      // For open house events: participant exists but private channel was removed (idle state)
+      return isOpenHouse && participantExists && !channelExists
     },
     eventCreatorIsHost: ({ context }) => context.anearEvent.hosted,
     isOpenHouseEvent: ({ context }) => context.anearEvent.openHouse || false,
@@ -2747,9 +2595,7 @@ const AnearEventMachineFunctions = ({
     allParticipantsResponded: ({ context }) => {
       return context.participantsActionTimeout && context.participantsActionTimeout.nonResponders.size === 0
     },
-    allCancelConfirmationsReceived: ({ context }) => {
-      return !context.pendingCancelConfirmations || context.pendingCancelConfirmations.size === 0
-    }
+    allCancelConfirmationsReceived: () => true
   },
   delays: {
     // in the future, these delays should be goverened by the type of App and
@@ -2767,7 +2613,6 @@ const AnearEventMachine = (anearEvent, {
   coreServiceMachine,
   pugTemplates,
   appEventMachineFactory,
-  appParticipantMachineFactory,
   imageAssetsUrl,
   rehydrate = false
 }) => {
@@ -2787,7 +2632,6 @@ const AnearEventMachine = (anearEvent, {
     pugTemplates,
     pugHelpers,
     appEventMachineFactory,
-    appParticipantMachineFactory,
     rehydrate
   )