Fix: player session never recovers when server resets

frontend/src/app/core/credentials.service.spec.ts

@@ -1,4 +1,8 @@
-import { readCookie } from './credentials.service';
+import { DOCUMENT } from '@angular/common';
+import { TestBed } from '@angular/core/testing';
+
+import { PAC_WINDOW } from './browser-window.token';
+import { CredentialsService, readCookie } from './credentials.service';
 
 describe('readCookie', () => {
   it('reads and decodes an exact cookie name', () => {
@@ -10,3 +14,50 @@ describe('readCookie', () => {
     expect(readCookie('theme=dark', 'id')).toBe('');
   });
 });
+
+describe('CredentialsService', () => {
+  let service: CredentialsService;
+  let mockDocument: { cookie: string };
+  let mockWindow: { location: { protocol: string } };
+
+  beforeEach(() => {
+    mockDocument = { cookie: '' };
+    mockWindow = { location: { protocol: 'http:' } };
+
+    TestBed.configureTestingModule({
+      providers: [
+        CredentialsService,
+        { provide: DOCUMENT, useValue: mockDocument },
+        { provide: PAC_WINDOW, useValue: mockWindow },
+      ],
+    });
+    service = TestBed.inject(CredentialsService);
+  });
+
+  it.each(['http:', 'https:'] as const)('expires the id cookie over %s', (protocol) => {
+    mockWindow.location.protocol = protocol;
+    mockDocument.cookie = 'id=ABC; theme=dark';
+
+    service.clear();
+
+    const secure = protocol === 'https:' ? '; Secure' : '';
+    expect(mockDocument.cookie).toBe(`id=; Path=/; SameSite=Lax${secure}; Max-Age=0`);
+  });
+
+  it('leaves the cookie untouched when PAC_WINDOW is null', () => {
+    TestBed.resetTestingModule();
+    TestBed.configureTestingModule({
+      providers: [
+        CredentialsService,
+        { provide: DOCUMENT, useValue: mockDocument },
+        { provide: PAC_WINDOW, useValue: null },
+      ],
+    });
+    service = TestBed.inject(CredentialsService);
+    mockDocument.cookie = 'id=ABC';
+
+    service.clear();
+
+    expect(mockDocument.cookie).toBe('id=ABC');
+  });
+});

frontend/src/app/core/credentials.service.ts

@@ -47,4 +47,13 @@ export class CredentialsService {
     const attributes = `; Path=/; SameSite=Lax${secure}`;
     this.document.cookie = `id=${encodeURIComponent(credentials.id)}${attributes}`;
   }
+
+  clear(): void {
+    if (!this.browserWindow) {
+      return;
+    }
+
+    const secure = this.browserWindow.location.protocol === 'https:' ? '; Secure' : '';
+    this.document.cookie = `id=; Path=/; SameSite=Lax${secure}; Max-Age=0`;
+  }
 }

frontend/src/app/core/player-name.service.spec.ts

@@ -0,0 +1,79 @@
+import { TestBed } from '@angular/core/testing';
+
+import { PAC_WINDOW } from './browser-window.token';
+import { PlayerNameService } from './player-name.service';
+
+describe('PlayerNameService', () => {
+  let service: PlayerNameService;
+  let mockStorage: Record<string, string>;
+
+  beforeEach(() => {
+    mockStorage = {};
+    const mockWindow = {
+      localStorage: {
+        getItem: (key: string) => mockStorage[key] ?? null,
+        setItem: (key: string, value: string) => {
+          mockStorage[key] = value;
+        },
+      },
+    };
+
+    TestBed.configureTestingModule({
+      providers: [PlayerNameService, { provide: PAC_WINDOW, useValue: mockWindow }],
+    });
+    service = TestBed.inject(PlayerNameService);
+  });
+
+  it('returns an empty string when no name has been saved', () => {
+    expect(service.get()).toBe('');
+  });
+
+  it('saves and retrieves a player name', () => {
+    service.save('Odin');
+    expect(service.get()).toBe('Odin');
+  });
+
+  it('returns an empty string when localStorage throws on get', () => {
+    TestBed.resetTestingModule();
+    const throwingWindow = {
+      localStorage: {
+        getItem: () => {
+          throw new Error('unavailable');
+        },
+        setItem: () => {},
+      },
+    };
+    TestBed.configureTestingModule({
+      providers: [PlayerNameService, { provide: PAC_WINDOW, useValue: throwingWindow }],
+    });
+    service = TestBed.inject(PlayerNameService);
+    expect(service.get()).toBe('');
+  });
+
+  it('silently ignores localStorage errors on save', () => {
+    TestBed.resetTestingModule();
+    const throwingWindow = {
+      localStorage: {
+        getItem: () => null,
+        setItem: () => {
+          throw new Error('quota exceeded');
+        },
+      },
+    };
+    TestBed.configureTestingModule({
+      providers: [PlayerNameService, { provide: PAC_WINDOW, useValue: throwingWindow }],
+    });
+    service = TestBed.inject(PlayerNameService);
+    expect(() => service.save('Odin')).not.toThrow();
+  });
+
+  it('returns an empty string when PAC_WINDOW is null', () => {
+    TestBed.resetTestingModule();
+    TestBed.configureTestingModule({
+      providers: [PlayerNameService, { provide: PAC_WINDOW, useValue: null }],
+    });
+    service = TestBed.inject(PlayerNameService);
+    expect(service.get()).toBe('');
+    expect(() => service.save('Odin')).not.toThrow();
+  });
+});

frontend/src/app/core/player-name.service.ts

@@ -0,0 +1,26 @@
+import { inject, Service, signal } from '@angular/core';
+import { PAC_WINDOW } from './browser-window.token';
+
+const PLAYER_NAME_KEY = 'playerName';
+
+@Service()
+export class PlayerNameService {
+  private readonly browserWindow = inject(PAC_WINDOW);
+  private readonly statusMessage = signal<string | null>(null);
+
+  get(): string {
+    try {
+      return this.browserWindow?.localStorage.getItem(PLAYER_NAME_KEY) ?? '';
+    } catch {
+      return '';
+    }
+  }
+
+  save(name: string): void {
+    try {
+      this.browserWindow?.localStorage.setItem(PLAYER_NAME_KEY, name);
+    } catch {
+      this.statusMessage.set('Could not save your name for auto-re-registration.');
+    }
+  }
+}

frontend/src/app/core/sockets/game-socket.service.spec.ts

@@ -297,4 +297,118 @@ describe('GameSocketService', () => {
     expect(service.state()).toBe('error');
     expect(service.status()).toContain('Register as admin again in this browser');
   });
+
+  it('expires the session after three consecutive failed player connections', () => {
+    vi.useFakeTimers();
+    vi.spyOn(console, 'log').mockImplementation(() => undefined);
+    vi.spyOn(console, 'warn').mockImplementation(() => undefined);
+    const onSessionExpired = vi.fn();
+    service.start('ABCD', () => undefined, onSessionExpired);
+
+    MockGameWebSocket.instances[0].serverClose(false);
+    vi.advanceTimersByTime(1000);
+    MockGameWebSocket.instances[1].serverClose(false);
+    vi.advanceTimersByTime(2000);
+    MockGameWebSocket.instances[2].serverClose(false);
+    vi.runAllTimers();
+
+    expect(service.sessionExpired()).toBe(true);
+    expect(service.state()).toBe('error');
+    expect(service.status()).toContain('Session has expired as game server restarted.');
+    expect(MockGameWebSocket.instances).toHaveLength(3);
+    expect(onSessionExpired).toHaveBeenCalledOnce();
+  });
+
+  it('does not invoke the session-expired callback after fewer than three failures', () => {
+    vi.useFakeTimers();
+    vi.spyOn(console, 'log').mockImplementation(() => undefined);
+    vi.spyOn(console, 'warn').mockImplementation(() => undefined);
+    const onSessionExpired = vi.fn();
+    service.start('ABCD', () => undefined, onSessionExpired);
+
+    MockGameWebSocket.instances[0].serverClose(false);
+    vi.advanceTimersByTime(1000);
+    MockGameWebSocket.instances[1].serverClose(false);
+    vi.advanceTimersByTime(2000);
+
+    expect(service.sessionExpired()).toBe(false);
+    expect(onSessionExpired).not.toHaveBeenCalled();
+  });
+
+  it('keeps reconnecting a player socket after fewer than three failures', () => {
+    vi.useFakeTimers();
+    vi.spyOn(console, 'log').mockImplementation(() => undefined);
+    vi.spyOn(console, 'warn').mockImplementation(() => undefined);
+    service.start('ABCD', () => undefined);
+
+    MockGameWebSocket.instances[0].serverClose(false);
+    vi.advanceTimersByTime(1000);
+    MockGameWebSocket.instances[1].serverClose(false);
+    vi.advanceTimersByTime(2000);
+
+    expect(service.sessionExpired()).toBe(false);
+    expect(service.state()).toBe('connecting');
+    expect(MockGameWebSocket.instances).toHaveLength(3);
+  });
+
+  it('resets the failure counter when a player connection succeeds', () => {
+    vi.useFakeTimers();
+    vi.spyOn(console, 'log').mockImplementation(() => undefined);
+    vi.spyOn(console, 'warn').mockImplementation(() => undefined);
+    service.start('ABCD', () => undefined);
+
+    MockGameWebSocket.instances[0].serverClose(false);
+    vi.advanceTimersByTime(1000);
+    MockGameWebSocket.instances[1].serverClose(false);
+    vi.advanceTimersByTime(2000);
+
+    MockGameWebSocket.instances[2].open();
+    MockGameWebSocket.instances[2].serverClose(false);
+    vi.advanceTimersByTime(4000);
+    MockGameWebSocket.instances[3].serverClose(false);
+    vi.runAllTimers();
+
+    expect(service.sessionExpired()).toBe(false);
+    expect(MockGameWebSocket.instances).toHaveLength(5);
+  });
+
+  it('never expires the session for a viewer socket', () => {
+    vi.useFakeTimers();
+    vi.spyOn(console, 'log').mockImplementation(() => undefined);
+    vi.spyOn(console, 'warn').mockImplementation(() => undefined);
+    service.startViewer();
+
+    MockGameWebSocket.instances[0].serverClose(false);
+    vi.advanceTimersByTime(1000);
+    MockGameWebSocket.instances[1].serverClose(false);
+    vi.advanceTimersByTime(2000);
+    MockGameWebSocket.instances[2].serverClose(false);
+    vi.runAllTimers();
+
+    expect(service.sessionExpired()).toBe(false);
+    expect(MockGameWebSocket.instances.length).toBeGreaterThan(3);
+  });
+
+  it('start and stop clear an expired session', () => {
+    vi.useFakeTimers();
+    vi.spyOn(console, 'log').mockImplementation(() => undefined);
+    vi.spyOn(console, 'warn').mockImplementation(() => undefined);
+    service.start('ABCD', () => undefined);
+
+    MockGameWebSocket.instances[0].serverClose(false);
+    vi.advanceTimersByTime(1000);
+    MockGameWebSocket.instances[1].serverClose(false);
+    vi.advanceTimersByTime(2000);
+    MockGameWebSocket.instances[2].serverClose(false);
+    vi.runAllTimers();
+
+    expect(service.sessionExpired()).toBe(true);
+
+    service.stop();
+    expect(service.sessionExpired()).toBe(false);
+
+    service.start('ABCD', () => undefined);
+    expect(service.sessionExpired()).toBe(false);
+    expect(MockGameWebSocket.instances).toHaveLength(4);
+  });
 });

frontend/src/app/core/sockets/game-socket.service.ts

@@ -29,18 +29,25 @@ export class GameSocketService extends WebSocketService<GameSocketMessage> {
   private playerId: string | null = null;
   private mode: SocketMode | null = null;
   private onConnected: (() => void) | null = null;
+  private onSessionExpired: (() => void) | null = null;
   private reconnecting = false;
   private suspendedReason = 'Paused while the browser is offline.';
+  private consecutiveFailures = 0;
   private readonly statusMessage = signal<string | null>(null);
 
   readonly players = signal<Record<string, LivePlayer>>({});
   readonly isFlagFound = signal(false);
+  readonly sessionExpired = signal(false);
+  readonly MAX_FAILED_ATTEMPTS = 3;
 
-  start(id: string, onConnected: () => void): void {
+  start(id: string, onConnected: () => void, onSessionExpired: () => void = () => undefined): void {
     this.stop();
     this.mode = 'player';
     this.playerId = id;
     this.onConnected = onConnected;
+    this.onSessionExpired = onSessionExpired;
+    this.consecutiveFailures = 0;
+    this.sessionExpired.set(false);
     this.resume();
   }
 
@@ -72,8 +79,11 @@ export class GameSocketService extends WebSocketService<GameSocketMessage> {
     this.mode = null;
     this.playerId = null;
     this.onConnected = null;
+    this.onSessionExpired = null;
     this.reconnecting = false;
     this.statusMessage.set(null);
+    this.consecutiveFailures = 0;
+    this.sessionExpired.set(false);
     this.disconnect();
   }
 
@@ -96,13 +106,33 @@ export class GameSocketService extends WebSocketService<GameSocketMessage> {
     this.players.set({});
     this.reconnecting = false;
     this.statusMessage.set(null);
+    this.consecutiveFailures = 0;
     this.onConnected?.();
   }
 
   protected override onSocketClose(): void {
     this.reconnecting = true;
   }
 
+  protected override shouldReconnect(closeEvent: CloseEvent): boolean {
+    if (this.mode !== 'player') {
+      return true;
+    }
+
+    this.consecutiveFailures++;
+
+    if (this.consecutiveFailures >= this.MAX_FAILED_ATTEMPTS) {
+      this.sessionExpired.set(true);
+      this.statusMessage.set(
+        'Session has expired as game server restarted.',
+      );
+      this.onSessionExpired?.();
+      return false; 
+    }
+
+    return true; 
+  }
+
   protected override onSocketError(): void {
     this.statusMessage.set(
       this.mode === 'viewer'