@omnitronix/bonnys-fortune-game-engine 1.7.2 → 1.8.0

package/src/__tests__/error-paths.test.ts

@@ -16,7 +16,14 @@ import {
   nextCommandId,
   resetCommandIdCounter,
   waitForEngineReady,
+  getOutcome,
 } from './helpers/test-engine-factory';
+import {
+  BonnysFortunePublicState,
+  BonnysFortunePrivateState,
+  SpinResultResponse,
+  BonnysFortuneBaseGameSpinResult,
+} from '../logic/bonnys-fortune.types';
 
 describe('Error Paths — Bonnys Fortune', () => {
   beforeEach(() => {
@@ -28,7 +35,7 @@ describe('Error Paths — Bonnys Fortune', () => {
       const engine = createEngine();
       await waitForEngineReady(engine);
 
-      const result = await engine.processCommand(null as any, null as any, {
+      const result = await engine.processCommand(null as unknown as BonnysFortunePublicState, null as unknown as BonnysFortunePrivateState, {
         id: nextCommandId('init'),
         type: 'INIT_SESSION_STATE',
         payload: { betAmountThresholds: [1.0], defaultBetAmount: 1.0 },
@@ -42,7 +49,7 @@ describe('Error Paths — Bonnys Fortune', () => {
       const session = await initSession(engine);
 
       try {
-        await executeSpin(engine, null, session.privateState);
+        await executeSpin(engine, null as unknown as BonnysFortunePublicState, session.privateState);
       } catch (error) {
         expect(error).toBeDefined();
       }
@@ -53,7 +60,7 @@ describe('Error Paths — Bonnys Fortune', () => {
       const session = await initSession(engine);
 
       try {
-        await executeSpin(engine, session.publicState, null);
+        await executeSpin(engine, session.publicState, null as unknown as BonnysFortunePrivateState);
       } catch (error) {
         expect(error).toBeDefined();
       }
@@ -64,7 +71,7 @@ describe('Error Paths — Bonnys Fortune', () => {
       const session = await initSession(engine);
 
       try {
-        await executeSpin(engine, undefined, undefined);
+        await executeSpin(engine, undefined as unknown as BonnysFortunePublicState, undefined as unknown as BonnysFortunePrivateState);
       } catch (error) {
         expect(error).toBeDefined();
       }
@@ -135,7 +142,8 @@ describe('Error Paths — Bonnys Fortune', () => {
           },
         );
         if (result.success && result.outcome) {
-          expect((result.outcome as any).playerWinning).toBeGreaterThanOrEqual(0);
+          const outcome = result.outcome as unknown as { result?: { playerWinning: number }; playerWinning?: number };
+          expect(outcome.result?.playerWinning ?? outcome.playerWinning ?? 0).toBeGreaterThanOrEqual(0);
         }
       } catch (error) {
         expect(error).toBeDefined();
@@ -204,7 +212,7 @@ describe('Error Paths — Bonnys Fortune', () => {
             type: 'SPIN',
             payload: {
               sessionId: 'test',
-              betAmount: '1.0' as any,
+              betAmount: '1.0' as unknown as number,
               gameCode: 'bonnys-fortune',
               gameVersion: '1.0.0',
             },
@@ -241,7 +249,7 @@ describe('Error Paths — Bonnys Fortune', () => {
       await waitForEngineReady(engine);
 
       try {
-        const result = await engine.processCommand(null as any, null as any, {
+        const result = await engine.processCommand(null as unknown as BonnysFortunePublicState, null as unknown as BonnysFortunePrivateState, {
           id: nextCommandId('init'),
           type: 'INIT_SESSION_STATE',
           payload: { betAmountThresholds: [], defaultBetAmount: 1.0 },
@@ -361,11 +369,11 @@ describe('Error Paths — Bonnys Fortune', () => {
       const engine = createEngine();
       const session = await initSession(engine);
 
-      const corruptedPriv = { ...session.privateState };
+      const corruptedPriv = { ...session.privateState } as Partial<BonnysFortunePrivateState> & Omit<BonnysFortunePrivateState, 'nextSpinType'>;
       delete corruptedPriv.nextSpinType;
 
       try {
-        const result = await executeSpin(engine, session.publicState, corruptedPriv);
+        const result = await executeSpin(engine, session.publicState, corruptedPriv as unknown as BonnysFortunePrivateState);
         expect(result).toBeDefined();
       } catch (error) {
         expect(error).toBeDefined();
@@ -378,11 +386,11 @@ describe('Error Paths — Bonnys Fortune', () => {
 
       const corruptedPriv = {
         ...session.privateState,
-        bonusMetersByAmount: null as any,
+        bonusMetersByAmount: null as unknown as BonnysFortunePrivateState['bonusMetersByAmount'],
       };
 
       try {
-        const result = await executeSpin(engine, session.publicState, corruptedPriv);
+        const result = await executeSpin(engine, session.publicState, corruptedPriv as unknown as BonnysFortunePrivateState);
         expect(result).toBeDefined();
       } catch (error) {
         expect(error).toBeDefined();
@@ -395,7 +403,7 @@ describe('Error Paths — Bonnys Fortune', () => {
 
       const corruptedPub = {
         ...session.publicState,
-        bonusMeters: null as any,
+        bonusMeters: null as unknown as BonnysFortunePublicState['bonusMeters'],
       };
 
       try {
@@ -421,8 +429,9 @@ describe('Error Paths — Bonnys Fortune', () => {
         const result = await executeSpin(engine, pub, priv);
         expect(result.success).toBe(true);
 
-        if (result.outcome?.playerWinning !== undefined) {
-          expect(result.outcome.playerWinning).toBeGreaterThanOrEqual(0);
+        const o = getOutcome(result);
+        if (o.playerWinning !== undefined) {
+          expect(o.playerWinning).toBeGreaterThanOrEqual(0);
         }
 
         pub = result.publicState;
@@ -437,8 +446,9 @@ describe('Error Paths — Bonnys Fortune', () => {
       const result = await executeSpin(engine, session.publicState, session.privateState);
       expect(result.success).toBe(true);
 
-      if (result.outcome?.playerWinning !== undefined) {
-        expect(typeof result.outcome.playerWinning).toBe('number');
+      const o1 = getOutcome(result);
+      if (o1.playerWinning !== undefined) {
+        expect(typeof o1.playerWinning).toBe('number');
       }
     });
 
@@ -449,8 +459,9 @@ describe('Error Paths — Bonnys Fortune', () => {
       const result = await executeSpin(engine, session.publicState, session.privateState);
       expect(result.success).toBe(true);
 
-      if (result.outcome?.playerWinning !== undefined) {
-        expect(Number.isFinite(result.outcome.playerWinning)).toBe(true);
+      const o2 = getOutcome(result);
+      if (o2.playerWinning !== undefined) {
+        expect(Number.isFinite(o2.playerWinning)).toBe(true);
       }
     });
   });

package/src/__tests__/helpers/test-engine-factory.ts

@@ -8,6 +8,19 @@
  *   through our mock — no need to rebuild gameLogic or handlers.
  */
 import { BonnysFortuneV1GameEngine } from '../../bonnys-fortune-v1.game-engine';
+import {
+  BonnysFortunePublicState,
+  BonnysFortunePrivateState,
+  BonnysFortuneOutcome,
+  SpinResultResponse,
+  SpinResult,
+  BonusRoundResult,
+} from '../../logic/bonnys-fortune.types';
+import {
+  CommandProcessingResult,
+  RngOutcome,
+} from '../../game-engine.interface';
+import { IRngClient } from '../../rng/rng-client.interface';
 import {
   MockRngClient,
   LcgRngClient,
@@ -67,6 +80,70 @@ export {
   AssertionBounds,
 } from '@omnitronix/game-test-utils';
 
+/** Type alias for the full command processing result from the engine. */
+export type BonnysFortuneCommandResult = CommandProcessingResult<
+  BonnysFortunePublicState,
+  BonnysFortunePrivateState,
+  BonnysFortuneOutcome
+>;
+
+/**
+ * Loose outcome interface for test assertions.
+ * Tests frequently access properties across multiple outcome union members
+ * without narrowing. This interface provides a test-safe accessor pattern.
+ */
+export interface TestOutcome {
+  result?: {
+    screen?: number[][];
+    playerWinning?: number;
+    spinType?: string;
+    nextSpinType?: string;
+    winResult?: unknown;
+    [key: string]: unknown;
+  };
+  results?: Array<{
+    result?: {
+      playerWinning?: number;
+      spinType?: string;
+      nextSpinType?: string;
+      prizeType?: string;
+      prizeValue?: unknown;
+      totalMultiplier?: number;
+      triggeredBonus?: unknown;
+      [key: string]: unknown;
+    };
+    publicState?: BonnysFortunePublicState;
+    privateState?: BonnysFortunePrivateState;
+    [key: string]: unknown;
+  }>;
+  screen?: number[][];
+  playerWinning?: number;
+  triggeredBonus?: unknown;
+  nextSpinType?: string;
+  autoStarted?: boolean;
+  requiresStartCommand?: boolean;
+  updatedMeter?: unknown;
+  publicState?: BonnysFortunePublicState;
+  privateState?: BonnysFortunePrivateState;
+  [key: string]: unknown;
+}
+
+/**
+ * Cast outcome to a specific type for tests that know the expected shape.
+ * Uses `as unknown as T` pattern recommended for test fixtures.
+ */
+export function outcomeAs<T>(result: BonnysFortuneCommandResult): T {
+  return result.outcome as unknown as T;
+}
+
+/**
+ * Get the outcome from a command result as a test-friendly object.
+ * This avoids TypeScript union narrowing issues in test assertions.
+ */
+export function getOutcome(result: BonnysFortuneCommandResult): TestOutcome {
+  return (result.outcome ?? {}) as unknown as TestOutcome;
+}
+
 /**
  * Create a standard engine with default (DummyRngClient) RNG.
  */
@@ -74,6 +151,14 @@ export function createEngine(): BonnysFortuneV1GameEngine {
   return new BonnysFortuneV1GameEngine();
 }
 
+/**
+ * Helper to replace the rngClient on a shared RngService.
+ * The rngClient is private readonly, so we use a type assertion.
+ */
+function replaceRngClient(engine: BonnysFortuneV1GameEngine, client: IRngClient): void {
+  (engine.rngService as unknown as { rngClient: IRngClient }).rngClient = client;
+}
+
 /**
  * Create an engine with a MockRngClient injected.
  */
@@ -82,7 +167,7 @@ export function createEngineWithMockRng(
 ): { engine: BonnysFortuneV1GameEngine; mockRng: MockRngClient } {
   const engine = new BonnysFortuneV1GameEngine();
   const mockRng = new MockRngClient(values);
-  (engine.rngService as any).rngClient = mockRng;
+  replaceRngClient(engine, mockRng);
   return { engine, mockRng };
 }
 
@@ -94,7 +179,7 @@ export function createEngineWithLcgRng(
 ): { engine: BonnysFortuneV1GameEngine; lcgRng: LcgRngClient } {
   const engine = new BonnysFortuneV1GameEngine();
   const lcgRng = new LcgRngClient(seed);
-  (engine.rngService as any).rngClient = lcgRng;
+  replaceRngClient(engine, lcgRng);
   return { engine, lcgRng };
 }
 
@@ -105,7 +190,7 @@ export function injectMockRng(
   engine: BonnysFortuneV1GameEngine,
   mockRng: MockRngClient,
 ): void {
-  (engine.rngService as any).rngClient = mockRng;
+  replaceRngClient(engine, mockRng);
 }
 
 // ---------------------------------------------------------------------------
@@ -117,12 +202,12 @@ export function injectMockRng(
  * The engine constructor fires preload() without await (fire-and-forget).
  * We poll for `engine.reels` to be defined before proceeding.
  */
-export async function waitForEngineReady(engine: any, timeout = 5000): Promise<void> {
+export async function waitForEngineReady(engine: BonnysFortuneV1GameEngine, timeout = 5000): Promise<void> {
   const start = Date.now();
-  while (!engine.reels && Date.now() - start < timeout) {
+  while (!(engine as unknown as { reels: unknown }).reels && Date.now() - start < timeout) {
     await new Promise(resolve => setTimeout(resolve, 10));
   }
-  if (!engine.reels) {
+  if (!(engine as unknown as { reels: unknown }).reels) {
     throw new Error('Engine preload did not complete within timeout');
   }
 }
@@ -132,13 +217,13 @@ export async function waitForEngineReady(engine: any, timeout = 5000): Promise<v
 // ---------------------------------------------------------------------------
 
 export interface SessionState {
-  publicState: any;
-  privateState: any;
+  publicState: BonnysFortunePublicState;
+  privateState: BonnysFortunePrivateState;
 }
 
 /**
  * Initialize a session on the engine.
- * Waits for engine preload to complete before issuing any commands.
+ * Waits for engine preload to complete before issuing commands.
  */
 export async function initSession(
   engine: BonnysFortuneV1GameEngine,
@@ -146,7 +231,7 @@ export async function initSession(
   betAmountThresholds: number[] = [0.1, 0.2, 0.5, 1, 2, 5, 10, 20, 50, 100],
 ): Promise<SessionState> {
   await waitForEngineReady(engine);
-  const result = await engine.processCommand(null as any, null as any, {
+  const result = await engine.processCommand(null as unknown as BonnysFortunePublicState, null as unknown as BonnysFortunePrivateState, {
     id: nextCommandId('init'),
     type: 'INIT_SESSION_STATE',
     payload: {
@@ -167,10 +252,10 @@ export async function initSession(
  */
 export async function executeSpin(
   engine: BonnysFortuneV1GameEngine,
-  publicState: any,
-  privateState: any,
+  publicState: BonnysFortunePublicState,
+  privateState: BonnysFortunePrivateState,
   betAmount: number = 1.0,
-): Promise<any> {
+): Promise<BonnysFortuneCommandResult> {
   const result = await engine.processCommand(publicState, privateState, {
     id: nextCommandId('spin'),
     type: 'SPIN',
@@ -194,14 +279,15 @@ export async function executeSpin(
  */
 export async function safeExecuteSpin(
   engine: BonnysFortuneV1GameEngine,
-  publicState: any,
-  privateState: any,
+  publicState: BonnysFortunePublicState,
+  privateState: BonnysFortunePrivateState,
   betAmount: number = 1.0,
-): Promise<any | null> {
+): Promise<BonnysFortuneCommandResult | null> {
   try {
     return await executeSpin(engine, publicState, privateState, betAmount);
-  } catch (error: any) {
+  } catch (error: unknown) {
     if (
+      error instanceof Error &&
       error.message?.includes('Cannot execute base spin')
     ) {
       return null;
@@ -215,12 +301,12 @@ export async function safeExecuteSpin(
  */
 export async function executeSpins(
   engine: BonnysFortuneV1GameEngine,
-  publicState: any,
-  privateState: any,
+  publicState: BonnysFortunePublicState,
+  privateState: BonnysFortunePrivateState,
   count: number,
   betAmount: number = 1.0,
-): Promise<any[]> {
-  const results: any[] = [];
+): Promise<BonnysFortuneCommandResult[]> {
+  const results: BonnysFortuneCommandResult[] = [];
   let currentPublic = publicState;
   let currentPrivate = privateState;
 
@@ -239,11 +325,11 @@ export async function executeSpins(
  */
 export async function startBonusRound(
   engine: BonnysFortuneV1GameEngine,
-  publicState: any,
-  privateState: any,
+  publicState: BonnysFortunePublicState,
+  privateState: BonnysFortunePrivateState,
   bonusType: string = 'bonusGame1',
   betAmount: number = 1.0,
-): Promise<any> {
+): Promise<BonnysFortuneCommandResult> {
   const bonusId = privateState.pendingBonuses?.[0]?.bonusId ?? 'test-bonus-id';
 
   const result = await engine.processCommand(publicState, privateState, {
@@ -267,11 +353,11 @@ export async function startBonusRound(
  */
 export async function debugTriggerBonus(
   engine: BonnysFortuneV1GameEngine,
-  publicState: any,
-  privateState: any,
+  publicState: BonnysFortunePublicState,
+  privateState: BonnysFortunePrivateState,
   bonusType: string = 'bonusGame1',
   betAmount: number = 1.0,
-): Promise<any> {
+): Promise<BonnysFortuneCommandResult> {
   const result = await engine.processCommand(publicState, privateState, {
     id: nextCommandId('debug'),
     type: 'DEBUG_TRIGGER_BONUS',
@@ -290,11 +376,11 @@ export async function debugTriggerBonus(
  */
 export async function debugUpdateBonusMeter(
   engine: BonnysFortuneV1GameEngine,
-  publicState: any,
-  privateState: any,
+  publicState: BonnysFortunePublicState,
+  privateState: BonnysFortunePrivateState,
   meterId: string,
   progress: number,
-): Promise<any> {
+): Promise<BonnysFortuneCommandResult> {
   const result = await engine.processCommand(publicState, privateState, {
     id: nextCommandId('debug-meter'),
     type: 'DEBUG_UPDATE_BONUS_METER_PROGRESS',
@@ -313,12 +399,13 @@ export async function debugUpdateBonusMeter(
  * are the ORIGINAL input states. The actual final state (with nextSpinType
  * transitioned back to BASE_GAME_SPIN) is in the last result entry.
  */
-export function extractFinalBonusState(bonusResult: any): {
-  publicState: any;
-  privateState: any;
+export function extractFinalBonusState(bonusResult: BonnysFortuneCommandResult): {
+  publicState: BonnysFortunePublicState;
+  privateState: BonnysFortunePrivateState;
 } {
-  const results = bonusResult.outcome?.results;
-  if (results?.length > 0) {
+  const outcome = bonusResult.outcome as BonusRoundResult<SpinResult> | null | undefined;
+  const results = outcome?.results;
+  if (results && results.length > 0) {
     const lastResult = results[results.length - 1];
     return {
       publicState: lastResult.publicState ?? bonusResult.publicState,
@@ -337,7 +424,7 @@ export function extractFinalBonusState(bonusResult: any): {
 export function getRngOutcome(
   engine: BonnysFortuneV1GameEngine,
   commandId: string,
-): any {
+): RngOutcome {
   return engine.rngService.getRngOutcomeForCommand(commandId);
 }
 
@@ -346,7 +433,7 @@ export function getRngOutcome(
  */
 export function getAllRngOutcomes(
   engine: BonnysFortuneV1GameEngine,
-): any {
+): Record<string, RngOutcome> {
   return engine.rngService.getAllRngOutcome();
 }
 
@@ -358,9 +445,9 @@ export async function runSpinCycle(
   spinCount: number,
   betAmount: number = 1.0,
 ): Promise<{
-  results: any[];
-  finalPublicState: any;
-  finalPrivateState: any;
+  results: BonnysFortuneCommandResult[];
+  finalPublicState: BonnysFortunePublicState;
+  finalPrivateState: BonnysFortunePrivateState;
 }> {
   const session = await initSession(engine, betAmount);
   const results = await executeSpins(

package/src/__tests__/integration-1000-spin.test.ts

@@ -16,7 +16,31 @@ import {
   extractFinalBonusState,
   debugTriggerBonus,
   resetCommandIdCounter,
+  BonnysFortuneCommandResult,
+  getOutcome,
 } from './helpers/test-engine-factory';
+import { BonnysFortuneV1GameEngine } from '../bonnys-fortune-v1.game-engine';
+import {
+  BonnysFortunePublicState,
+  BonnysFortunePrivateState,
+  SpinResult,
+  BonusRoundResult,
+  SpinResultResponse,
+} from '../logic/bonnys-fortune.types';
+
+/** Extract playerWinning from a command result outcome. */
+function extractPlayerWinning(result: BonnysFortuneCommandResult): number {
+  const outcome = result.outcome as unknown as {
+    result?: { playerWinning?: number; totalWin?: number };
+    playerWinning?: number;
+    totalWin?: number;
+  } | null;
+  return outcome?.result?.playerWinning
+    ?? outcome?.playerWinning
+    ?? outcome?.result?.totalWin
+    ?? outcome?.totalWin
+    ?? 0;
+}
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -24,15 +48,15 @@ import {
 
 /** Drain all pending bonuses, including chained ones (e.g. bonusGame3 -> bonusGame1). */
 async function drainAllBonuses(
-  engine: any,
-  pub: any,
-  priv: any,
+  engine: BonnysFortuneV1GameEngine,
+  pub: BonnysFortunePublicState,
+  priv: BonnysFortunePrivateState,
   betAmount: number,
   tracker: {
     bonusTriggersPerType: Record<string, number>;
     totalWon: number;
   },
-): Promise<{ pub: any; priv: any }> {
+): Promise<{ pub: BonnysFortunePublicState; priv: BonnysFortunePrivateState }> {
   let maxDepth = 10; // safety guard against infinite chaining
   while (priv.pendingBonuses?.length > 0 && maxDepth-- > 0) {
     const bonus = priv.pendingBonuses[0];
@@ -51,22 +75,14 @@ async function drainAllBonuses(
     expect(bonusResult.success).toBe(true);
 
     // Sum bonus winnings from results array
-    if (bonusResult.outcome?.results) {
-      for (const r of bonusResult.outcome.results) {
-        const win =
-          r.result?.playerWinning ??
-          r.playerWinning ??
-          r.result?.totalWin ??
-          r.totalWin ??
-          0;
+    const bonusOutcome = bonusResult.outcome as unknown as BonusRoundResult<SpinResult> | null;
+    if (bonusOutcome?.results) {
+      for (const r of bonusOutcome.results) {
+        const win = r.result?.playerWinning ?? 0;
         tracker.totalWon += win;
       }
     } else {
-      const win =
-        (bonusResult.outcome as any)?.result?.playerWinning ??
-        (bonusResult.outcome as any)?.playerWinning ??
-        0;
-      tracker.totalWon += win;
+      tracker.totalWon += extractPlayerWinning(bonusResult);
     }
 
     const finalState = extractFinalBonusState(bonusResult);
@@ -77,7 +93,7 @@ async function drainAllBonuses(
 }
 
 /** Validate state consistency assertions after any command. */
-function assertStateConsistency(pub: any, priv: any): void {
+function assertStateConsistency(pub: BonnysFortunePublicState, priv: BonnysFortunePrivateState): void {
   // publicState.bonusMeters has exactly 3 keys
   expect(pub.bonusMeters).toBeDefined();
   expect(Object.keys(pub.bonusMeters).length).toBe(3);
@@ -177,10 +193,7 @@ describe('Integration: 1000-Spin Simulation — Bonnys Fortune', () => {
             spinCount++;
             totalWagered += betAmount;
 
-            const win =
-              (retry.outcome as any)?.result?.playerWinning ??
-              (retry.outcome as any)?.playerWinning ??
-              0;
+            const win = extractPlayerWinning(retry);
             totalWon += win;
 
             pub = retry.publicState;
@@ -191,10 +204,7 @@ describe('Integration: 1000-Spin Simulation — Bonnys Fortune', () => {
           spinCount++;
           totalWagered += betAmount;
 
-          const win =
-            (spinResult.outcome as any)?.result?.playerWinning ??
-            (spinResult.outcome as any)?.playerWinning ??
-            0;
+          const win = extractPlayerWinning(spinResult);
           totalWon += win;
 
           pub = spinResult.publicState;
@@ -267,9 +277,10 @@ describe('Integration: 1000-Spin Simulation — Bonnys Fortune', () => {
 
         // Outcome assertions
         expect(debugResult.outcome).toBeDefined();
-        expect(debugResult.outcome.nextSpinType).toBe(expectedNextSpinType);
-        expect(debugResult.outcome.autoStarted).toBe(false);
-        expect(debugResult.outcome.requiresStartCommand).toBe(true);
+        const debugOutcome = getOutcome(debugResult);
+        expect(debugOutcome.nextSpinType).toBe(expectedNextSpinType);
+        expect(debugOutcome.autoStarted).toBe(false);
+        expect(debugOutcome.requiresStartCommand).toBe(true);
 
         // Pending bonuses
         expect(debugResult.privateState.pendingBonuses.length).toBe(1);
@@ -285,9 +296,10 @@ describe('Integration: 1000-Spin Simulation — Bonnys Fortune', () => {
 
         expect(bonusResult.success).toBe(true);
         expect(bonusResult.outcome).toBeDefined();
-        expect(bonusResult.outcome.results).toBeDefined();
-        expect(Array.isArray(bonusResult.outcome.results)).toBe(true);
-        expect(bonusResult.outcome.results.length).toBeGreaterThan(0);
+        const bonusOutcome = getOutcome(bonusResult);
+        expect(bonusOutcome.results).toBeDefined();
+        expect(Array.isArray(bonusOutcome.results)).toBe(true);
+        expect(bonusOutcome.results!.length).toBeGreaterThan(0);
 
         // Final state
         const finalState = extractFinalBonusState(bonusResult);
@@ -370,13 +382,11 @@ describe('Integration: 1000-Spin Simulation — Bonnys Fortune', () => {
             completions++;
 
             // Track total wins from bonus results
-            if (bonusResult.outcome?.results) {
-              for (const r of bonusResult.outcome.results) {
+            const stressOutcome = getOutcome(bonusResult);
+            if (stressOutcome.results) {
+              for (const r of stressOutcome.results) {
                 const w =
                   r.result?.playerWinning ??
-                  r.playerWinning ??
-                  r.result?.totalWin ??
-                  r.totalWin ??
                   0;
                 wins += w;
               }
@@ -467,10 +477,7 @@ describe('Integration: 1000-Spin Simulation — Bonnys Fortune', () => {
           paidSpins++;
           totalWagered += betAmount;
 
-          const win =
-            (spinResult.outcome as any)?.result?.playerWinning ??
-            (spinResult.outcome as any)?.playerWinning ??
-            0;
+          const win = extractPlayerWinning(spinResult);
           totalWon += win;
 
           pub = spinResult.publicState;
@@ -550,10 +557,11 @@ describe('Integration: 1000-Spin Simulation — Bonnys Fortune', () => {
               expect(bonusResult.success).toBe(true);
 
               // Check winnings are non-negative
-              if (bonusResult.outcome?.results) {
-                for (const r of bonusResult.outcome.results) {
+              const consistencyOutcome = getOutcome(bonusResult);
+              if (consistencyOutcome.results) {
+                for (const r of consistencyOutcome.results) {
                   const w =
-                    r.result?.playerWinning ?? r.playerWinning ?? 0;
+                    r.result?.playerWinning ?? 0;
                   expect(w).toBeGreaterThanOrEqual(0);
                 }
               }
@@ -578,10 +586,7 @@ describe('Integration: 1000-Spin Simulation — Bonnys Fortune', () => {
           if (!spinResult) continue;
 
           // Check spin winning is non-negative
-          const spinWin =
-            (spinResult.outcome as any)?.result?.playerWinning ??
-            (spinResult.outcome as any)?.playerWinning ??
-            0;
+          const spinWin = extractPlayerWinning(spinResult);
           expect(spinWin).toBeGreaterThanOrEqual(0);
 
           pub = spinResult.publicState;