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

package/src/__tests__/rng-gli19-compliance.test.ts

@@ -65,7 +65,7 @@ describe('GLI-19 Compliance — Bonnys Fortune', () => {
       const session = await initSession(engine);
       const result = await executeSpin(engine, session.publicState, session.privateState);
 
-      const outcome = result.rngOutcome;
+      const outcome = result.rngOutcome!;
       const validation = validateRngOutcome(outcome);
 
       expect(validation.valid).toBe(true);
@@ -115,7 +115,7 @@ describe('GLI-19 Compliance — Bonnys Fortune', () => {
         expect(result.rngOutcome).toBeDefined();
         expect(Object.keys(result.rngOutcome || {}).length).toBeGreaterThan(0);
 
-        const validation = validateRngOutcome(result.rngOutcome);
+        const validation = validateRngOutcome(result.rngOutcome!);
         expect(validation.valid).toBe(true);
 
         pub = result.publicState;
@@ -154,7 +154,7 @@ describe('GLI-19 Compliance — Bonnys Fortune', () => {
       const session = await initSession(engine);
       const result = await executeSpin(engine, session.publicState, session.privateState);
 
-      const hash = hashRngOutcome(result.rngOutcome);
+      const hash = hashRngOutcome(result.rngOutcome!);
       expect(isValidSha256(hash)).toBe(true);
     });
 
@@ -165,8 +165,8 @@ describe('GLI-19 Compliance — Bonnys Fortune', () => {
       const result1 = await executeSpin(engine, session.publicState, session.privateState);
       const result2 = await executeSpin(engine, result1.publicState, result1.privateState);
 
-      const hash1 = hashRngOutcome(result1.rngOutcome);
-      const hash2 = hashRngOutcome(result2.rngOutcome);
+      const hash1 = hashRngOutcome(result1.rngOutcome!);
+      const hash2 = hashRngOutcome(result2.rngOutcome!);
 
       expect(hash1).not.toBe(hash2);
     });
@@ -176,8 +176,8 @@ describe('GLI-19 Compliance — Bonnys Fortune', () => {
       const session = await initSession(engine);
       const result = await executeSpin(engine, session.publicState, session.privateState);
 
-      const hash1 = hashRngOutcome(result.rngOutcome);
-      const hash2 = hashRngOutcome(result.rngOutcome);
+      const hash1 = hashRngOutcome(result.rngOutcome!);
+      const hash2 = hashRngOutcome(result.rngOutcome!);
 
       expect(hash1).toBe(hash2);
     });
@@ -187,7 +187,7 @@ describe('GLI-19 Compliance — Bonnys Fortune', () => {
       const session = await initSession(engine);
       const result = await executeSpin(engine, session.publicState, session.privateState);
 
-      const originalHash = hashRngOutcome(result.rngOutcome);
+      const originalHash = hashRngOutcome(result.rngOutcome!);
 
       interface RngOutcomeRecord {
         result: number;
@@ -217,9 +217,9 @@ describe('GLI-19 Compliance — Bonnys Fortune', () => {
         max: number;
       }
 
-      const canonical1 = canonicalizeRngOutcome(result.rngOutcome);
+      const canonical1 = canonicalizeRngOutcome(result.rngOutcome!);
       const reversed: Record<string, RngOutcomeRecord> = {};
-      const keys = Object.keys(result.rngOutcome).reverse();
+      const keys = Object.keys(result.rngOutcome!).reverse();
       for (const key of keys) {
         reversed[key] = (result.rngOutcome as Record<string, RngOutcomeRecord>)[key];
       }
@@ -255,8 +255,8 @@ describe('GLI-19 Compliance — Bonnys Fortune', () => {
       const session2 = await initSession(engine2);
       const result2 = await executeSpin(engine2, session2.publicState, session2.privateState);
 
-      const hash1 = hashRngOutcome(result1.rngOutcome);
-      const hash2 = hashRngOutcome(result2.rngOutcome);
+      const hash1 = hashRngOutcome(result1.rngOutcome!);
+      const hash2 = hashRngOutcome(result2.rngOutcome!);
       expect(hash1).toBe(hash2);
     });
 
@@ -269,8 +269,8 @@ describe('GLI-19 Compliance — Bonnys Fortune', () => {
       const session2 = await initSession(engine2);
       const result2 = await executeSpin(engine2, session2.publicState, session2.privateState);
 
-      const hash1 = hashRngOutcome(result1.rngOutcome);
-      const hash2 = hashRngOutcome(result2.rngOutcome);
+      const hash1 = hashRngOutcome(result1.rngOutcome!);
+      const hash2 = hashRngOutcome(result2.rngOutcome!);
       expect(hash1).not.toBe(hash2);
     });
   });
@@ -305,7 +305,7 @@ describe('GLI-19 Compliance — Bonnys Fortune', () => {
         }
 
         const result = await executeSpin(engine, pub, priv);
-        const hash = hashRngOutcome(result.rngOutcome);
+        const hash = hashRngOutcome(result.rngOutcome!);
         expect(isValidSha256(hash)).toBe(true);
         hashChain.push(hash);
 
@@ -330,7 +330,7 @@ describe('GLI-19 Compliance — Bonnys Fortune', () => {
 
       for (let i = 0; i < 3; i++) {
         const result = await executeSpin(engine, pub, priv);
-        const outcomeHash = hashRngOutcome(result.rngOutcome);
+        const outcomeHash = hashRngOutcome(result.rngOutcome!);
         const chainedHash = hashString(prevHash + outcomeHash);
 
         expect(isValidSha256(chainedHash)).toBe(true);
@@ -412,7 +412,7 @@ describe('GLI-19 Compliance — Bonnys Fortune', () => {
 
       for (let i = 0; i < 10; i++) {
         const result = await executeSpin(engine, pub, priv);
-        const validation = validateRngOutcome(result.rngOutcome);
+        const validation = validateRngOutcome(result.rngOutcome!);
         expect(validation.valid).toBe(true);
 
         pub = result.publicState;

package/src/__tests__/rng-security.test.ts

@@ -24,6 +24,10 @@ import {
   validateRngOutcome,
   waitForEngineReady,
 } from './helpers/test-engine-factory';
+import {
+  BonnysFortunePublicState,
+  BonnysFortunePrivateState,
+} from '../logic/bonnys-fortune.types';
 
 describe('RNG Security — Bonnys Fortune', () => {
   beforeEach(() => {
@@ -42,8 +46,7 @@ describe('RNG Security — Bonnys Fortune', () => {
     it('should handle null state gracefully for INIT', async () => {
       const engine = createEngine();
       await waitForEngineReady(engine);
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      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 },
@@ -61,7 +64,7 @@ describe('RNG Security — Bonnys Fortune', () => {
       const session = await initSession(engine);
 
       try {
-        await executeSpin(engine, null, session.privateState);
+        await executeSpin(engine, null as unknown as BonnysFortunePublicState, session.privateState);
         // If no exception, test should still pass as the engine handled it
       } catch (error) {
         expect(error).toBeInstanceOf(Error);
@@ -74,7 +77,7 @@ describe('RNG Security — Bonnys Fortune', () => {
       const session = await initSession(engine);
 
       try {
-        await executeSpin(engine, session.publicState, null);
+        await executeSpin(engine, session.publicState, null as unknown as BonnysFortunePrivateState);
         // If no exception, test should still pass as the engine handled it
       } catch (error) {
         expect(error).toBeInstanceOf(Error);
@@ -193,7 +196,7 @@ describe('RNG Security — Bonnys Fortune', () => {
       const result = await executeSpin(engine, session.publicState, session.privateState);
 
       expect(result.success).toBe(true);
-      const validation = validateRngOutcome(result.rngOutcome);
+      const validation = validateRngOutcome(result.rngOutcome!);
       expect(validation.valid).toBe(true);
     });
 
@@ -251,10 +254,10 @@ describe('RNG Security — Bonnys Fortune', () => {
       const engine = createEngine();
       const session = await initSession(engine);
 
-      const pollutedState = cloneState(session.privateState) as Record<string, unknown>;
+      const pollutedState = cloneState(session.privateState) as unknown as Record<string, unknown>;
       Object.setPrototypeOf(pollutedState, { malicious: true });
 
-      const result = await executeSpin(engine, session.publicState, pollutedState);
+      const result = await executeSpin(engine, session.publicState, pollutedState as unknown as BonnysFortunePrivateState);
       expect(result.success).toBe(true);
       expect(result.publicState).toBeDefined();
       expect(typeof result.publicState).toBe('object');
@@ -288,7 +291,7 @@ describe('RNG Security — Bonnys Fortune', () => {
 
       const stateBefore = cloneState(session) as { publicState: object; privateState: object };
       const result1 = await executeSpin(engine, session.publicState, session.privateState);
-      const result2 = await executeSpin(engine, stateBefore.publicState, stateBefore.privateState);
+      const result2 = await executeSpin(engine, stateBefore.publicState as BonnysFortunePublicState, stateBefore.privateState as BonnysFortunePrivateState);
 
       expect(result1).toBeDefined();
       expect(result1.success).toBe(true);

package/src/__tests__/rtp-simulation.test.ts

@@ -19,9 +19,24 @@ import {
   extractFinalBonusState,
   nextCommandId,
   resetCommandIdCounter,
+  BonnysFortuneCommandResult,
 } from './helpers/test-engine-factory';
 import { StatisticalValidator } from '@omnitronix/game-test-utils';
 
+/** 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;
+}
+
 // ---------------------------------------------------------------------------
 // Simulation helpers
 // ---------------------------------------------------------------------------
@@ -82,11 +97,7 @@ async function runSimulation(
           const bonusResult = await startBonusRound(engine, pub, priv, bonusType, betAmount);
           if (bonusResult.success) {
             // BF generates all bonus results upfront
-            const bonusWin = (bonusResult.outcome as any)?.result?.playerWinning
-              ?? (bonusResult.outcome as any)?.playerWinning
-              ?? (bonusResult.outcome as any)?.result?.totalWin
-              ?? (bonusResult.outcome as any)?.totalWin
-              ?? 0;
+            const bonusWin = extractPlayerWinning(bonusResult);
             result.totalWon += bonusWin;
             result.bonusRounds++;
 
@@ -118,11 +129,7 @@ async function runSimulation(
     result.totalWagered += betAmount;
 
     // BF uses outcome.result.playerWinning or outcome.playerWinning
-    const totalWin = (spinResult.outcome as any)?.result?.playerWinning
-      ?? (spinResult.outcome as any)?.playerWinning
-      ?? (spinResult.outcome as any)?.result?.totalWin
-      ?? (spinResult.outcome as any)?.totalWin
-      ?? 0;
+    const totalWin = extractPlayerWinning(spinResult);
     result.totalWon += totalWin;
 
     // Classify win

package/src/__tests__/state-transitions.test.ts

@@ -23,6 +23,11 @@ import {
   resetCommandIdCounter,
   waitForEngineReady,
 } from './helpers/test-engine-factory';
+import {
+  BonnysFortunePublicState,
+  BonnysFortunePrivateState,
+  BonusTrigger,
+} from '../logic/bonnys-fortune.types';
 
 describe('State Transitions — Bonnys Fortune', () => {
   beforeEach(() => {
@@ -266,7 +271,7 @@ describe('State Transitions — Bonnys Fortune', () => {
       expect(bonusResult.success).toBe(true);
       // Pending bonus for this type should be consumed
       const remaining = bonusResult.privateState.pendingBonuses.filter(
-        (b: any) => b.bonusId === bonus.bonusId,
+        (b: BonusTrigger) => b.bonusId === bonus.bonusId,
       );
       expect(remaining.length).toBe(0);
     });
@@ -320,8 +325,7 @@ describe('State Transitions — Bonnys Fortune', () => {
       const engine = createEngine();
       await waitForEngineReady(engine);
 
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      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('symbols'),
         type: 'GET_SYMBOLS',
         payload: {},
@@ -345,7 +349,7 @@ describe('State Transitions — Bonnys Fortune', () => {
       };
 
       try {
-        const result = await executeSpin(engine, session.publicState, modifiedPriv);
+        const result = await executeSpin(engine, session.publicState, modifiedPriv as BonnysFortunePrivateState);
         // Should fail or throw
         if (result.success === false) {
           expect(result.success).toBe(false);

package/src/__tests__/steering-fortune-handler.test.ts

@@ -20,7 +20,19 @@ import {
   resetCommandIdCounter,
   MockRngClient,
 } from './helpers/test-engine-factory';
-import { SpinType, PrizeType } from '../logic/bonnys-fortune.types';
+import {
+  SpinType,
+  PrizeType,
+  SteeringToTheFortuneResult,
+  SpinResultResponse,
+  BonusRoundResult,
+} from '../logic/bonnys-fortune.types';
+import { BonnysFortuneCommandResult } from './helpers/test-engine-factory';
+
+/** Helper to extract steering fortune results from a bonus command result */
+function getSteeringResults(result: BonnysFortuneCommandResult): SpinResultResponse<SteeringToTheFortuneResult>[] {
+  return (result.outcome as unknown as BonusRoundResult<SteeringToTheFortuneResult>).results;
+}
 
 describe('Steering Fortune Handler - Bonnys Fortune', () => {
   beforeEach(() => {
@@ -50,9 +62,9 @@ describe('Steering Fortune Handler - Bonnys Fortune', () => {
       );
 
       expect(bonusResult.success).toBe(true);
-      expect(bonusResult.outcome?.results).toBeDefined();
+      expect(getSteeringResults(bonusResult)).toBeDefined();
       // Steering Fortune produces exactly 1 result per spin
-      expect(bonusResult.outcome.results.length).toBe(1);
+      expect(getSteeringResults(bonusResult).length).toBe(1);
     });
 
     it('should use weighted draw for wheel segment selection', async () => {
@@ -104,7 +116,7 @@ describe('Steering Fortune Handler - Bonnys Fortune', () => {
       );
 
       expect(bonusResult.success).toBe(true);
-      expect(bonusResult.outcome.results[0].result.spinType).toBe(
+      expect(getSteeringResults(bonusResult)[0].result.spinType).toBe(
         SpinType.BONUS_GAME_3_SPIN,
       );
     });
@@ -133,7 +145,7 @@ describe('Steering Fortune Handler - Bonnys Fortune', () => {
       );
 
       expect(bonusResult.success).toBe(true);
-      const prizeType = bonusResult.outcome.results[0].result.prizeType;
+      const prizeType = getSteeringResults(bonusResult)[0].result.prizeType;
       expect([PrizeType.MULTIPLIER, PrizeType.BONUS]).toContain(prizeType);
     });
 
@@ -160,7 +172,7 @@ describe('Steering Fortune Handler - Bonnys Fortune', () => {
       );
 
       expect(bonusResult.success).toBe(true);
-      const result = bonusResult.outcome.results[0].result;
+      const result = getSteeringResults(bonusResult)[0].result;
       expect(result.playerWinning).toBeDefined();
       expect(typeof result.playerWinning).toBe('number');
     });
@@ -187,7 +199,7 @@ describe('Steering Fortune Handler - Bonnys Fortune', () => {
       );
 
       expect(bonusResult.success).toBe(true);
-      const result = bonusResult.outcome.results[0].result;
+      const result = getSteeringResults(bonusResult)[0].result;
       expect(result.prizeValue).toBeDefined();
     });
 
@@ -213,7 +225,7 @@ describe('Steering Fortune Handler - Bonnys Fortune', () => {
       );
 
       expect(bonusResult.success).toBe(true);
-      const result = bonusResult.outcome.results[0].result;
+      const result = getSteeringResults(bonusResult)[0].result;
       expect(result.totalMultiplier).toBeDefined();
       expect(typeof result.totalMultiplier).toBe('number');
     });
@@ -249,11 +261,11 @@ describe('Steering Fortune Handler - Bonnys Fortune', () => {
 
         if (!bonusResult.success) continue;
 
-        const result = bonusResult.outcome.results[0].result;
+        const result = getSteeringResults(bonusResult)[0].result;
         if (result.prizeType === PrizeType.BONUS) {
           expect(result.triggeredBonus).toBeDefined();
-          expect(result.triggeredBonus.bonusId).toBeDefined();
-          expect(result.triggeredBonus.bonusType).toBeDefined();
+          expect(result.triggeredBonus!.bonusId).toBeDefined();
+          expect(result.triggeredBonus!.bonusType).toBeDefined();
           return; // Test passed
         }
       }
@@ -286,7 +298,7 @@ describe('Steering Fortune Handler - Bonnys Fortune', () => {
       expect(bonusResult.success).toBe(true);
 
       const finalState = extractFinalBonusState(bonusResult);
-      const result = bonusResult.outcome.results[0].result;
+      const result = getSteeringResults(bonusResult)[0].result;
 
       if (result.prizeType === PrizeType.BONUS) {
         // Should have pending bonus for chaining
@@ -352,7 +364,7 @@ describe('Steering Fortune Handler - Bonnys Fortune', () => {
 
         if (!bonusResult.success) continue;
 
-        const result = bonusResult.outcome.results[0].result;
+        const result = getSteeringResults(bonusResult)[0].result;
         if (result.prizeType === PrizeType.MULTIPLIER) {
           const finalState = extractFinalBonusState(bonusResult);
           expect(finalState.privateState.nextSpinType).toBe(SpinType.BASE_GAME_SPIN);
@@ -414,7 +426,7 @@ describe('Steering Fortune Handler - Bonnys Fortune', () => {
       );
 
       expect(bonusResult.success).toBe(true);
-      const result = bonusResult.outcome.results[0].result;
+      const result = getSteeringResults(bonusResult)[0].result;
 
       if (result.prizeType === PrizeType.MULTIPLIER) {
         expect(typeof result.prizeValue).toBe('number');
@@ -447,7 +459,7 @@ describe('Steering Fortune Handler - Bonnys Fortune', () => {
       );
 
       expect(bonusResult.success).toBe(true);
-      expect(bonusResult.outcome.results[0].result.playerWinning).toBeGreaterThanOrEqual(
+      expect(getSteeringResults(bonusResult)[0].result.playerWinning).toBeGreaterThanOrEqual(
         0,
       );
     });
@@ -482,7 +494,7 @@ describe('Steering Fortune Handler - Bonnys Fortune', () => {
         );
 
         if (bonusResult.success) {
-          const result = bonusResult.outcome.results[0].result;
+          const result = getSteeringResults(bonusResult)[0].result;
           if (result.prizeType === PrizeType.MULTIPLIER) {
             winnings.push(result.playerWinning);
           }
@@ -499,7 +511,7 @@ describe('Steering Fortune Handler - Bonnys Fortune', () => {
 
   describe('RNG Determinism', () => {
     it('should produce consistent results with same LCG seed', async () => {
-      const results: any[] = [];
+      const results: SteeringToTheFortuneResult[] = [];
 
       for (let i = 0; i < 2; i++) {
         resetCommandIdCounter();
@@ -523,7 +535,7 @@ describe('Steering Fortune Handler - Bonnys Fortune', () => {
           bonus.bonusType,
         );
 
-        results.push(bonusResult.outcome.results[0].result);
+        results.push(getSteeringResults(bonusResult)[0].result);
       }
 
       expect(results.length).toBe(2);

package/src/__tests__/symbol-distribution.test.ts

@@ -15,8 +15,23 @@ import {
   initSession,
   safeExecuteSpin,
   resetCommandIdCounter,
+  BonnysFortuneCommandResult,
 } from './helpers/test-engine-factory';
 
+/** Extract screen from a spin outcome (BF may have different shapes). */
+function extractScreen(result: BonnysFortuneCommandResult): number[][] | null {
+  const outcome = result.outcome as unknown as {
+    result?: { screen?: number[][] };
+    screens?: Array<{ screen?: number[][] }>;
+    screen?: number[][];
+  } | null;
+  return outcome?.result?.screen
+    ?? outcome?.screens?.[0]?.screen
+    ?? (result.publicState as unknown as { screen?: number[][] })?.screen
+    ?? outcome?.screen
+    ?? null;
+}
+
 // ---------------------------------------------------------------------------
 // Constants
 // ---------------------------------------------------------------------------
@@ -56,10 +71,7 @@ describe('Symbol Distribution — Bonnys Fortune', () => {
 
       // Get screen from outcome (5 reels × 3 rows = 15 positions)
       // BF outcome: result.screen
-      const screen = (result.outcome as any)?.result?.screen
-        ?? result.outcome?.screens?.[0]?.screen
-        ?? result.publicState?.screen
-        ?? (result.outcome as any)?.screen;
+      const screen = extractScreen(result);
 
       if (screen) {
         for (const reel of screen) {
@@ -107,10 +119,7 @@ describe('Symbol Distribution — Bonnys Fortune', () => {
       if (!result) break;
 
       // BF outcome: result.screen
-      const screen = (result.outcome as any)?.result?.screen
-        ?? result.outcome?.screens?.[0]?.screen
-        ?? result.publicState?.screen
-        ?? (result.outcome as any)?.screen;
+      const screen = extractScreen(result);
 
       if (screen) {
         for (const reel of screen) {
@@ -154,10 +163,7 @@ describe('Symbol Distribution — Bonnys Fortune', () => {
       if (!result) break;
 
       // BF outcome: result.screen
-      const screen = (result.outcome as any)?.result?.screen
-        ?? result.outcome?.screens?.[0]?.screen
-        ?? result.publicState?.screen
-        ?? (result.outcome as any)?.screen;
+      const screen = extractScreen(result);
 
       if (screen) {
         for (const reel of screen) {
@@ -197,10 +203,7 @@ describe('Symbol Distribution — Bonnys Fortune', () => {
       if (!result) break;
 
       // BF outcome: result.screen
-      const screen = (result.outcome as any)?.result?.screen
-        ?? result.outcome?.screens?.[0]?.screen
-        ?? result.publicState?.screen
-        ?? (result.outcome as any)?.screen;
+      const screen = extractScreen(result);
 
       if (screen) {
         const unique = new Set<number>();

package/src/__tests__/treasure-hunt-handler.test.ts

@@ -19,8 +19,19 @@ import {
   nextCommandId,
   resetCommandIdCounter,
   MockRngClient,
+  BonnysFortuneCommandResult,
 } from './helpers/test-engine-factory';
-import { SpinType } from '../logic/bonnys-fortune.types';
+import {
+  SpinType,
+  SpinResultResponse,
+  TreasureHuntSpinResult,
+  BonusRoundResult,
+} from '../logic/bonnys-fortune.types';
+
+/** Helper to extract treasure hunt results from a bonus command result */
+function getTreasureResults(result: BonnysFortuneCommandResult): SpinResultResponse<TreasureHuntSpinResult>[] {
+  return (result.outcome as unknown as BonusRoundResult<TreasureHuntSpinResult>).results;
+}
 
 describe('Treasure Hunt Handler - Bonnys Fortune', () => {
   beforeEach(() => {
@@ -50,11 +61,11 @@ describe('Treasure Hunt Handler - Bonnys Fortune', () => {
       );
 
       expect(bonusResult.success).toBe(true);
-      expect(bonusResult.outcome?.results).toBeDefined();
-      expect(bonusResult.outcome.results.length).toBeGreaterThan(0);
+      expect(getTreasureResults(bonusResult)).toBeDefined();
+      expect(getTreasureResults(bonusResult).length).toBeGreaterThan(0);
 
       // Each step should have a selection
-      for (const step of bonusResult.outcome.results) {
+      for (const step of getTreasureResults(bonusResult)) {
         expect(step.result.selection).toBeDefined();
         expect(['mini', 'minor', 'major', 'grand']).toContain(step.result.selection);
       }
@@ -85,7 +96,7 @@ describe('Treasure Hunt Handler - Bonnys Fortune', () => {
 
       // Each result should have multiplierCounts that accumulate
       let prevTotal = 0;
-      for (const step of bonusResult.outcome.results) {
+      for (const step of getTreasureResults(bonusResult)) {
         const counts = step.result.multiplierCounts as Record<string, number>;
         expect(counts).toBeDefined();
         const total = Object.values(counts).reduce((a, b) => a + b, 0);
@@ -118,7 +129,7 @@ describe('Treasure Hunt Handler - Bonnys Fortune', () => {
       expect(bonusResult.success).toBe(true);
 
       const validJackpots = ['mini', 'minor', 'major', 'grand'];
-      for (const step of bonusResult.outcome.results) {
+      for (const step of getTreasureResults(bonusResult)) {
         expect(validJackpots).toContain(step.result.selection);
       }
     });
@@ -149,8 +160,9 @@ describe('Treasure Hunt Handler - Bonnys Fortune', () => {
       expect(bonusResult.success).toBe(true);
 
       // Check that jackpot keys are valid
-      const selections = bonusResult.outcome.results.map(
-        (r: any) => r.result.selection,
+      const bonusOutcome = bonusResult.outcome as unknown as BonusRoundResult<TreasureHuntSpinResult>;
+      const selections = bonusOutcome.results.map(
+        (r: SpinResultResponse<TreasureHuntSpinResult>) => r.result.selection,
       );
       const uniqueSelections = [...new Set(selections)];
       expect(uniqueSelections.length).toBeGreaterThanOrEqual(1);
@@ -182,7 +194,7 @@ describe('Treasure Hunt Handler - Bonnys Fortune', () => {
 
       expect(bonusResult.success).toBe(true);
 
-      for (const step of bonusResult.outcome.results) {
+      for (const step of getTreasureResults(bonusResult)) {
         expect(step.result.multiplier).toBeDefined();
         expect(step.result.multiplier).toBeGreaterThan(0);
       }
@@ -212,7 +224,7 @@ describe('Treasure Hunt Handler - Bonnys Fortune', () => {
       expect(bonusResult.success).toBe(true);
 
       const finalStep =
-        bonusResult.outcome.results[bonusResult.outcome.results.length - 1];
+        getTreasureResults(bonusResult)[getTreasureResults(bonusResult).length - 1];
       // Final step should have winningMultiplier (0 if no win, >0 if win)
       expect(finalStep.result.winningMultiplier).toBeDefined();
       expect(typeof finalStep.result.winningMultiplier).toBe('number');
@@ -242,7 +254,7 @@ describe('Treasure Hunt Handler - Bonnys Fortune', () => {
 
       expect(bonusResult.success).toBe(true);
       // When RNG returns 0, weighted draw should select first eligible jackpot
-      expect(bonusResult.outcome.results).toBeDefined();
+      expect(getTreasureResults(bonusResult)).toBeDefined();
     });
   });
 
@@ -274,7 +286,7 @@ describe('Treasure Hunt Handler - Bonnys Fortune', () => {
       expect(bonusResult.success).toBe(true);
 
       // Step 3: Verify all steps completed
-      expect(bonusResult.outcome?.results?.length).toBeGreaterThan(0);
+      expect(getTreasureResults(bonusResult).length).toBeGreaterThan(0);
 
       // Step 4: Extract final payout
       const finalState = extractFinalBonusState(bonusResult);
@@ -308,7 +320,7 @@ describe('Treasure Hunt Handler - Bonnys Fortune', () => {
       expect(bonusResult.success).toBe(true);
 
       // Total winning across all steps should be consistent
-      const results = bonusResult.outcome.results;
+      const results = getTreasureResults(bonusResult);
       const finalStep = results[results.length - 1];
       expect(finalStep.result.playerWinning).toBeGreaterThanOrEqual(0);
     });
@@ -355,7 +367,7 @@ describe('Treasure Hunt Handler - Bonnys Fortune', () => {
 
       expect(bonusResult.success).toBe(true);
 
-      const results = bonusResult.outcome.results;
+      const results = getTreasureResults(bonusResult);
       expect(results.length).toBeGreaterThan(0);
 
       // Verify sequential step progression
@@ -394,7 +406,7 @@ describe('Treasure Hunt Handler - Bonnys Fortune', () => {
       expect(bonusResult.success).toBe(true);
 
       const finalStep =
-        bonusResult.outcome.results[bonusResult.outcome.results.length - 1];
+        getTreasureResults(bonusResult)[getTreasureResults(bonusResult).length - 1];
       // winningCount is 3 if player won (3-of-a-kind), 0 otherwise
       expect([0, 3]).toContain(finalStep.result.winningCount);
     });
@@ -423,7 +435,7 @@ describe('Treasure Hunt Handler - Bonnys Fortune', () => {
       expect(bonusResult.success).toBe(true);
 
       const finalStep =
-        bonusResult.outcome.results[bonusResult.outcome.results.length - 1];
+        getTreasureResults(bonusResult)[getTreasureResults(bonusResult).length - 1];
       expect(finalStep.result.totalMultiplier).toBeDefined();
       expect(typeof finalStep.result.totalMultiplier).toBe('number');
     });
@@ -508,8 +520,9 @@ describe('Treasure Hunt Handler - Bonnys Fortune', () => {
       expect(bonusResult.success).toBe(true);
 
       // Sum all playerWinning values
-      const totalWinning = bonusResult.outcome.results.reduce(
-        (sum: number, step: any) => sum + step.result.playerWinning,
+      const bonusOutcome2 = bonusResult.outcome as unknown as BonusRoundResult<TreasureHuntSpinResult>;
+      const totalWinning = bonusOutcome2.results.reduce(
+        (sum: number, step: SpinResultResponse<TreasureHuntSpinResult>) => sum + step.result.playerWinning,
         0,
       );
       expect(totalWinning).toBeGreaterThanOrEqual(0);
@@ -544,7 +557,7 @@ describe('Treasure Hunt Handler - Bonnys Fortune', () => {
 
   describe('RNG Determinism', () => {
     it('should produce consistent results with same LCG seed', async () => {
-      const results: any[] = [];
+      const results: SpinResultResponse<TreasureHuntSpinResult>[][] = [];
 
       for (let i = 0; i < 2; i++) {
         const { engine } = createEngineWithLcgRng(54321);
@@ -567,14 +580,15 @@ describe('Treasure Hunt Handler - Bonnys Fortune', () => {
           bonus.bonusType,
         );
 
-        results.push(bonusResult.outcome.results);
+        const bonusOutcome3 = bonusResult.outcome as unknown as BonusRoundResult<TreasureHuntSpinResult>;
+        results.push(bonusOutcome3.results);
         resetCommandIdCounter();
       }
 
       expect(results.length).toBe(2);
       // Same seed should produce identical selections
-      const selections1 = results[0].map((r: any) => r.result.selection);
-      const selections2 = results[1].map((r: any) => r.result.selection);
+      const selections1 = results[0].map((r) => r.result.selection);
+      const selections2 = results[1].map((r) => r.result.selection);
       expect(selections1).toEqual(selections2);
     });
   });