import { assertBet, assertBoard, evaluate } from './SlotsMath'; import type { SpinResult } from './SlotsMath'; import type { GameState } from './GameSession'; export interface GameStorage { getItem(key: string): string | null; setItem(key: string, value: string): void; } interface Snapshot { revision: number; state: GameState; } /** Shared across repository instances, including writes reentered from a storage adapter. */ const writing = new WeakMap>(); function requireValue(condition: unknown, message: string): asserts condition { if (!condition) throw new Error(`Invalid game snapshot: ${message}`); } function record(value: unknown): value is Record { return typeof value === 'object' && value !== null && !Array.isArray(value); } function coins(value: unknown): value is number { return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0; } function validDay(value: unknown): boolean { if (value === null) return true; if (typeof value !== 'string' || !/^\d{4}-\d{2}-\d{2}$/.test(value)) return false; const time = new Date(`${value}T00:00:00.000Z`); return Number.isFinite(time.getTime()) && time.toISOString().slice(0, 10) === value; } function validateResult(value: unknown, bet: number, free: boolean): asserts value is SpinResult { requireValue(record(value), 'missing spin result'); assertBoard(value.board); const expected = evaluate(value.board, bet); requireValue(value.win === expected.win && value.scatters === expected.scatters, 'incorrect spin award or scatter count'); requireValue(value.awarded === (free ? 0 : expected.awarded), 'incorrect free-spin award'); requireValue(Array.isArray(value.wins) && value.wins.length === expected.wins.length, 'incorrect winning lines'); for (let index = 0; index < expected.wins.length; index++) { const actual: unknown = value.wins[index]; const award = expected.wins[index]; requireValue(record(actual) && actual.line === award.line && actual.count === award.count && actual.symbol === award.symbol && actual.amount === award.amount, 'incorrect line award'); } if (free) { const column = value.wildColumn; requireValue(typeof column === 'number' && Number.isInteger(column) && column >= 0 && column < 5, 'invalid wild column'); requireValue(value.board[column].every(symbol => symbol === 'wild' || symbol === 'scatter'), 'unconverted free-spin column'); } else { requireValue(value.wildColumn === null, 'ordinary spin has a wild column'); } } function validateState(value: unknown): asserts value is GameState { requireValue(record(value), 'state is not an object'); requireValue(value.version === 1, 'unsupported version'); requireValue(coins(value.balance) && coins(value.lastWin) && coins(value.sequence), 'invalid coin amount or sequence'); assertBet(value.bet); assertBoard(value.board); requireValue(validDay(value.lastClaimDay), 'invalid claim day'); requireValue(record(value.settings) && typeof value.settings.music === 'boolean' && typeof value.settings.sound === 'boolean' && typeof value.settings.vibration === 'boolean', 'invalid preferences'); requireValue(['idle', 'spinning', 'free-trigger', 'free-ready', 'free-result'].includes(value.phase as string), 'unknown phase'); const free = value.free; requireValue(free === null || record(free), 'invalid free-spin state'); if (free !== null) { requireValue(typeof free.awarded === 'number' && [8, 12, 16].includes(free.awarded), 'invalid awarded spin count'); requireValue(coins(free.remaining) && free.remaining <= free.awarded && coins(free.total), 'invalid remaining spins or free total'); assertBet(free.bet); requireValue(free.bet === value.bet, 'free-spin bet is not locked'); if (free.remaining === free.awarded) requireValue(free.total === 0, 'unplayed free spins have winnings'); } const pending = value.pending; requireValue(pending === null || record(pending), 'invalid pending state'); requireValue((value.phase === 'spinning') === (pending !== null), 'phase and pending result disagree'); if (pending !== null) { requireValue(coins(pending.id) && pending.id > 0 && pending.id === value.sequence, 'invalid pending identifier'); requireValue(typeof pending.free === 'boolean', 'invalid pending round type'); validateResult(pending.result, value.bet, pending.free); requireValue(JSON.stringify(value.board) === JSON.stringify(pending.result.board), 'pending board differs from displayed board'); requireValue(value.lastWin === pending.result.win && value.balance >= pending.result.win, 'pending award is not settled'); if (pending.free) { requireValue(free !== null && (free.remaining as number) < (free.awarded as number) && (free.total as number) >= pending.result.win, 'pending free spin has invalid counters'); } else if (pending.result.awarded > 0) { requireValue(free !== null && free.awarded === pending.result.awarded && free.remaining === free.awarded && free.total === 0, 'missing free-spin trigger'); } else { requireValue(free === null, 'ordinary round retains unrelated free spins'); } } switch (value.phase) { case 'idle': requireValue(free === null, 'idle phase retains free spins'); break; case 'free-trigger': requireValue(free !== null && free.remaining === free.awarded && free.total === 0, 'invalid free-spin trigger'); break; case 'free-ready': requireValue(free !== null && (free.remaining as number) > 0, 'no free spins to start'); break; case 'free-result': requireValue(free !== null && free.remaining === 0, 'free-spin result has unfinished rounds'); break; } } function decode(raw: string): Snapshot { const value: unknown = JSON.parse(raw); requireValue(record(value) && coins(value.revision) && value.revision > 0, 'invalid snapshot revision'); validateState(value.state); return { revision: value.revision, state: value.state }; } /** * One JSON value per scope. A revision and exact observed bytes reject stale writers. * Readback failure leaves the commit uncertain: never roll back or grant a new balance. * Callers must reload after a conflict or uncertain write. Synchronous storage has no * cross-process compare-and-swap; the shared lock additionally protects same-page reentry. */ export class GameRepository { private readonly key: string; private loaded = false; private observed: string | null = null; private revision = 0; constructor(private readonly storage: GameStorage, scope: string) { if (storage === null || typeof storage !== 'object' || typeof storage.getItem !== 'function' || typeof storage.setItem !== 'function') throw new Error('Storage is unavailable'); if (typeof scope !== 'string' || scope.trim().length === 0) throw new Error('A game storage scope is required'); this.key = `fruit-pop:game:v1:${encodeURIComponent(scope)}`; } load(): GameState | null { const raw = this.storage.getItem(this.key); if (raw !== null && typeof raw !== 'string') throw new Error('Storage returned an invalid value'); const snapshot = raw === null ? null : decode(raw); this.observed = raw; this.revision = snapshot === null ? 0 : snapshot.revision; this.loaded = true; // Parsing created fresh arrays and objects; nothing exposed is retained internally. return snapshot === null ? null : snapshot.state; } save(state: GameState): void { validateState(state); let locks = writing.get(this.storage); if (locks === undefined) { locks = new Set(); writing.set(this.storage, locks); } if (locks.has(this.key)) throw new Error('A write for this game scope is already in progress'); locks.add(this.key); try { if (!this.loaded) this.load(); if (this.storage.getItem(this.key) !== this.observed) throw new Error('Stale game snapshot; reload before retrying'); const revision = this.revision + 1; if (!Number.isSafeInteger(revision)) throw new Error('Snapshot revision exhausted'); const raw = JSON.stringify({ revision, state }); // Validate the serialized representation as well, before any storage mutation. decode(raw); this.storage.setItem(this.key, raw); if (this.storage.getItem(this.key) !== raw) throw new Error('Game snapshot readback verification failed'); this.observed = raw; this.revision = revision; } finally { locks.delete(this.key); } } }