fix(plopsa): trust wait-times feed over stale temporarily_closed hint

Diagnostic logs show a subset of rides (8 at a time) flapping
OPERATING ↔ CLOSED every ~3 minutes — independent of `parkOpenNow`,
which stays steady. Pattern is per-ride, lockstep across the same set
of rides each cycle.

Cause: the per-ride `closedById` map (built from POI's
`temporarily_closed` flag) is the deciding bit when it disagrees with
the live wait-times feed. POI is HTTP-cached for 12 hours, and on a
multi-instance deployment two collectors that fetched POI at slightly
different moments end up with different cached snapshots — one says
"ride X is temp-closed", the other says "open" — and they alternate
writes on every poll cycle.

The wait-times feed is the ground truth for "is this ride currently
taking guests": if it gives us a numeric value, the ride is operating
regardless of what POI's cached `temporarily_closed` hint says. The
hint is only authoritative when the wait-times feed has no number for
the ride.

Decision logic extracted into a pure `plopsaDecideOperating(parkOpenNow,
tempClosed, hasWait)` helper. Unit-tested matrix in
`__tests__/plopsa.test.ts` covers all 8 input combinations and pins the
specific pre-fix bug case (open + temp-closed + has-wait → was CLOSED,
now OPERATING).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: cubehouse

src/parks/plopsa/__tests__/plopsa.test.ts

@@ -0,0 +1,38 @@
+/**
+ * Plopsa decision-logic regression tests.
+ *
+ * The full decision matrix for whether a ride emits OPERATING vs CLOSED.
+ * The interesting case is row 3: a numeric wait time + a stale
+ * `temporarily_closed: true` from POI must NOT downgrade to CLOSED, or
+ * multi-collector deployments will flap any ride whose POI snapshot
+ * disagrees between instances.
+ */
+import {describe, test, expect} from 'vitest';
+import {plopsaDecideOperating} from '../plopsa.js';
+
+describe('plopsaDecideOperating', () => {
+  test('park closed → ride always CLOSED regardless of other inputs', () => {
+    expect(plopsaDecideOperating(false, false, false)).toBe(false);
+    expect(plopsaDecideOperating(false, false, true)).toBe(false);
+    expect(plopsaDecideOperating(false, true,  false)).toBe(false);
+    expect(plopsaDecideOperating(false, true,  true)).toBe(false);
+  });
+
+  test('park open + ride open + has wait → OPERATING', () => {
+    expect(plopsaDecideOperating(true, false, true)).toBe(true);
+  });
+
+  test('park open + ride open + no wait → OPERATING (e.g. brand-new ride before first reading)', () => {
+    expect(plopsaDecideOperating(true, false, false)).toBe(true);
+  });
+
+  test('park open + POI says temp-closed + has wait → OPERATING (wait-times feed wins over stale POI hint)', () => {
+    // This is the case the bug report depends on: stale POI says closed,
+    // but the wait-times feed has a real number. Trust the live number.
+    expect(plopsaDecideOperating(true, true, true)).toBe(true);
+  });
+
+  test('park open + POI says temp-closed + no wait → CLOSED (the hint is authoritative when no live signal)', () => {
+    expect(plopsaDecideOperating(true, true, false)).toBe(false);
+  });
+});

src/parks/plopsa/plopsa.ts

@@ -97,6 +97,27 @@ function formatTodayInTimezone(tz: string): string {
   return `${yyyy}-${mm}-${dd}`;
 }
 
+/**
+ * Decide whether a Plopsa ride should emit as OPERATING right now.
+ *
+ * Inputs are intentionally flat booleans + a primitive — pure function so
+ * the matrix is easy to unit-test (see `__tests__/plopsa.test.ts`).
+ *
+ * The wait-times feed is treated as the ground truth: a numeric wait
+ * means the ride is taking guests right now. POI's `temporarily_closed`
+ * is a hint we use only when the wait-times feed has no number for the
+ * ride. Without that priority, a stale 12h-cached POI snapshot on one
+ * collector instance disagreeing with another instance's cached snapshot
+ * causes lockstep OPERATING ↔ CLOSED flapping for the affected rides.
+ */
+export function plopsaDecideOperating(
+  parkOpenNow: boolean,
+  tempClosed: boolean,
+  hasWait: boolean,
+): boolean {
+  return parkOpenNow && (hasWait || !tempClosed);
+}
+
 /** Is the park currently within an "open" timeslot from today's hours? */
 function isParkOpenNow(hours: PlopsaTodayHours | null, tz: string): boolean {
   if (!hours?.timeslots?.length) return false;
@@ -432,7 +453,9 @@ class PlopsaBase extends Destination {
     const lastUpdated = new Date().toISOString();
     return Object.entries(waitTimes).map(([attractionId, waitTime]) => {
       const id = String(attractionId);
-      const operating = parkOpenNow && closedById.get(id) !== true;
+      const tempClosed = closedById.get(id) === true;
+      const hasWait = typeof waitTime === 'number';
+      const operating = plopsaDecideOperating(parkOpenNow, tempClosed, hasWait);
 
       if (!operating) {
         return {id, status: 'CLOSED', lastUpdated} as unknown as LiveData;
@@ -441,7 +464,7 @@ class PlopsaBase extends Destination {
         id,
         status: 'OPERATING',
         queue: {
-          STANDBY: {waitTime: typeof waitTime === 'number' ? waitTime : null},
+          STANDBY: {waitTime: hasWait ? waitTime : null},
         },
         lastUpdated,
       } as unknown as LiveData;