anear-js-api 0.5.9 → 0.6.1

package/lib/models/AnearEvent.js

@@ -154,7 +154,11 @@ class AnearEvent extends JsonApiResource {
   }
 
   allowsSpectators() {
-    return !this.hasFlag("no_spectators")
+    //
+    // Canonical spectators decision uses the ANAPI-provided boolean when present.
+    // Fallback to legacy negative flag for older payloads.
+    //
+    return this.attributes['spectators-allowed']
   }
 
   isParticipantEventCreator(participant) {

package/lib/state_machines/AnearParticipantMachine.js

@@ -209,6 +209,16 @@ const AnearParticipantMachineConfig = participantId => ({
                 ]
               },
               on: {
+                // Even while we're waiting for a reconnect, the AppM may
+                // re-trigger a display (e.g. a refreshed PlayableGameBoard).
+                // In that case, re-publish the view but keep the timeout
+                // semantics governed by the stored remaining time.
+                RENDER_DISPLAY: {
+                  target: '#renderDisplay'
+                },
+                PRIVATE_DISPLAY: {
+                  target: '#renderDisplay'
+                },
                 PARTICIPANT_EXIT: {
                   target: '#cleanupAndExit'
                 },
@@ -258,6 +268,16 @@ const AnearParticipantMachineConfig = participantId => ({
                 }
               },
               on: {
+                RENDER_DISPLAY: {
+                  // Re-render the current prompt for this participant (e.g. after reconnect)
+                  // without resetting the original timeout start. The updateActionTimeout
+                  // action will recompute the remaining time based on the original
+                  // actionTimeoutStart so the participant does not get extra time.
+                  target: '#renderDisplay'
+                },
+                PRIVATE_DISPLAY: {
+                  target: '#renderDisplay'
+                },
                 PARTICIPANT_EXIT: {
                   actions: 'logExit',
                   target: '#cleanupAndExit'
@@ -404,22 +424,33 @@ const AnearParticipantMachineFunctions = {
       lastSeen: context => CurrentDateTimestamp()
     }),
     updateActionTimeout: assign((context, event) => {
-      const newTimeoutDuration = event.data.timeout
+      const timeoutFromEvent = event.data.timeout
+      const now = CurrentDateTimestamp()
 
+      // If we already have a running timer (e.g. after a disconnect/reconnect
+      // cycle or a re-render), treat actionTimeoutMsecs as the remaining
+      // duration for this leg and subtract only the time since the last
+      // (re)start. This avoids double-subtracting elapsed time across
+      // multiple renders.
       if (context.actionTimeoutStart) {
-        const elapsed = CurrentDateTimestamp() - context.actionTimeoutStart
-        const remaining = newTimeoutDuration - elapsed
-        logger.debug(`[APM] Resuming timer for ${context.anearParticipant.id} with ${remaining}ms remaining`)
-        return {
-          actionTimeoutMsecs: remaining > 0 ? remaining : 0
-        }
-      } else {
-        logger.debug(`[APM] Starting new timer for ${context.anearParticipant.id} with ${newTimeoutDuration}ms`)
+        const elapsed = now - context.actionTimeoutStart
+        const base = context.actionTimeoutMsecs != null ? context.actionTimeoutMsecs : timeoutFromEvent
+        const remaining = base - elapsed
+        const remainingMsecs = remaining > 0 ? remaining : 0
+
+        logger.debug(`[APM] Resuming timer for ${context.anearParticipant.id} with ${remainingMsecs}ms remaining`)
         return {
-          actionTimeoutMsecs: newTimeoutDuration,
-          actionTimeoutStart: CurrentDateTimestamp()
+          actionTimeoutMsecs: remainingMsecs,
+          actionTimeoutStart: now
         }
       }
+
+      // First time this participant sees this prompt: start a fresh timer.
+      logger.debug(`[APM] Starting new timer for ${context.anearParticipant.id} with ${timeoutFromEvent}ms`)
+      return {
+        actionTimeoutMsecs: timeoutFromEvent,
+        actionTimeoutStart: now
+      }
     }),
     nullActionTimeout: assign({
       actionTimeoutMsecs: _c => null,
@@ -427,12 +458,16 @@ const AnearParticipantMachineFunctions = {
     }),
     updateRemainingTimeoutOnDisconnect: assign((context, event) => {
       if (context.actionTimeoutStart) {
-        const elapsed = CurrentDateTimestamp() - context.actionTimeoutStart
+        const now = CurrentDateTimestamp()
+        const elapsed = now - context.actionTimeoutStart
         const remaining = context.actionTimeoutMsecs - elapsed
         const remainingMsecs = remaining > 0 ? remaining : 0
         logger.debug(`[APM] Participant disconnected mid-turn. Storing remaining timeout of ${remainingMsecs}ms`)
         return {
-          actionTimeoutMsecs: remainingMsecs
+          actionTimeoutMsecs: remainingMsecs,
+          // Reset the start baseline to "now" so that subsequent resumptions
+          // measure elapsed time from the disconnect point forward.
+          actionTimeoutStart: now
         }
       }
       return {}

package/lib/utils/DisplayEventProcessor.js

@@ -336,18 +336,75 @@ class DisplayEventProcessor {
     let timeout = null
 
     const participantStruct = this.participantsIndex.get(participantId)
+    const appCtx = templateRenderContext.app || {}
+
+    // Determine which participant (if any) is currently timed according to
+    // the AppM context (e.g., Tic-Tac-Toe currentPlayerToken).
+    const currentToken = appCtx.currentPlayerToken
+    const currentPlayerId = currentToken && appCtx.playerIds ? appCtx.playerIds[currentToken] : null
+    const isCurrentPlayer = currentPlayerId && participantId === currentPlayerId
 
     if (timeoutFn) {
-      timeout = timeoutFn(templateRenderContext.app, participantStruct)
+      // Only the current player should receive a real timeout value that
+      // starts an APM timer. For other participants we keep `timeout` null
+      // so their APMs never start per-participant timers.
+      if (isCurrentPlayer) {
+        timeout = timeoutFn(appCtx, participantStruct)
+      }
     }
     const privateRenderContext = {
       ...templateRenderContext,
       participant: participantStruct
     }
 
-    if (timeout !== null) {
-      // APM will compute remaining on its own; start remaining at full msecs here
-      privateRenderContext.timeout = { msecs: timeout, remainingMsecs: timeout }
+    // Build visual timeout (meta.timeout) used by the countdown bar.
+    // For the current player, derive from their own APM state.
+    // For opponents / other participants, mirror the current player's timer
+    // so everyone sees the same countdown without starting extra APM timers.
+    let visualTimeout = null
+    try {
+      // Helper to compute remaining from a given participant machine
+      const computeRemainingFromMachine = (pm) => {
+        const state = pm?.state
+        const ctx = state?.context
+        if (!ctx || !ctx.actionTimeoutStart || ctx.actionTimeoutMsecs == null) return null
+        const now = Date.now()
+        const elapsed = now - ctx.actionTimeoutStart
+        const base = ctx.actionTimeoutMsecs
+        const remaining = base - elapsed
+        return remaining > 0 ? remaining : 0
+      }
+
+      if (isCurrentPlayer) {
+        if (timeout !== null) {
+          const remainingMsecs = computeRemainingFromMachine(participantMachine) ?? timeout
+          visualTimeout = { msecs: timeout, remainingMsecs }
+        }
+      } else if (currentPlayerId) {
+        // Mirror the current player's timer for non-current participants.
+        const currentPm = this.participantMachines[currentPlayerId]
+        const remainingMsecs = computeRemainingFromMachine(currentPm)
+
+        if (remainingMsecs != null) {
+          // Prefer the app-configured move timeout if available; otherwise
+          // fall back to the remaining time as the total for visuals.
+          const moveTimeout =
+            (appCtx.C && typeof appCtx.C.MOVE_TIMEOUT_MSECS === 'number' && appCtx.C.MOVE_TIMEOUT_MSECS > 0)
+              ? appCtx.C.MOVE_TIMEOUT_MSECS
+              : remainingMsecs
+          visualTimeout = { msecs: moveTimeout, remainingMsecs }
+        }
+      }
+    } catch (_e) {
+      // If anything goes wrong computing visualTimeout, we simply omit it and
+      // let the templates fall back to their default behavior.
+    }
+
+    if (visualTimeout) {
+      privateRenderContext.meta = {
+        ...(privateRenderContext.meta || {}),
+        timeout: visualTimeout
+      }
     }
 
     const privateHtml = template(privateRenderContext)

package/package.json

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