import { readFileSync } from 'node:fs';
import assert from 'node:assert/strict';
import { test } from 'node:test';
import type { RuntimeConfig } from '../../YouleNexus/assets/framework/config/runtime-config.ts';
import type { OutboundEnvelope } from '../../YouleNexus/assets/framework/core/types/envelope.ts';
import type { Clock } from '../../YouleNexus/assets/framework/net/heartbeat.ts';
import type { WireEvent } from '../../YouleNexus/assets/framework/net/wire-client.ts';
import { Router } from '../../YouleNexus/assets/framework/protocol/router.ts';
import type {
  GameEntry,
  GameHost,
  GameModule,
  PlatformToGameEvent,
} from '../../YouleNexus/assets/framework/sdk/contracts/index.ts';
import {
  PlatformRuntime,
  type PlatformWireClient,
} from '../../YouleNexus/assets/framework/platform/runtime.ts';
import type { ScenePort } from '../../YouleNexus/assets/framework/platform/scene-port.ts';
import { PlatformStore } from '../../YouleNexus/assets/framework/platform/stores/platform-store.ts';
import { PlatformUiController } from '../../YouleNexus/assets/framework/presentation/platform-ui-controller.ts';

function fixture(name: string): Record<string, unknown> {
  return JSON.parse(
    readFileSync(new URL(`../fixtures/contracts/${name}`, import.meta.url), 'utf8'),
  ).data;
}

const ACCOUNT = Object.freeze({
  openid: 'o1',
  nickname: '测试号',
  avatar: 'http://a',
  sex: 0,
  province: '江西',
  city: '南昌',
  unionid: 'test_unionid',
});

const DEVICE = Object.freeze({
  ip: '127.0.0.1',
  location: Object.freeze({ latitude: 1, longitude: 2 }),
  machineid: 'machine-1',
  machineroom: 'room-install-1',
  deviceLogin: Object.freeze({ enabled: false as const }),
  loginPlayerId: Object.freeze({ enabled: false as const }),
});

function runtimeConfig(gameid: string | number = '41'): RuntimeConfig {
  return Object.freeze({
    mode: 'debug',
    isDebugger: true,
    identity: Object.freeze({
      agentid: 'veRa0qrBf',
      channelid: 'FtJf073aa',
      gameid,
      marketid: 4,
      version: 10000,
    }),
    servers: Object.freeze(['ws://agent']),
    source: 'direct',
    gameserver: null,
    rawConfig: null,
  }) as RuntimeConfig;
}

interface Deferred<T> {
  readonly promise: Promise<T>;
  resolve(value: T): void;
  reject(error: unknown): void;
}

function deferred<T>(): Deferred<T> {
  let resolvePromise!: (value: T) => void;
  let rejectPromise!: (error: unknown) => void;
  const promise = new Promise<T>((resolve, reject) => {
    resolvePromise = resolve;
    rejectPromise = reject;
  });
  return { promise, resolve: resolvePromise, reject: rejectPromise };
}

function rejectedValue(promise: Promise<unknown>): Promise<unknown> {
  return promise.then(
    () => { throw new Error('Expected promise to reject'); },
    (error: unknown) => error,
  );
}

function thrownValue(operation: () => void): unknown {
  let didThrow = false;
  let thrown: unknown;
  try {
    operation();
  } catch (error) {
    didThrow = true;
    thrown = error;
  }
  assert.equal(didThrow, true, 'Expected operation to throw');
  return thrown;
}

class ManualClock implements Clock {
  private nextHandle = 1;
  readonly timers = new Map<number, { readonly fn: () => void; readonly ms: number }>();

  setTimeout(fn: () => void, ms: number): unknown {
    const handle = this.nextHandle;
    this.nextHandle += 1;
    this.timers.set(handle, { fn, ms });
    return handle;
  }

  clearTimeout(handle: unknown): void {
    this.timers.delete(handle as number);
  }

  runOnlyTimer(): void {
    assert.equal(this.timers.size, 1);
    const [handle, timer] = [...this.timers.entries()][0]!;
    this.timers.delete(handle);
    timer.fn();
  }
}

class ControlledClearClock extends ManualClock {
  private failureEnabled = false;
  private failure: unknown;
  onFailingClear: () => void = () => {};

  enableClearFailure(error: unknown): void {
    this.failure = error;
    this.failureEnabled = true;
  }

  clearTimeout(handle: unknown): void {
    super.clearTimeout(handle);
    if (!this.failureEnabled) return;
    this.onFailingClear();
    throw this.failure;
  }
}

class RecordingWireClient implements PlatformWireClient {
  readonly sent: OutboundEnvelope[] = [];
  readonly switchCalls: string[] = [];
  readonly lifecycle: string[] = [];
  reconnectCalls = 0;
  stopCalls = 0;
  onAction: (name: string) => void = () => {};
  private readonly listeners = new Set<(event: WireEvent) => void>();

  subscribe(listener: (event: WireEvent) => void): () => void {
    this.lifecycle.push('subscribe');
    this.onAction('subscribe');
    this.listeners.add(listener);
    return () => {
      this.lifecycle.push('unsubscribe');
      this.onAction('unsubscribe');
      this.listeners.delete(listener);
    };
  }

  start(): void {
    this.lifecycle.push('start');
    this.onAction('start');
  }

  send(envelope: OutboundEnvelope): void {
    this.sent.push(envelope);
  }

  switchServer(target: string): void {
    this.switchCalls.push(target);
  }

  reconnectCurrent(): void {
    this.reconnectCalls += 1;
  }

  stop(): void {
    this.stopCalls += 1;
    this.lifecycle.push('stop');
    this.onAction('stop');
  }

  emit(event: WireEvent): void {
    for (const listener of [...this.listeners]) listener(event);
  }
}

class SynchronousSubscribeWireClient implements PlatformWireClient {
  readonly sent: OutboundEnvelope[] = [];
  readonly switchCalls: string[] = [];
  startCalls = 0;
  stopCalls = 0;
  unsubscribeCalls = 0;
  private listener: ((event: WireEvent) => void) | null = null;

  constructor(
    private readonly subscribeEvent: WireEvent,
    private readonly unsubscribeFailure?: { readonly value: unknown },
  ) {}

  subscribe(listener: (event: WireEvent) => void): () => void {
    this.listener = listener;
    listener(this.subscribeEvent);
    return () => {
      this.unsubscribeCalls += 1;
      this.listener = null;
      if (this.unsubscribeFailure !== undefined) throw this.unsubscribeFailure.value;
    };
  }

  start(): void {
    this.startCalls += 1;
  }

  send(envelope: OutboundEnvelope): void {
    this.sent.push(envelope);
  }

  switchServer(target: string): void {
    this.switchCalls.push(target);
  }

  reconnectCurrent(): void {}

  stop(): void {
    this.stopCalls += 1;
  }

  emit(event: WireEvent): void {
    this.listener?.(event);
  }

  get listenerAttached(): boolean {
    return this.listener !== null;
  }
}

class InvalidSubscribeWireClient extends RecordingWireClient {
  constructor(private readonly invalidUnsubscribe: unknown) {
    super();
  }

  override subscribe(_listener: (event: WireEvent) => void): () => void {
    this.lifecycle.push('subscribe');
    this.onAction('subscribe');
    return this.invalidUnsubscribe as () => void;
  }
}

class RecordingScene implements ScenePort {
  readonly calls: Array<{ readonly name: string; readonly value?: unknown }> = [];
  onCall: (name: string, value?: unknown) => void = () => {};
  private record(name: string, value?: unknown): void {
    this.calls.push(value === undefined ? { name } : { name, value });
    this.onCall(name, value);
  }
  showLoading(): void { this.record('loading'); }
  showLogin(): void { this.record('login'); }
  showLobby(): void { this.record('lobby'); }
  showRoom(): void { this.record('room'); }
  showReconnect(): void { this.record('reconnect'); }
  showKicked(data: unknown): void { this.record('kicked', data); }
  showServerDenial(outcome: unknown): void { this.record('denied', outcome); }
  showFatal(error: Error): void { this.record('fatal', error); }
}

function makeGameEntry(overrides: Partial<GameEntry> = {}): GameEntry {
  return {
    key: 'fixture',
    gameId: '41',
    route: 'fixture-game',
    resolveSeatCount: () => 4,
    createModule: (): GameModule => ({
      attach() {},
      handlePlatformEvent() {},
      handleGameMessage() {},
      restore() {},
      dispose() {},
    }),
    ...overrides,
  };
}

function makeRuntime(config: RuntimeConfig = runtimeConfig(), entry = makeGameEntry()) {
  const wire = new RecordingWireClient();
  const scene = new RecordingScene();
  const clock = new ManualClock();
  const factoryConfigs: RuntimeConfig[] = [];
  const runtime = new PlatformRuntime({
    gameEntry: entry,
    resolveRuntimeConfig: async () => config,
    createWireClient(resolved) {
      factoryConfigs.push(resolved);
      return wire;
    },
    scene,
    loadResources: async () => {},
    waitForMinimumDisplay: async () => {},
    getLoginDeviceSnapshot: () => DEVICE,
    clock,
  });
  return { runtime, wire, scene, clock, factoryConfigs, config };
}

test('UI observes canonical commits and unsubscribe is idempotent', async () => {
  const { runtime, wire } = makeRuntime();
  const seen: unknown[] = [];
  const off = runtime.subscribeState(
    state => { seen.push(state); },
    error => { throw error; },
  );
  assert.equal(seen.length, 0);
  await runtime.start();
  wire.emit({ type: 'open', server: 'ws://agent' });
  assert.equal(seen[seen.length - 1], runtime.state);
  off();
  off();
  const count = seen.length;
  runtime.login(ACCOUNT);
  wire.emit({ type: 'message', message: {
    route: 'agent', rpc: 'player_login', data: fixture('player-login-success.json'),
  } });
  assert.equal(seen.length, count);
  runtime.stop();
  assert.throws(() => runtime.subscribeState(() => {}, () => {}), /stopped/);
});

test('a failing UI observer reports its original error once while other observers continue', async () => {
  const { runtime, wire } = makeRuntime();
  const failure = { source: 'render' };
  const reported: unknown[] = [];
  let failingCalls = 0;
  const healthyStates: unknown[] = [];
  runtime.subscribeState(
    () => {
      failingCalls += 1;
      throw failure;
    },
    error => { reported.push(error); },
  );
  runtime.subscribeState(
    state => { healthyStates.push(state); },
    error => { throw error; },
  );

  await runtime.start();
  wire.emit({ type: 'open', server: 'ws://agent' });

  assert.equal(failingCalls, 1);
  assert.deepEqual(reported, [failure]);
  assert.equal(reported[0], failure);
  assert.equal(healthyStates[0], runtime.state);

  runtime.login(ACCOUNT);
  wire.emit({ type: 'message', message: {
    route: 'agent', rpc: 'player_login', data: fixture('player-login-success.json'),
  } });
  assert.equal(failingCalls, 1);
  assert.equal(healthyStates[healthyStates.length - 1], runtime.state);
  runtime.stop();
});

test('an onError failure enters fatal with both UI error identities and cancels observers', async () => {
  const { runtime, wire, scene } = makeRuntime();
  const listenerFailure = { source: 'listener' };
  const onErrorFailure = { source: 'onError' };
  let laterObserverCalls = 0;
  runtime.subscribeState(
    () => { throw listenerFailure; },
    () => { throw onErrorFailure; },
  );
  runtime.subscribeState(
    () => { laterObserverCalls += 1; },
    error => { throw error; },
  );
  await runtime.start();

  wire.emit({ type: 'open', server: 'ws://agent' });

  assert.equal(laterObserverCalls, 0);
  assert.equal(wire.stopCalls, 1);
  const fatal = scene.calls.find(call => call.name === 'fatal')?.value;
  assert.ok(fatal instanceof Error);
  const errors = (fatal as Error & { readonly errors: readonly unknown[] }).errors;
  assert.equal(errors.length, 2);
  assert.equal(errors[0], listenerFailure);
  assert.equal(errors[1], onErrorFailure);
  assert.throws(() => runtime.subscribeState(() => {}, () => {}), /fatal/);
});

for (const terminal of ['stop', 'fatal', 'kick'] as const) {
  test(`${terminal} invalidates a late Store delivery and rejects new UI observers`, async () => {
    const originalSubscribe = PlatformStore.prototype.subscribe;
    let retainedListener: Parameters<PlatformStore['subscribe']>[0] | null = null;
    PlatformStore.prototype.subscribe = function retainFirstListener(listener) {
      retainedListener ??= listener;
      return originalSubscribe.call(this, listener);
    };

    try {
      const setup = makeRuntime();
      let calls = 0;
      setup.runtime.subscribeState(
        () => { calls += 1; },
        error => { throw error; },
      );
      await setup.runtime.start();
      setup.wire.emit({ type: 'open', server: 'ws://agent' });
      const callsBeforeTermination = calls;
      setup.wire.onAction = (name) => {
        if (name !== 'stop') return;
        const listener = retainedListener;
        assert.ok(listener);
        listener(setup.runtime.state, setup.runtime.state);
      };

      if (terminal === 'stop') {
        setup.runtime.stop();
      } else if (terminal === 'fatal') {
        setup.scene.onCall = (name) => {
          if (name === 'reconnect') throw new Error('reconnect render failed');
        };
        setup.wire.emit({ type: 'slow' });
      } else {
        setup.runtime.login(ACCOUNT);
        setup.wire.emit({ type: 'message', message: {
          route: 'agent', rpc: 'kick_server', data: { code: 1, msg: 'terminal' },
        } });
      }

      assert.equal(
        calls,
        callsBeforeTermination + (terminal === 'fatal' ? 1 : 0),
        'observers must be inactive before terminal cleanup callbacks',
      );
      const callsAtTermination = calls;
      const lateListener = retainedListener as Parameters<PlatformStore['subscribe']>[0] | null;
      assert.ok(lateListener);
      lateListener(setup.runtime.state, setup.runtime.state);
      assert.equal(calls, callsAtTermination);
      assert.throws(
        () => setup.runtime.subscribeState(() => {}, () => {}),
        new RegExp(terminal === 'kick' ? 'kicked' : terminal),
      );
    } finally {
      PlatformStore.prototype.subscribe = originalSubscribe;
    }
  });
}

test('stop during a Store commit cancels later observers and prevents scene revival', async () => {
  const setup = makeRuntime();
  await setup.runtime.start();
  setup.wire.emit({ type: 'open', server: 'ws://agent' });
  let laterObserverCalls = 0;
  let resubscribeFailure: unknown;
  setup.runtime.subscribeState(
    () => {
      setup.runtime.stop();
      resubscribeFailure = thrownValue(
        () => setup.runtime.subscribeState(() => {}, () => {}),
      );
    },
    error => { throw error; },
  );
  setup.runtime.subscribeState(
    () => { laterObserverCalls += 1; },
    error => { throw error; },
  );
  const sceneCallsBefore = setup.scene.calls.length;

  setup.wire.emit({ type: 'slow' });

  assert.equal(laterObserverCalls, 0);
  assert.match(String(resubscribeFailure), /stopped/);
  assert.equal(setup.scene.calls.length, sceneCallsBefore);
  assert.equal(setup.wire.stopCalls, 1);
});

test('listener and onError failures after stopping escape the Store boundary without reviving fatal', async () => {
  const setup = makeRuntime();
  await setup.runtime.start();
  setup.wire.emit({ type: 'open', server: 'ws://agent' });
  const listenerFailure = { source: 'listener-after-stop' };
  const onErrorFailure = { source: 'onError-after-stop' };
  const reported: unknown[] = [];
  setup.runtime.subscribeState(
    () => {
      setup.runtime.stop();
      throw listenerFailure;
    },
    error => {
      reported.push(error);
      setup.runtime.stop();
      throw onErrorFailure;
    },
  );
  const sceneCallsBefore = setup.scene.calls.length;

  const thrown = thrownValue(() => { setup.wire.emit({ type: 'slow' }); });

  assert.deepEqual(reported, [listenerFailure]);
  assert.ok(thrown instanceof Error);
  const errors = (thrown as Error & { readonly errors: readonly unknown[] }).errors;
  assert.equal(errors.length, 2);
  assert.equal(errors[0], listenerFailure);
  assert.equal(errors[1], onErrorFailure);
  assert.equal(setup.scene.calls.length, sceneCallsBefore);
  assert.equal(setup.scene.calls.filter(call => call.name === 'fatal').length, 0);
  assert.equal(setup.wire.stopCalls, 1);
  assert.throws(() => setup.runtime.subscribeState(() => {}, () => {}), /stopped/);
});

test('stopped observer errors survive a later active-room publish failure', async () => {
  const setup = makeRuntime();
  await setup.runtime.start();
  setup.wire.emit({ type: 'open', server: 'ws://agent' });
  setup.runtime.login(ACCOUNT);
  const roomLogin = fixture('player-login-room.json');
  (roomLogin.players as unknown[])[2] = {
    playerid: 430512,
    nickname: '同桌玩家',
    avatar: 'http://b',
    sex: 0,
    bean: 10,
    isprepare: 0,
    onstate: 0,
  };
  setup.wire.emit({ type: 'message', message: {
    route: 'agent', rpc: 'player_login', data: roomLogin,
  } });
  const listenerFailure = { source: 'room-listener-after-stop' };
  const onErrorFailure = { source: 'room-onError-after-stop' };
  setup.runtime.subscribeState(
    () => {
      setup.runtime.stop();
      throw listenerFailure;
    },
    () => { throw onErrorFailure; },
  );

  const thrown = thrownValue(() => {
    setup.wire.emit({ type: 'message', message: {
      route: 'room', rpc: 'player_prepare', data: { seat: 2 },
    } });
  });

  assert.ok(thrown instanceof Error);
  const errors = (thrown as Error & { readonly errors: readonly unknown[] }).errors;
  assert.equal(errors.length, 2);
  const observerFailure = errors[0];
  assert.ok(observerFailure instanceof Error);
  const observerErrors = (
    observerFailure as Error & { readonly errors: readonly unknown[] }
  ).errors;
  assert.equal(observerErrors[0], listenerFailure);
  assert.equal(observerErrors[1], onErrorFailure);
  assert.match(String(errors[1]), /disposed game session/i);
  assert.equal(setup.scene.calls.filter(call => call.name === 'fatal').length, 0);
  assert.throws(() => setup.runtime.subscribeState(() => {}, () => {}), /stopped/);
});

test('UI observers receive each committed snapshot even when a listener commits reentrantly', async () => {
  const setup = makeRuntime();
  const delivered: unknown[] = [];
  let firstCommit: unknown;
  let latestDuringFirstCommit: unknown;
  let reentered = false;
  setup.runtime.subscribeState(
    state => {
      if (reentered) return;
      reentered = true;
      firstCommit = state;
      setup.wire.emit({ type: 'slow' });
      latestDuringFirstCommit = setup.runtime.state;
    },
    error => { throw error; },
  );
  setup.runtime.subscribeState(
    state => { delivered.push(state); },
    error => { throw error; },
  );
  await setup.runtime.start();

  setup.wire.emit({ type: 'open', server: 'ws://agent' });

  assert.notEqual(firstCommit, latestDuringFirstCommit);
  assert.equal(delivered[0], firstCommit);
  assert.equal(delivered[1], latestDuringFirstCommit);
  assert.deepEqual(
    delivered.map(state => (state as { app: { phase: string } }).app.phase),
    ['connected', 'slow'],
  );
  setup.runtime.stop();
});

test('cancelling and subscribing observers during a commit cannot alter that delivery snapshot', async () => {
  const setup = makeRuntime();
  let cancelledCalls = 0;
  const replacementPhases: string[] = [];
  let changedObservers = false;
  let offCancelled = (): void => {};
  setup.runtime.subscribeState(
    () => {
      if (changedObservers) return;
      changedObservers = true;
      offCancelled();
      setup.runtime.subscribeState(
        state => { replacementPhases.push(state.app.phase); },
        error => { throw error; },
      );
    },
    error => { throw error; },
  );
  offCancelled = setup.runtime.subscribeState(
    () => { cancelledCalls += 1; },
    error => { throw error; },
  );
  await setup.runtime.start();

  setup.wire.emit({ type: 'open', server: 'ws://agent' });
  assert.equal(cancelledCalls, 0);
  assert.deepEqual(replacementPhases, []);

  setup.wire.emit({ type: 'slow' });
  assert.equal(cancelledCalls, 0);
  assert.deepEqual(replacementPhases, ['slow']);
  setup.runtime.stop();
});

test('a denied join retains the lobby root, reports the raw outcome and permits a valid retry', async () => {
  const { runtime, wire, scene } = makeRuntime();
  await runtime.start();
  wire.emit({ type: 'open', server: 'ws://agent' });
  runtime.login(ACCOUNT);
  wire.emit({ type: 'message', message: {
    route: 'agent', rpc: 'player_login', data: fixture('player-login-success.json'),
  } });
  const lobby = runtime.state;
  const denial = { state: 99, roomcode: '999999', showerror: 1, error: 'Room does not exist' };
  runtime.joinRoom({ roomcode: '999999', location: null, ip: '127.0.0.1' });
  wire.emit({ type: 'message', message: { route: 'agent', rpc: 'self_join_room', data: denial } });

  assert.equal(runtime.state, lobby);
  assert.equal(wire.stopCalls, 0);
  assert.deepEqual(scene.calls.filter(call => call.name === 'fatal'), []);
  const outcome = scene.calls.find(call => call.name === 'denied')?.value;
  assert.deepEqual(outcome, { rpc: 'self_join_room', state: 99, data: denial });
  assert.equal((outcome as { data: unknown }).data, denial);

  runtime.joinRoom({ roomcode: '100001', location: null, ip: '127.0.0.1' });
  wire.emit({ type: 'message', message: {
    route: 'agent', rpc: 'self_join_room', data: fixture('self-join-room.json'),
  } });
  assert.equal(runtime.state.room.kind, 'inside');
  assert.equal(scene.calls[scene.calls.length - 1]?.name, 'room');
  runtime.stop();
});

test('runtime resolves seats only from the actual game-owned server roomtype at room entry', async () => {
  const roomtypes: Array<readonly unknown[]> = [];
  const attached: GameHost[] = [];
  const setup = makeRuntime(runtimeConfig(), makeGameEntry({
    resolveSeatCount(roomtype) {
      roomtypes.push(roomtype);
      if (roomtype.length !== 7 || roomtype[1] !== 4 || !Array.isArray(roomtype[5])) {
        throw new Error('Game roomtype requires the full nested server configuration');
      }
      return 4;
    },
    createModule: () => ({
      attach(host) { attached.push(host); },
      handlePlatformEvent() {}, handleGameMessage() {}, restore() {}, dispose() {},
    }),
  }));
  await setup.runtime.start();
  assert.deepEqual(roomtypes, []);
  setup.wire.emit({ type: 'open', server: 'ws://agent' });
  setup.wire.emit({ type: 'message', message: {
    route: 'agent', rpc: 'player_login', data: fixture('player-login-room.json'),
  } });
  assert.equal(roomtypes.length, 1);
  assert.equal(attached.length, 1);
  assert.equal(roomtypes[0], attached[0]!.getSnapshot().room.roomtype);
  assert.equal(attached[0]!.seat.toView(1), 0);
  assert.deepEqual(setup.scene.calls.filter(call => call.name === 'fatal'), []);
  setup.runtime.stop();
});

for (const count of [0, 2.5, 2]) {
  test(`runtime rejects invalid game count ${count} at the real room boundary`, async () => {
    let attaches = 0;
    const setup = makeRuntime(runtimeConfig(), makeGameEntry({
      resolveSeatCount: () => count,
      createModule: () => ({
        attach() { attaches += 1; },
        handlePlatformEvent() {}, handleGameMessage() {}, restore() {}, dispose() {},
      }),
    }));
    await setup.runtime.start();
    setup.wire.emit({ type: 'open', server: 'ws://agent' });
    setup.wire.emit({ type: 'message', message: {
      route: 'agent', rpc: 'player_login', data: fixture('player-login-room.json'),
    } });
    assert.equal(attaches, 0);
    assert.equal(setup.wire.stopCalls, 1);
    const failure = setup.scene.calls.find(call => call.name === 'fatal')?.value;
    assert.match(String((failure as { errors: unknown[] }).errors[0]), /seat count/);
    setup.runtime.stop();
  });
}

test('a nonzero login outcome clears its guard, retains state and permits account retry', async () => {
  const { runtime, wire, scene, clock } = makeRuntime();
  await runtime.start();
  wire.emit({ type: 'open', server: 'ws://agent' });
  const before = runtime.state;
  runtime.login(ACCOUNT);
  const denial = { state: 7, roomcode: 'unavailable', showerror: 1, error: 'Login denied' };
  wire.emit({ type: 'message', message: { route: 'agent', rpc: 'player_login', data: denial } });

  assert.equal(runtime.state, before);
  assert.equal(wire.stopCalls, 0);
  assert.equal(clock.timers.size, 0);
  const outcome = scene.calls.find(call => call.name === 'denied')?.value;
  assert.deepEqual(outcome, { rpc: 'player_login', state: 7, data: denial });
  assert.equal((outcome as { data: unknown }).data, denial);
  assert.deepEqual(scene.calls.filter(call => call.name === 'fatal'), []);
  runtime.login({ ...ACCOUNT, openid: 'retry-account' });
  assert.equal((wire.sent[wire.sent.length - 1]!.data as Record<string, unknown>).openid, 'retry-account');
  wire.emit({ type: 'message', message: {
    route: 'agent', rpc: 'player_login', data: fixture('player-login-success.json'),
  } });
  assert.equal(runtime.state.app.phase, 'logged-in');
  runtime.stop();
});

for (const interruption of ['attach', 'restore', 'room-scene', 'room-event'] as const) {
  test(`stop from ${interruption} releases the actual module and host without reviving runtime`, async () => {
    let runtime: PlatformRuntime;
    let attachedHost: GameHost | undefined;
    let moduleNumber = 0;
    const disposed: number[] = [];
    const events: string[] = [];
    const entry = makeGameEntry({
      createModule() {
        const id = moduleNumber++;
        return {
          attach(host) {
            attachedHost = host;
            host.subscribe(() => { events.push('snapshot'); });
            if (interruption === 'attach') runtime.stop();
          },
          handlePlatformEvent() {
            events.push('room-event');
            if (interruption === 'room-event') runtime.stop();
          },
          handleGameMessage() { events.push('game-message'); },
          restore() {
            events.push('restore');
            if (interruption === 'restore') runtime.stop();
          },
          dispose() { disposed.push(id); },
        };
      },
    });
    const setup = makeRuntime(runtimeConfig(), entry);
    runtime = setup.runtime;
    setup.scene.onCall = name => {
      if (name === 'room' && interruption === 'room-scene') runtime.stop();
    };
    await runtime.start();
    setup.wire.emit({ type: 'open', server: 'ws://agent' });
    runtime.login(ACCOUNT);
    setup.wire.emit({ type: 'message', message: {
      route: 'agent', rpc: 'player_login', data: fixture('player-login-room.json'),
    } });

    assert.deepEqual(disposed, [0, 1], 'validation and actual room modules each dispose once');
    assert.ok(attachedHost);
    const stoppedHost = attachedHost;
    assert.throws(() => stoppedHost.getSnapshot(), /disposed/);
    assert.throws(() => stoppedHost.subscribe(() => {}), /disposed/);
    assert.equal(setup.clock.timers.size, 0);
    assert.deepEqual(setup.scene.calls.filter(call => call.name === 'fatal'), []);
    assert.equal(setup.wire.stopCalls, 1);
    assert.deepEqual(setup.wire.lifecycle, ['subscribe', 'start', 'unsubscribe', 'stop']);
    if (interruption === 'attach') assert.deepEqual(events, ['snapshot']);
    if (interruption === 'room-event' || interruption === 'room-scene') {
      assert.deepEqual(events, ['snapshot', 'room-event']);
    }
    const stoppedState = runtime.state;
    const stoppedEvents = [...events];
    setup.wire.emit({ type: 'open', server: 'ws://agent' });
    setup.wire.emit({ type: 'message', message: {
      route: 'fixture-game', rpc: 'late', data: {},
    } });
    assert.equal(runtime.state, stoppedState);
    assert.deepEqual(events, stoppedEvents);
    assert.throws(() => runtime.login(ACCOUNT), /stopped/);
    await assert.rejects(runtime.start(), /stopped/);
    runtime.stop();
    assert.deepEqual(disposed, [0, 1]);
    assert.equal(setup.wire.stopCalls, 1);
  });
}

test('stop reentered by an old module disposal prevents replacement room activation', async () => {
  let runtime: PlatformRuntime;
  const attached: GameHost[] = [];
  let disposals = 0;
  const setup = makeRuntime(runtimeConfig(), makeGameEntry({
    createModule() {
      let host: GameHost | undefined;
      return {
        attach(value) { host = value; attached.push(value); },
        handlePlatformEvent() {}, handleGameMessage() {}, restore() {},
        dispose() {
          if (host === undefined) return;
          disposals += 1;
          runtime.stop();
        },
      };
    },
  }));
  runtime = setup.runtime;
  await runtime.start();
  setup.wire.emit({ type: 'open', server: 'ws://agent' });
  setup.wire.emit({ type: 'message', message: {
    route: 'agent', rpc: 'player_login', data: fixture('player-login-room.json'),
  } });
  setup.wire.emit({ type: 'message', message: {
    route: 'agent', rpc: 'player_login', data: fixture('player-login-room.json'),
  } });
  assert.equal(disposals, 1);
  assert.equal(attached.length, 1);
  assert.throws(() => attached[0]!.getSnapshot(), /disposed/);
  assert.deepEqual(setup.scene.calls.filter(call => call.name === 'fatal'), []);
  assert.equal(setup.wire.stopCalls, 1);
  assert.throws(() => runtime.login(ACCOUNT), /stopped/);
  runtime.stop();
});

test('an actual callback error after stop remains explicit without changing the stopped lifecycle', async () => {
  let runtime: PlatformRuntime;
  const failure = new Error('restore callback failed after stop');
  const setup = makeRuntime(runtimeConfig(), makeGameEntry({
    createModule: () => ({
      attach() {}, handlePlatformEvent() {}, handleGameMessage() {}, dispose() {},
      restore() { runtime.stop(); throw failure; },
    }),
  }));
  runtime = setup.runtime;
  await runtime.start();
  setup.wire.emit({ type: 'open', server: 'ws://agent' });
  const thrown = thrownValue(() => setup.wire.emit({ type: 'message', message: {
    route: 'agent', rpc: 'player_login', data: fixture('player-login-room.json'),
  } }));
  assert.deepEqual((thrown as { errors: unknown[] }).errors, [failure]);
  assert.deepEqual(setup.scene.calls.filter(call => call.name === 'fatal'), []);
  assert.throws(() => runtime.login(ACCOUNT), /stopped/);
  runtime.stop();
  assert.equal(setup.wire.stopCalls, 1);
});

for (const rpc of ['player_login', 'self_join_room']) {
  test(`malformed successful ${rpc} still terminates explicitly`, async () => {
    const { runtime, wire, scene } = makeRuntime();
    await runtime.start();
    wire.emit({ type: 'open', server: 'ws://agent' });
    wire.emit({ type: 'message', message: { route: 'agent', rpc, data: { state: 0 } } });
    assert.equal(wire.stopCalls, 1);
    assert.equal(scene.calls.filter(call => call.name === 'fatal').length, 1);
    assert.deepEqual(scene.calls.filter(call => call.name === 'denied'), []);
    runtime.stop();
  });
}

function makeLoggingEntry(log: string[], restored: unknown[], attached: GameHost[]): GameEntry {
  let recording = false;
  const entry = makeGameEntry({
    createModule: (): GameModule => {
      let host: GameHost | null = null;
      return {
        attach(value) {
          host = value;
          if (!recording) return;
          attached.push(value);
          log.push(`attach:${value.getSnapshot().room.roomcode}`);
        },
        handlePlatformEvent(event: PlatformToGameEvent) {
          if (recording) log.push(`event:${event.type}`);
        },
        handleGameMessage() {},
        restore(deskinfo) {
          if (!recording) return;
          assert.ok(host);
          restored.push(deskinfo);
          log.push('restore');
        },
        dispose() {
          if (!recording) return;
          assert.ok(host);
          host.getSnapshot();
          log.push('dispose');
        },
      };
    },
  });
  Object.defineProperty(entry, 'beginRecording', {
    value: () => { recording = true; },
  });
  return entry;
}

function beginEntryRecording(entry: GameEntry): void {
  (entry as GameEntry & { beginRecording(): void }).beginRecording();
}

interface CapturedGameHost {
  host: GameHost | null;
}

function makeCleanupFailureEntry(
  log: string[],
  disposeFailure: unknown,
  captured: CapturedGameHost,
): GameEntry {
  let moduleNumber = 0;
  return makeGameEntry({
    createModule(): GameModule {
      moduleNumber += 1;
      const validationModule = moduleNumber === 1;
      return {
        attach(host) {
          if (validationModule) return;
          captured.host = host;
          host.subscribe(() => {});
        },
        handlePlatformEvent() {},
        handleGameMessage() {},
        restore() {},
        dispose() {
          if (validationModule) return;
          log.push('game:dispose');
          throw disposeFailure;
        },
      };
    },
  });
}

test('start resolves config, subscribes before connect, and never logs in without an account', async () => {
  const setup = makeRuntime();

  await setup.runtime.start();
  setup.wire.emit({ type: 'open', server: 'ws://agent' });

  assert.equal(setup.factoryConfigs.length, 1);
  assert.equal(setup.factoryConfigs[0], setup.config);
  assert.deepEqual(setup.wire.lifecycle, ['subscribe', 'start']);
  assert.deepEqual(setup.wire.sent, []);
  assert.equal(setup.runtime.ready, true);
  assert.deepEqual(setup.scene.calls.map((call) => call.name), ['loading', 'login']);
});

test('showLoading failure enters terminal fatal before any startup dependency runs', async () => {
  const primary = new Error('loading scene failed');
  const scene = new RecordingScene();
  const wire = new RecordingWireClient();
  let resourcesStarted = 0;
  let minimumDisplayStarted = 0;
  let configsResolved = 0;
  let wireFactories = 0;
  scene.onCall = (name) => {
    if (name === 'loading') throw primary;
  };
  const runtime = new PlatformRuntime({
    gameEntry: makeGameEntry(),
    resolveRuntimeConfig: async () => {
      configsResolved += 1;
      return runtimeConfig();
    },
    createWireClient: () => {
      wireFactories += 1;
      return wire;
    },
    scene,
    loadResources: async () => { resourcesStarted += 1; },
    waitForMinimumDisplay: async () => { minimumDisplayStarted += 1; },
    getLoginDeviceSnapshot: () => DEVICE,
  });

  const thrown = await rejectedValue(runtime.start());

  assert.equal(thrown, primary);
  assert.deepEqual(scene.calls.map((call) => call.name), ['loading', 'fatal']);
  assert.equal(scene.calls[1]?.value, primary);
  assert.equal(resourcesStarted, 0);
  assert.equal(minimumDisplayStarted, 0);
  assert.equal(configsResolved, 0);
  assert.equal(wireFactories, 0);
  assert.deepEqual(wire.lifecycle, []);
  assert.equal(runtime.ready, false);

  await assert.rejects(() => runtime.start(), /fatal/i);
  assert.equal(scene.calls.filter((call) => call.name === 'fatal').length, 1);
});

test('showLoading and showFatal failures preserve both error identities without starting dependencies', async () => {
  const primary = new Error('loading scene failed');
  const fatalSceneFailure = { step: 'scene.showFatal' };
  const scene = new RecordingScene();
  let dependencyCalls = 0;
  scene.onCall = (name) => {
    if (name === 'loading') throw primary;
    if (name === 'fatal') throw fatalSceneFailure;
  };
  const runtime = new PlatformRuntime({
    gameEntry: makeGameEntry(),
    resolveRuntimeConfig: async () => {
      dependencyCalls += 1;
      return runtimeConfig();
    },
    createWireClient: () => {
      dependencyCalls += 1;
      return new RecordingWireClient();
    },
    scene,
    loadResources: async () => { dependencyCalls += 1; },
    waitForMinimumDisplay: async () => { dependencyCalls += 1; },
    getLoginDeviceSnapshot: () => DEVICE,
  });

  const thrown = await rejectedValue(runtime.start());
  assert.ok(thrown instanceof Error);
  const errors = (thrown as Error & { readonly errors: readonly unknown[] }).errors;

  assert.equal(errors[0], primary);
  assert.equal(errors[1], fatalSceneFailure);
  assert.equal(dependencyCalls, 0);
  assert.deepEqual(scene.calls.map((call) => call.name), ['loading', 'fatal']);
  await assert.rejects(() => runtime.start(), /fatal/i);
  assert.equal(scene.calls.filter((call) => call.name === 'fatal').length, 1);
});

test('stop while config is pending prevents every late startup continuation from reviving runtime', async () => {
  const configReady = deferred<RuntimeConfig>();
  const resourcesReady = deferred<void>();
  const minimumDisplayReady = deferred<void>();
  const wire = new RecordingWireClient();
  const scene = new RecordingScene();
  let resourcesStarted = 0;
  let minimumDisplayStarted = 0;
  let wireFactories = 0;
  const runtime = new PlatformRuntime({
    gameEntry: makeGameEntry(),
    resolveRuntimeConfig: () => configReady.promise,
    createWireClient() {
      wireFactories += 1;
      return wire;
    },
    scene,
    loadResources() {
      resourcesStarted += 1;
      return resourcesReady.promise;
    },
    waitForMinimumDisplay() {
      minimumDisplayStarted += 1;
      return minimumDisplayReady.promise;
    },
    getLoginDeviceSnapshot: () => DEVICE,
  });

  const starting = runtime.start();
  await Promise.resolve();
  assert.equal(resourcesStarted, 1);
  assert.equal(minimumDisplayStarted, 1);

  runtime.stop();
  configReady.resolve(runtimeConfig());
  resourcesReady.resolve(undefined);
  minimumDisplayReady.resolve(undefined);

  await assert.rejects(starting, /stopped/i);
  await assert.rejects(() => runtime.start(), /stopped/i);
  assert.equal(wireFactories, 0);
  assert.deepEqual(wire.lifecycle, []);
  assert.equal(runtime.ready, false);
  assert.deepEqual(scene.calls.map((call) => call.name), ['loading']);
});

test('a synchronous subscribe callback that stops runtime hands the returned unsubscribe to teardown exactly once', async () => {
  const unsubscribeFailure = { step: 'late-unsubscribe' };
  const wire = new SynchronousSubscribeWireClient(
    { type: 'slow' },
    { value: unsubscribeFailure },
  );
  const scene = new RecordingScene();
  let runtime!: PlatformRuntime;
  runtime = new PlatformRuntime({
    gameEntry: makeGameEntry(),
    resolveRuntimeConfig: async () => runtimeConfig(),
    createWireClient: () => wire,
    scene,
    loadResources: async () => {},
    waitForMinimumDisplay: async () => {},
    getLoginDeviceSnapshot: () => DEVICE,
  });
  scene.onCall = (name) => {
    if (name === 'reconnect') runtime.stop();
  };

  const thrown = await rejectedValue(runtime.start());
  assert.ok(thrown instanceof Error);
  const errors = (thrown as Error & { readonly errors: readonly unknown[] }).errors;

  assert.match(String(errors[0]), /stopped/i);
  assert.equal(errors[1], unsubscribeFailure);
  assert.equal(wire.unsubscribeCalls, 1);
  assert.equal(wire.listenerAttached, false);
  assert.equal(wire.stopCalls, 1);
  assert.equal(wire.startCalls, 0);

  const sceneCallCount = scene.calls.length;
  wire.emit({ type: 'open', server: 'ws://agent' });
  runtime.stop();
  assert.equal(scene.calls.length, sceneCallCount);
  assert.equal(wire.unsubscribeCalls, 1);
  assert.equal(wire.stopCalls, 1);
});

test('a fatal synchronous subscribe callback still adopts unsubscribe and ignores late events', async () => {
  const primary = new Error('synchronous reconnect scene failed');
  const wire = new SynchronousSubscribeWireClient({ type: 'slow' });
  const scene = new RecordingScene();
  scene.onCall = (name) => {
    if (name === 'reconnect') throw primary;
  };
  const runtime = new PlatformRuntime({
    gameEntry: makeGameEntry(),
    resolveRuntimeConfig: async () => runtimeConfig(),
    createWireClient: () => wire,
    scene,
    loadResources: async () => {},
    waitForMinimumDisplay: async () => {},
    getLoginDeviceSnapshot: () => DEVICE,
  });

  const thrown = await rejectedValue(runtime.start());

  assert.equal(thrown, primary);
  assert.equal(wire.unsubscribeCalls, 1);
  assert.equal(wire.listenerAttached, false);
  assert.equal(wire.stopCalls, 1);
  assert.equal(wire.startCalls, 0);
  assert.deepEqual(
    scene.calls.filter((call) => call.name === 'fatal').map((call) => call.value),
    [primary],
  );

  const sceneCallCount = scene.calls.length;
  wire.emit({ type: 'reconnecting', server: 'ws://agent' });
  assert.equal(scene.calls.length, sceneCallCount);
});

for (const invalidUnsubscribe of [7, null, undefined] as const) {
  test(`subscribe returning ${String(invalidUnsubscribe)} is fatal before Wire start`, async () => {
    const wire = new InvalidSubscribeWireClient(invalidUnsubscribe);
    const scene = new RecordingScene();
    const runtime = new PlatformRuntime({
      gameEntry: makeGameEntry(),
      resolveRuntimeConfig: async () => runtimeConfig(),
      createWireClient: () => wire,
      scene,
      loadResources: async () => {},
      waitForMinimumDisplay: async () => {},
      getLoginDeviceSnapshot: () => DEVICE,
    });

    const thrown = await rejectedValue(runtime.start());

    assert.ok(thrown instanceof TypeError);
    assert.match(thrown.message, /subscribe.*unsubscribe.*function/i);
    assert.deepEqual(wire.lifecycle, ['subscribe', 'stop']);
    assert.equal(wire.stopCalls, 1);
    assert.deepEqual(
      scene.calls.filter((call) => call.name === 'fatal').map((call) => call.value),
      [thrown],
    );
    await assert.rejects(() => runtime.start(), /fatal/i);
    assert.equal(scene.calls.filter((call) => call.name === 'fatal').length, 1);
  });
}

test('subscribe startup failure enters fatal once and stops the created wire without starting it', async () => {
  const setup = makeRuntime();
  const primary = new Error('subscribe failed');
  setup.wire.onAction = (name) => {
    if (name === 'subscribe') throw primary;
  };

  const thrown = await rejectedValue(setup.runtime.start());

  assert.equal(thrown, primary);
  assert.deepEqual(setup.wire.lifecycle, ['subscribe', 'stop']);
  assert.equal(setup.wire.stopCalls, 1);
  assert.deepEqual(
    setup.scene.calls.filter((call) => call.name === 'fatal').map((call) => call.value),
    [primary],
  );
});

test('wire start failure cleans every established layer and preserves cleanup error order', async () => {
  const primary = new Error('wire start failed');
  const unsubscribeFailure = { step: 'unsubscribe' };
  const stopFailure = { step: 'wire.stop' };
  const cleanupLog: string[] = [];
  let moduleNumber = 0;
  let activeHost: GameHost | null = null;
  const entry = makeGameEntry({
    createModule(): GameModule {
      moduleNumber += 1;
      const currentModule = moduleNumber;
      return {
        attach(host) {
          if (currentModule === 1) return;
          activeHost = host;
          host.subscribe(() => {});
        },
        handlePlatformEvent() {},
        handleGameMessage() {},
        restore() {},
        dispose() {
          if (currentModule === 1) return;
          cleanupLog.push('game:dispose');
          throw undefined;
        },
      };
    },
  });
  const setup = makeRuntime(runtimeConfig(), entry);
  setup.wire.onAction = (name) => {
    if (name === 'start') {
      setup.wire.emit({ type: 'open', server: 'ws://agent' });
      setup.runtime.login(ACCOUNT);
      setup.wire.emit({
        type: 'message',
        message: {
          route: 'agent',
          rpc: 'player_login',
          data: fixture('player-login-room.json'),
        },
      });
      throw primary;
    }
    if (name === 'unsubscribe') {
      cleanupLog.push('wire:unsubscribe');
      throw unsubscribeFailure;
    }
    if (name === 'stop') {
      cleanupLog.push('wire:stop');
      const host = activeHost;
      assert.ok(host);
      assert.throws(() => host.getSnapshot(), /disposed/i);
      throw stopFailure;
    }
  };

  const thrown = await rejectedValue(setup.runtime.start());
  assert.ok(thrown instanceof Error);
  const errors = (thrown as Error & { readonly errors: readonly unknown[] }).errors;

  assert.deepEqual(cleanupLog, ['wire:unsubscribe', 'game:dispose', 'wire:stop']);
  assert.equal(errors.length, 4);
  assert.equal(errors[0], primary);
  assert.equal(errors[1], unsubscribeFailure);
  assert.equal(errors[2], undefined);
  assert.equal(errors[3], stopFailure);
  assert.equal(setup.scene.calls.filter((call) => call.name === 'fatal').length, 1);
  assert.equal(
    setup.scene.calls.find((call) => call.name === 'fatal')?.value,
    thrown,
  );

  const sceneCalls = setup.scene.calls.length;
  setup.wire.emit({ type: 'reconnecting', server: 'ws://agent' });
  setup.wire.emit({ type: 'open', server: 'ws://agent' });
  assert.equal(setup.scene.calls.length, sceneCalls);
  assert.equal(setup.wire.stopCalls, 1);
});

for (const failedGate of ['resources', 'minimum-display'] as const) {
  test(`${failedGate} failure after Wire start tears down once and stays fatal`, async () => {
    const resourcesReady = deferred<void>();
    const minimumDisplayReady = deferred<void>();
    const wireStarted = deferred<void>();
    const primary = new Error(`${failedGate} failed`);
    const setup = makeRuntime();
    const runtime = new PlatformRuntime({
      gameEntry: makeGameEntry(),
      resolveRuntimeConfig: async () => runtimeConfig(),
      createWireClient: () => setup.wire,
      scene: setup.scene,
      loadResources: () => resourcesReady.promise,
      waitForMinimumDisplay: () => minimumDisplayReady.promise,
      getLoginDeviceSnapshot: () => DEVICE,
      clock: setup.clock,
    });
    setup.wire.onAction = (name) => {
      if (name === 'start') wireStarted.resolve(undefined);
    };

    const starting = runtime.start();
    await wireStarted.promise;
    setup.wire.emit({ type: 'open', server: 'ws://agent' });
    if (failedGate === 'resources') {
      resourcesReady.reject(primary);
      minimumDisplayReady.resolve(undefined);
    } else {
      resourcesReady.resolve(undefined);
      minimumDisplayReady.reject(primary);
    }

    const thrown = await rejectedValue(starting);
    assert.equal(thrown, primary);
    assert.deepEqual(setup.wire.lifecycle, ['subscribe', 'start', 'unsubscribe', 'stop']);
    assert.equal(setup.wire.stopCalls, 1);
    assert.deepEqual(
      setup.scene.calls.filter((call) => call.name === 'fatal').map((call) => call.value),
      [primary],
    );

    const sceneCalls = setup.scene.calls.length;
    setup.wire.emit({ type: 'reconnecting', server: 'ws://agent' });
    setup.wire.emit({ type: 'open', server: 'ws://agent' });
    assert.equal(setup.scene.calls.length, sceneCalls);
  });
}

test('login sends one exact request and an ordinary reopen resends the same data with a four-second guard', async () => {
  const setup = makeRuntime();
  await setup.runtime.start();
  setup.wire.emit({ type: 'open', server: 'ws://agent' });

  setup.runtime.login(ACCOUNT);

  assert.deepEqual(setup.wire.sent[0], {
    app: 'youle',
    route: 'agent',
    rpc: 'player_login',
    data: {
      agentid: 'veRa0qrBf', gameid: '41', openid: 'o1', nickname: '测试号',
      avatar: 'http://a', sex: 0, province: '江西', city: '南昌',
      unionid: 'test_unionid', version: 10000, channelid: 'FtJf073aa',
      marketid: 4, ip: '127.0.0.1', location: DEVICE.location,
      machineid: 'machine-1', machineroom: 'room-install-1',
    },
  });
  assert.deepEqual([...setup.clock.timers.values()].map((timer) => timer.ms), [4000]);

  setup.wire.emit({
    type: 'message',
    message: { route: 'agent', rpc: 'player_login', data: fixture('player-login-success.json') },
  });
  assert.equal(setup.clock.timers.size, 0);

  setup.wire.emit({ type: 'open', server: 'ws://agent' });

  assert.equal(setup.wire.sent.length, 2);
  assert.equal(setup.wire.sent[1]?.rpc, 'player_login');
  assert.equal(setup.wire.sent[1]?.data, setup.wire.sent[0]?.data);
  assert.deepEqual([...setup.clock.timers.values()].map((timer) => timer.ms), [4000]);
  setup.clock.runOnlyTimer();
  assert.equal(setup.wire.reconnectCalls, 1);
});

for (const mismatch of [
  { label: 'different value', configGameId: '42', entryGameId: '41' },
  { label: 'different type', configGameId: '41', entryGameId: 41 },
] as const) {
  test(`gameid ${mismatch.label} fails fatally before WireClient creation`, async () => {
    const setup = makeRuntime(
      runtimeConfig(mismatch.configGameId),
      makeGameEntry({ gameId: mismatch.entryGameId }),
    );

    await assert.rejects(() => setup.runtime.start(), /gameid/i);
    await assert.rejects(() => setup.runtime.start(), /fatal/i);

    assert.equal(setup.factoryConfigs.length, 0);
    assert.deepEqual(setup.wire.lifecycle, []);
    const fatalCalls = setup.scene.calls.filter((call) => call.name === 'fatal');
    assert.equal(fatalCalls.length, 1);
    assert.ok(fatalCalls[0]?.value instanceof Error);
  });
}

for (const switchCase of [
  {
    label: 'room',
    route: 'room',
    rpc: 'connect_roomserver',
    target: 'ws://room.example:3088',
    data: { roomserver: 'ws://room.example:3088', epoch: 7, nested: { trace: 'r' } },
  },
  {
    label: 'agent',
    route: 'agent',
    rpc: 'connect_agentserver',
    target: 'wss://agent.example/socket',
    data: {
      agentserver: 'wss://agent.example/socket',
      opt: 'free_room',
      nested: { trace: 'a' },
    },
  },
] as const) {
  test(`${switchCase.label} switch resends the exact switch envelope before returning to steady login`, async () => {
    const setup = makeRuntime();
    await setup.runtime.start();
    setup.wire.emit({ type: 'open', server: 'ws://agent' });
    setup.runtime.login(ACCOUNT);
    const loginEnvelope = setup.wire.sent[0]!;
    setup.wire.emit({
      type: 'message',
      message: { route: 'agent', rpc: 'player_login', data: fixture('player-login-success.json') },
    });
    setup.wire.sent.length = 0;

    setup.wire.emit({
      type: 'message',
      message: { route: switchCase.route, rpc: switchCase.rpc, data: switchCase.data },
    });

    assert.deepEqual(setup.wire.switchCalls, [switchCase.target]);
    assert.equal(setup.wire.sent.length, 0);

    setup.wire.emit({ type: 'open', server: switchCase.target });

    assert.equal(setup.wire.sent.length, 1);
    assert.equal(setup.wire.sent[0]?.rpc, switchCase.rpc);
    assert.deepEqual(setup.wire.sent[0], {
      app: 'youle',
      route: switchCase.route,
      rpc: switchCase.rpc,
      data: switchCase.data,
    });
    assert.equal(setup.wire.sent[0]?.data, switchCase.data);
    assert.equal(setup.clock.timers.size, 0, 'switch resend must not start the login guard');

    setup.wire.emit({ type: 'open', server: switchCase.target });

    assert.equal(setup.wire.sent.length, 2);
    assert.equal(setup.wire.sent[1]?.rpc, 'player_login');
    assert.equal(setup.wire.sent[1]?.data, loginEnvelope.data);
    assert.deepEqual([...setup.clock.timers.values()].map((timer) => timer.ms), [4000]);
  });
}

test('successful login without a room shows the lobby', async () => {
  const setup = makeRuntime();
  await setup.runtime.start();
  setup.wire.emit({ type: 'open', server: 'ws://agent' });
  setup.runtime.login(ACCOUNT);

  setup.wire.emit({
    type: 'message',
    message: { route: 'agent', rpc: 'player_login', data: fixture('player-login-success.json') },
  });

  assert.equal(setup.runtime.state.room.kind, 'outside');
  assert.equal(setup.scene.calls[setup.scene.calls.length - 1]?.name, 'lobby');
});

test('room login commits and opens before showRoom, then restores the exact deskinfo', async () => {
  const log: string[] = [];
  const restored: unknown[] = [];
  const attached: GameHost[] = [];
  const entry = makeLoggingEntry(log, restored, attached);
  const setup = makeRuntime(runtimeConfig(), entry);
  setup.scene.onCall = (name) => { if (name === 'room') log.push('scene:room'); };
  await setup.runtime.start();
  beginEntryRecording(entry);
  setup.wire.emit({ type: 'open', server: 'ws://agent' });
  setup.runtime.login(ACCOUNT);
  const roomLogin = fixture('player-login-room.json');

  setup.wire.emit({
    type: 'message',
    message: { route: 'agent', rpc: 'player_login', data: roomLogin },
  });

  assert.equal(setup.runtime.state.room.kind, 'inside');
  assert.deepEqual(log, [
    'attach:100001',
    'event:room.entered',
    'scene:room',
    'restore',
  ]);
  assert.deepEqual(restored, [roomLogin.deskinfo]);
  assert.equal(restored[0], roomLogin.deskinfo);
  assert.equal(attached.length, 1);
});

for (const withDeskinfo of [false, true]) {
  test(`self join opens and shows the room ${withDeskinfo ? 'before restoring deskinfo' : 'without restoring absent deskinfo'}`, async () => {
    const log: string[] = [];
    const restored: unknown[] = [];
    const attached: GameHost[] = [];
    const entry = makeLoggingEntry(log, restored, attached);
    const setup = makeRuntime(runtimeConfig(), entry);
    setup.scene.onCall = (name) => { if (name === 'room') log.push('scene:room'); };
    await setup.runtime.start();
    beginEntryRecording(entry);
    setup.wire.emit({ type: 'open', server: 'ws://agent' });
    setup.runtime.login(ACCOUNT);
    setup.wire.emit({
      type: 'message',
      message: { route: 'agent', rpc: 'player_login', data: fixture('player-login-success.json') },
    });
    log.length = 0;
    const join = fixture('self-join-room.json');
    const deskinfo = join.deskinfo;
    if (!withDeskinfo) delete join.deskinfo;

    setup.wire.emit({
      type: 'message',
      message: { route: 'agent', rpc: 'self_join_room', data: join },
    });

    assert.deepEqual(log, withDeskinfo
      ? ['attach:100001', 'event:room.entered', 'scene:room', 'restore']
      : ['attach:100001', 'event:room.entered', 'scene:room']);
    assert.deepEqual(restored, withDeskinfo ? [deskinfo] : []);
    if (withDeskinfo) assert.equal(restored[0], deskinfo);
  });
}

test('slow and reconnecting show reconnect without clearing or replacing room state', async () => {
  const setup = makeRuntime();
  await setup.runtime.start();
  setup.wire.emit({ type: 'open', server: 'ws://agent' });
  setup.runtime.login(ACCOUNT);
  setup.wire.emit({
    type: 'message',
    message: { route: 'agent', rpc: 'player_login', data: fixture('player-login-room.json') },
  });
  const roomState = setup.runtime.state;
  const callsBefore = setup.scene.calls.length;

  setup.wire.emit({ type: 'slow' });
  assert.equal(setup.runtime.state.app.phase, 'slow');
  setup.wire.emit({ type: 'reconnecting', server: 'ws://agent' });

  assert.equal(setup.runtime.state.app.phase, 'reconnecting');
  assert.equal(setup.runtime.state.room, roomState.room);
  assert.equal(setup.runtime.state.players, roomState.players);
  assert.equal(setup.runtime.state.room.kind, 'inside');
  assert.deepEqual(
    setup.scene.calls.slice(callsBefore).map((call) => call.name),
    ['reconnect', 'reconnect'],
  );
});

test('kick closes the game before showing kicked and stopping the wire', async () => {
  const log: string[] = [];
  const restored: unknown[] = [];
  const attached: GameHost[] = [];
  const entry = makeLoggingEntry(log, restored, attached);
  const setup = makeRuntime(runtimeConfig(), entry);
  setup.scene.onCall = (name) => { if (name === 'kicked') log.push('scene:kicked'); };
  setup.wire.onAction = (name) => { if (name === 'stop') log.push('wire:stop'); };
  await setup.runtime.start();
  beginEntryRecording(entry);
  setup.wire.emit({ type: 'open', server: 'ws://agent' });
  setup.runtime.login(ACCOUNT);
  setup.wire.emit({
    type: 'message',
    message: { route: 'agent', rpc: 'player_login', data: fixture('player-login-room.json') },
  });
  log.length = 0;
  const kick = { msg: '检查到新版本', code: 1 };

  setup.wire.emit({
    type: 'message',
    message: { route: 'agent', rpc: 'kick_server', data: kick },
  });

  assert.deepEqual(log, ['dispose', 'scene:kicked', 'wire:stop']);
  assert.equal(setup.wire.stopCalls, 1);
  assert.equal(setup.scene.calls[setup.scene.calls.length - 1]?.value, kick);

  const sceneCalls = setup.scene.calls.length;
  setup.wire.emit({ type: 'reconnecting', server: 'ws://agent' });
  setup.wire.emit({ type: 'open', server: 'ws://agent' });
  assert.equal(setup.scene.calls.length, sceneCalls, 'late wire events stay silent after kick');
  assert.equal(setup.wire.sent.length, 1, 'late open never revives login after kick');
});

test('a game rpc named like a platform rpc cannot drive platform scenes', async () => {
  const setup = makeRuntime();
  await setup.runtime.start();
  setup.wire.emit({ type: 'open', server: 'ws://agent' });
  setup.runtime.login(ACCOUNT);
  setup.wire.emit({
    type: 'message',
    message: { route: 'agent', rpc: 'player_login', data: fixture('player-login-room.json') },
  });
  const sceneCalls = setup.scene.calls.length;

  setup.wire.emit({
    type: 'message',
    message: { route: 'fixture-game', rpc: 'self_exit_room', data: { reason: 'game-owned' } },
  });

  assert.equal(setup.runtime.state.room.kind, 'inside');
  assert.equal(setup.scene.calls.length, sceneCalls);
});

test('login gate routes each ignored room message once with zero runtime side effects', async () => {
  const originalDispatch = Router.prototype.dispatch;
  let routerDispatches = 0;
  Router.prototype.dispatch = function dispatchWithCount(message) {
    routerDispatches += 1;
    return originalDispatch.call(this, message);
  };

  try {
    const log: string[] = [];
    const entry = makeLoggingEntry(log, [], []);
    const setup = makeRuntime(runtimeConfig(), entry);
    await setup.runtime.start();
    beginEntryRecording(entry);
    setup.wire.emit({ type: 'open', server: 'ws://agent' });
    setup.runtime.login(ACCOUNT);
    const stateBefore = setup.runtime.state;
    const sceneCallsBefore = setup.scene.calls.length;
    const lifecycleBefore = [...setup.wire.lifecycle];

    setup.wire.emit({
      type: 'message',
      message: { route: 'room', rpc: 'self_exit_room', data: { seat: 1 } },
    });
    setup.wire.emit({
      type: 'message',
      message: { route: 'agent', rpc: 'self_join_room', data: fixture('self-join-room.json') },
    });

    assert.equal(routerDispatches, 2);
    assert.equal(setup.runtime.state, stateBefore);
    assert.deepEqual(log, []);
    assert.equal(setup.scene.calls.length, sceneCallsBefore);
    assert.equal(setup.scene.calls.filter((call) => call.name === 'fatal').length, 0);
    assert.deepEqual(setup.wire.lifecycle, lifecycleBefore);
    assert.equal(setup.wire.stopCalls, 0);
  } finally {
    Router.prototype.dispatch = originalDispatch;
  }
});

test('a handled no-op room message cannot drive a scene without a state transition', async () => {
  const setup = makeRuntime();
  await setup.runtime.start();
  setup.wire.emit({ type: 'open', server: 'ws://agent' });
  setup.runtime.login(ACCOUNT);
  setup.wire.emit({
    type: 'message',
    message: { route: 'agent', rpc: 'player_login', data: fixture('player-login-success.json') },
  });
  const stateBefore = setup.runtime.state;
  const sceneCallsBefore = setup.scene.calls.length;

  setup.wire.emit({
    type: 'message',
    message: { route: 'room', rpc: 'self_exit_room', data: {} },
  });

  assert.equal(setup.runtime.state, stateBefore);
  assert.equal(setup.scene.calls.length, sceneCallsBefore);
  assert.equal(setup.scene.calls.filter((call) => call.name === 'fatal').length, 0);
});

test('joinRoom, prepare, and exitRoom delegate through the authoritative platform commands', async () => {
  const setup = makeRuntime();
  await setup.runtime.start();
  setup.wire.emit({ type: 'open', server: 'ws://agent' });
  setup.runtime.login(ACCOUNT);
  setup.wire.emit({
    type: 'message',
    message: { route: 'agent', rpc: 'player_login', data: fixture('player-login-success.json') },
  });
  setup.wire.sent.length = 0;
  const location = { latitude: 28.7, longitude: 115.8 };

  setup.runtime.joinRoom({
    roomcode: '100001',
    location,
    ip: '203.0.113.7',
    vipMatch: 1,
    match_id: 'match-9',
  });

  assert.deepEqual(setup.wire.sent, [{
    app: 'youle',
    route: 'agent',
    rpc: 'self_join_room',
    data: {
      agentid: 'veRa0qrBf',
      playerid: 430511,
      gameid: '41',
      roomcode: '100001',
      location,
      ip: '203.0.113.7',
      vipMatch: 1,
      match_id: 'match-9',
    },
  }]);
  assert.equal((setup.wire.sent[0]!.data as { location: unknown }).location, location);

  const joinedRoom = fixture('self-join-room.json');
  delete joinedRoom.deskinfo;
  joinedRoom.deskwar = 0;
  setup.wire.emit({
    type: 'message',
    message: { route: 'agent', rpc: 'self_join_room', data: joinedRoom },
  });
  setup.wire.sent.length = 0;
  setup.runtime.prepare();
  setup.runtime.exitRoom();

  assert.deepEqual(setup.wire.sent, [
    {
      app: 'youle',
      route: 'room',
      rpc: 'player_prepare',
      data: {
        agentid: 'veRa0qrBf', playerid: 430511, gameid: '41', roomcode: '100001',
      },
    },
    {
      app: 'youle',
      route: 'room',
      rpc: 'self_exit_room',
      data: {
        agentid: 'veRa0qrBf', playerid: 430511, gameid: '41', roomcode: '100001',
      },
    },
  ]);
});

test('stop unsubscribes, disposes while the host is live, invalidates it, then stops the wire', async () => {
  const log: string[] = [];
  const restored: unknown[] = [];
  const attached: GameHost[] = [];
  const entry = makeLoggingEntry(log, restored, attached);
  const setup = makeRuntime(runtimeConfig(), entry);
  setup.wire.onAction = (name) => {
    if (name === 'unsubscribe' || name === 'stop') log.push(`wire:${name}`);
  };
  await setup.runtime.start();
  beginEntryRecording(entry);
  setup.wire.emit({ type: 'open', server: 'ws://agent' });
  setup.runtime.login(ACCOUNT);
  setup.wire.emit({
    type: 'message',
    message: { route: 'agent', rpc: 'player_login', data: fixture('player-login-room.json') },
  });
  const activeHost = attached[0]!;
  log.length = 0;

  setup.runtime.stop();

  assert.deepEqual(log, ['wire:unsubscribe', 'dispose', 'wire:stop']);
  assert.throws(() => activeHost.getSnapshot(), /disposed/i);
  setup.runtime.stop();
  assert.deepEqual(log, ['wire:unsubscribe', 'dispose', 'wire:stop']);
  assert.equal(setup.wire.stopCalls, 1);
});

test('stop continues after clearTimeout and every later cleanup failure in exact order', async () => {
  const clearFailure = { step: 'clock.clearTimeout' };
  const disposeFailure = { step: 'game.dispose' };
  const leaseFailure = { step: 'lease.invalidate' };
  const stopFailure = { step: 'wire.stop' };
  const log: string[] = [];
  const captured: CapturedGameHost = { host: null };
  const clock = new ControlledClearClock();
  const wire = new RecordingWireClient();
  const scene = new RecordingScene();
  const originalStoreSubscribe = PlatformStore.prototype.subscribe;
  PlatformStore.prototype.subscribe = function subscribeWithFailingRelease(listener) {
    const release = originalStoreSubscribe.call(this, listener);
    return () => {
      release();
      log.push('lease:invalidate');
      throw leaseFailure;
    };
  };

  try {
    const runtime = new PlatformRuntime({
      gameEntry: makeCleanupFailureEntry(log, disposeFailure, captured),
      resolveRuntimeConfig: async () => runtimeConfig(),
      createWireClient: () => wire,
      scene,
      loadResources: async () => {},
      waitForMinimumDisplay: async () => {},
      getLoginDeviceSnapshot: () => DEVICE,
      clock,
    });
    clock.onFailingClear = () => { log.push('clock:clear'); };
    wire.onAction = (name) => {
      if (name === 'unsubscribe') {
        log.push('wire:unsubscribe');
        throw undefined;
      }
      if (name === 'stop') {
        log.push('wire:stop');
        const host = captured.host;
        assert.ok(host);
        assert.throws(() => host.getSnapshot(), /disposed/i);
        throw stopFailure;
      }
    };

    await runtime.start();
    wire.emit({ type: 'open', server: 'ws://agent' });
    runtime.login(ACCOUNT);
    wire.emit({
      type: 'message',
      message: { route: 'agent', rpc: 'player_login', data: fixture('player-login-room.json') },
    });
    wire.emit({ type: 'open', server: 'ws://agent' });
    assert.equal(clock.timers.size, 1);
    clock.enableClearFailure(clearFailure);
    log.length = 0;

    const thrown = thrownValue(() => { runtime.stop(); });
    assert.ok(thrown instanceof Error);
    const errors = (thrown as Error & { readonly errors: readonly unknown[] }).errors;
    assert.deepEqual(log, [
      'clock:clear',
      'wire:unsubscribe',
      'game:dispose',
      'lease:invalidate',
      'wire:stop',
    ]);
    assert.equal(errors.length, 5);
    assert.equal(errors[0], clearFailure);
    assert.equal(errors[1], undefined);
    assert.equal(errors[2], disposeFailure);
    assert.equal(errors[3], leaseFailure);
    assert.equal(errors[4], stopFailure);
    assert.equal(scene.calls.filter((call) => call.name === 'fatal').length, 0);

    const completedLog = [...log];
    assert.doesNotThrow(() => { runtime.stop(); });
    assert.deepEqual(log, completedLog);
    assert.equal(wire.stopCalls, 1);
  } finally {
    PlatformStore.prototype.subscribe = originalStoreSubscribe;
  }
});

test('kick completes close, invalidate, clear, kicked scene, and wire stop despite all failures', async () => {
  const disposeFailure = { step: 'game.dispose' };
  const leaseFailure = { step: 'lease.invalidate' };
  const clearFailure = { step: 'clock.clearTimeout' };
  const stopFailure = { step: 'wire.stop' };
  const log: string[] = [];
  const captured: CapturedGameHost = { host: null };
  const clock = new ControlledClearClock();
  const wire = new RecordingWireClient();
  const scene = new RecordingScene();
  const originalStoreSubscribe = PlatformStore.prototype.subscribe;
  PlatformStore.prototype.subscribe = function subscribeWithFailingRelease(listener) {
    const release = originalStoreSubscribe.call(this, listener);
    return () => {
      release();
      log.push('lease:invalidate');
      throw leaseFailure;
    };
  };

  try {
    const runtime = new PlatformRuntime({
      gameEntry: makeCleanupFailureEntry(log, disposeFailure, captured),
      resolveRuntimeConfig: async () => runtimeConfig(),
      createWireClient: () => wire,
      scene,
      loadResources: async () => {},
      waitForMinimumDisplay: async () => {},
      getLoginDeviceSnapshot: () => DEVICE,
      clock,
    });
    clock.onFailingClear = () => { log.push('clock:clear'); };
    scene.onCall = (name) => {
      if (name === 'kicked') {
        log.push('scene:kicked');
        throw undefined;
      }
      if (name === 'fatal') log.push('scene:fatal');
    };
    wire.onAction = (name) => {
      if (name === 'unsubscribe') log.push('wire:unsubscribe');
      if (name === 'stop') {
        log.push('wire:stop');
        const host = captured.host;
        assert.ok(host);
        assert.throws(() => host.getSnapshot(), /disposed/i);
        throw stopFailure;
      }
    };

    await runtime.start();
    wire.emit({ type: 'open', server: 'ws://agent' });
    runtime.login(ACCOUNT);
    wire.emit({
      type: 'message',
      message: { route: 'agent', rpc: 'player_login', data: fixture('player-login-room.json') },
    });
    wire.emit({ type: 'open', server: 'ws://agent' });
    assert.equal(clock.timers.size, 1);
    clock.enableClearFailure(clearFailure);
    log.length = 0;
    const kick = { msg: 'terminal cleanup test', code: 1 };

    wire.emit({
      type: 'message',
      message: { route: 'agent', rpc: 'kick_server', data: kick },
    });

    assert.deepEqual(log, [
      'game:dispose',
      'lease:invalidate',
      'clock:clear',
      'scene:kicked',
      'wire:stop',
      'wire:unsubscribe',
      'scene:fatal',
    ]);
    assert.equal(wire.stopCalls, 1);
    assert.equal(scene.calls.filter((call) => call.name === 'kicked').length, 1);
    assert.equal(scene.calls.find((call) => call.name === 'kicked')?.value, kick);
    const fatal = scene.calls.find((call) => call.name === 'fatal')?.value;
    assert.ok(fatal instanceof Error);
    const sessionErrors = (fatal as Error & { readonly errors: readonly unknown[] }).errors;
    assert.equal(sessionErrors.length, 3);
    assert.equal(sessionErrors[0], disposeFailure);
    assert.equal(sessionErrors[1], leaseFailure);
    const kickCleanup = sessionErrors[2];
    assert.ok(kickCleanup instanceof Error);
    const kickErrors = (
      kickCleanup as Error & { readonly errors: readonly unknown[] }
    ).errors;
    assert.equal(kickErrors.length, 3);
    assert.equal(kickErrors[0], clearFailure);
    assert.equal(kickErrors[1], undefined);
    assert.equal(kickErrors[2], stopFailure);

    const completedLog = [...log];
    assert.doesNotThrow(() => { runtime.stop(); });
    assert.doesNotThrow(() => { runtime.stop(); });
    assert.deepEqual(log, completedLog);
    assert.equal(wire.stopCalls, 1);
  } finally {
    PlatformStore.prototype.subscribe = originalStoreSubscribe;
  }
});

test('real runtime renders the room before restoring canonical deskinfo', async () => {
  const events: string[] = [];
  const wire = new RecordingWireClient();
  const controller = new PlatformUiController({
    render: model => { events.push(`render:${model.page}`); },
    activate: page => { events.push(`activate:${page}`); },
    showOverlay: model => { events.push(`overlay:${model.kind}`); },
  }, { request: () => () => {} }, error => { throw error; });
  const deskinfo = { fixture: 'opaque' };
  const entry = makeGameEntry({ createModule: () => ({
    attach() { events.push('attach'); },
    handlePlatformEvent() {}, handleGameMessage() {}, dispose() {},
    restore(value) { assert.equal(value, deskinfo); events.push('restore'); },
  }) });
  const runtime = new PlatformRuntime({
    gameEntry: entry, resolveRuntimeConfig: async () => runtimeConfig(),
    createWireClient: () => wire, scene: controller,
    loadResources: async () => {}, waitForMinimumDisplay: async () => {},
    getLoginDeviceSnapshot: () => DEVICE, clock: new ManualClock(),
  });
  controller.connect(runtime);
  await runtime.start();
  wire.emit({ type: 'open', server: 'ws://agent' });
  controller.login(ACCOUNT);
  wire.emit({ type: 'message', message: { route: 'agent', rpc: 'player_login',
    data: fixture('player-login-success.json') } });
  controller.joinRoom({ roomcode: '100001', location: null, ip: '127.0.0.1' });
  wire.emit({ type: 'message', message: { route: 'agent', rpc: 'self_join_room',
    data: { ...fixture('self-join-room.json'), deskinfo } } });
  assert.ok(events.includes('render:lobby'));
  assert.ok(events.indexOf('attach') < events.indexOf('render:room'));
  assert.ok(events.indexOf('render:room') < events.indexOf('activate:room'));
  assert.ok(events.indexOf('activate:room') < events.indexOf('restore'));
  controller.dispose(); runtime.stop();
  assert.equal(wire.stopCalls, 1);
});

test('real runtime keeps canonical roots and raw denials while login and join retries succeed', async () => {
  const wire = new RecordingWireClient();
  const overlays: unknown[] = [];
  const controller = new PlatformUiController({
    render: () => {}, activate: () => {},
    showOverlay: model => { overlays.push(model); },
  }, { request: () => () => {} }, error => { throw error; });
  const runtime = new PlatformRuntime({
    gameEntry: makeGameEntry(), resolveRuntimeConfig: async () => runtimeConfig(),
    createWireClient: () => wire, scene: controller,
    loadResources: async () => {}, waitForMinimumDisplay: async () => {},
    getLoginDeviceSnapshot: () => DEVICE, clock: new ManualClock(),
  });
  controller.connect(runtime);
  await runtime.start();
  wire.emit({ type: 'open', server: 'ws://agent' });

  const preLoginRoot = runtime.state;
  controller.login(ACCOUNT);
  const loginDenial = { state: 7, showerror: 1, error: 'Login denied' };
  wire.emit({ type: 'message', message: {
    route: 'agent', rpc: 'player_login', data: loginDenial,
  } });
  assert.equal(runtime.state, preLoginRoot);
  const loginOverlay = overlays[overlays.length - 1] as { kind: string; outcome: { data: unknown } };
  assert.equal(loginOverlay.kind, 'denial');
  assert.equal(loginOverlay.outcome.data, loginDenial);

  const retryAccount = { ...ACCOUNT, openid: 'retry-account' };
  controller.login(retryAccount);
  assert.equal((wire.sent[wire.sent.length - 1]!.data as Record<string, unknown>).openid, 'retry-account');
  wire.emit({ type: 'message', message: {
    route: 'agent', rpc: 'player_login', data: fixture('player-login-success.json'),
  } });
  const lobbyRoot = runtime.state;

  const firstJoin = { roomcode: '999999', location: null, ip: '127.0.0.1' };
  controller.joinRoom(firstJoin);
  const joinDenial = { state: 99, roomcode: '999999', showerror: 1, error: 'No room' };
  wire.emit({ type: 'message', message: {
    route: 'agent', rpc: 'self_join_room', data: joinDenial,
  } });
  assert.equal(runtime.state, lobbyRoot);
  const joinOverlay = overlays[overlays.length - 1] as { kind: string; outcome: { data: unknown } };
  assert.equal(joinOverlay.kind, 'denial');
  assert.equal(joinOverlay.outcome.data, joinDenial);

  controller.joinRoom({ roomcode: '100001', location: null, ip: '127.0.0.1' });
  wire.emit({ type: 'message', message: {
    route: 'agent', rpc: 'self_join_room', data: fixture('self-join-room.json'),
  } });
  assert.equal(runtime.state.room.kind, 'inside');
  assert.equal((overlays[overlays.length - 1] as { kind: string }).kind, 'none');
  controller.dispose(); runtime.stop();
});

test('real runtime restores reconnect overlay and silences UI after kick or fatal', async () => {
  for (const terminal of ['kick', 'fatal'] as const) {
    const wire = new RecordingWireClient();
    const events: string[] = [];
    const controller = new PlatformUiController({
      render: model => { events.push(`render:${model.page}`); },
      activate: page => { events.push(`activate:${page}`); },
      showOverlay: model => { events.push(`overlay:${model.kind}`); },
    }, { request: () => () => {} }, error => { throw error; });
    const runtime = new PlatformRuntime({
      gameEntry: makeGameEntry(), resolveRuntimeConfig: async () => runtimeConfig(),
      createWireClient: () => wire, scene: controller,
      loadResources: async () => {}, waitForMinimumDisplay: async () => {},
      getLoginDeviceSnapshot: () => DEVICE, clock: new ManualClock(),
    });
    controller.connect(runtime);
    await runtime.start();
    wire.emit({ type: 'open', server: 'ws://agent' });
    controller.login(ACCOUNT);
    wire.emit({ type: 'message', message: {
      route: 'agent', rpc: 'player_login', data: fixture('player-login-success.json'),
    } });

    wire.emit({ type: 'slow' });
    assert.equal(events[events.length - 1], 'overlay:reconnect');
    const activations = events.filter(event => event.startsWith('activate:')).length;
    wire.emit({ type: 'open', server: 'ws://agent' });
    assert.equal(events[events.length - 1], 'overlay:none');
    assert.equal(events.filter(event => event.startsWith('activate:')).length, activations);

    if (terminal === 'kick') {
      wire.emit({ type: 'message', message: {
        route: 'agent', rpc: 'kick_server', data: { code: 1, msg: 'terminal' },
      } });
      assert.equal(events[events.length - 1], 'overlay:kicked');
    } else {
      wire.emit({ type: 'message', message: {
        route: 'agent', rpc: 'player_login', data: { state: 0 },
      } });
      assert.equal(events[events.length - 1], 'overlay:fatal');
    }
    const terminalEvents = [...events];
    assert.throws(() => controller.login(ACCOUNT), /terminal/);
    wire.emit({ type: 'slow' });
    wire.emit({ type: 'open', server: 'ws://agent' });
    assert.deepEqual(events, terminalEvents);
    assert.equal(wire.stopCalls, 1);
    controller.dispose(); runtime.stop();
  }
});

test('real runtime alone governs login readiness while resources are pending', async () => {
  const resourcesReady = deferred<void>();
  const wire = new RecordingWireClient();
  const controller = new PlatformUiController({
    render: () => {}, activate: () => {}, showOverlay: () => {},
  }, { request: () => () => {} }, error => { throw error; });
  const runtime = new PlatformRuntime({
    gameEntry: makeGameEntry(), resolveRuntimeConfig: async () => runtimeConfig(),
    createWireClient: () => wire, scene: controller,
    loadResources: () => resourcesReady.promise, waitForMinimumDisplay: async () => {},
    getLoginDeviceSnapshot: () => DEVICE, clock: new ManualClock(),
  });
  controller.connect(runtime);
  const starting = runtime.start();
  await Promise.resolve();
  await Promise.resolve();
  assert.deepEqual(wire.lifecycle, ['subscribe', 'start']);
  wire.emit({ type: 'open', server: 'ws://agent' });
  assert.equal(runtime.ready, false);
  assert.throws(() => controller.login(ACCOUNT), /login page/);
  assert.equal(wire.sent.length, 0);

  resourcesReady.resolve(undefined);
  await starting;
  assert.equal(runtime.ready, true);
  controller.login(ACCOUNT);
  assert.equal(wire.sent.length, 1);
  controller.dispose(); runtime.stop();
});

for (const phase of ['render', 'activate'] as const) {
  test(`real room ${phase} disposal interrupts restore and terminates the runtime`, async () => {
    const wire = new RecordingWireClient();
    let armed = false;
    let restores = 0;
    let controller!: PlatformUiController;
    controller = new PlatformUiController({
      render: model => {
        if (armed && phase === 'render' && model.page === 'room') controller.dispose();
      },
      activate: page => {
        if (armed && phase === 'activate' && page === 'room') controller.dispose();
      },
      showOverlay: () => {},
    }, { request: () => () => {} }, error => { throw error; });
    const runtime = new PlatformRuntime({
      gameEntry: makeGameEntry({ createModule: () => ({
        attach() {}, handlePlatformEvent() {}, handleGameMessage() {}, dispose() {},
        restore() { restores += 1; },
      }) }),
      resolveRuntimeConfig: async () => runtimeConfig(),
      createWireClient: () => wire, scene: controller,
      loadResources: async () => {}, waitForMinimumDisplay: async () => {},
      getLoginDeviceSnapshot: () => DEVICE, clock: new ManualClock(),
    });
    controller.connect(runtime);
    await runtime.start();
    wire.emit({ type: 'open', server: 'ws://agent' });
    controller.login(ACCOUNT);
    wire.emit({ type: 'message', message: {
      route: 'agent', rpc: 'player_login', data: fixture('player-login-success.json'),
    } });
    armed = true;
    controller.joinRoom({ roomcode: '100001', location: null, ip: '127.0.0.1' });
    wire.emit({ type: 'message', message: {
      route: 'agent', rpc: 'self_join_room', data: fixture('self-join-room.json'),
    } });

    assert.equal(restores, 0);
    assert.equal(wire.stopCalls, 1);
    assert.throws(() => runtime.login(ACCOUNT), error => {
      assert.ok(error instanceof Error);
      const errors = (error as Error & { readonly errors: readonly unknown[] }).errors;
      assert.match(String(errors[0]), /lifecycle interrupted/);
      return true;
    });
    runtime.stop();
  });
}

test('application overlay teardown disposes Presenter, stops Runtime, and invalidates a late frame', async () => {
  const wire = new RecordingWireClient();
  const frames: Array<{ callback: () => void; cancelled: boolean }> = [];
  const renders: string[] = [];
  let armed = false;
  let runtime!: PlatformRuntime;
  let controller!: PlatformUiController;
  controller = new PlatformUiController({
    render: model => { renders.push(model.page); },
    activate: () => {},
    showOverlay: model => {
      if (armed && model.kind === 'reconnect') {
        controller.dispose();
        runtime.stop();
      }
    },
  }, { request: callback => {
    const frame = { callback, cancelled: false };
    frames.push(frame);
    return () => { frame.cancelled = true; };
  } }, error => { throw error; });
  runtime = new PlatformRuntime({
    gameEntry: makeGameEntry(), resolveRuntimeConfig: async () => runtimeConfig(),
    createWireClient: () => wire, scene: controller,
    loadResources: async () => {}, waitForMinimumDisplay: async () => {},
    getLoginDeviceSnapshot: () => DEVICE, clock: new ManualClock(),
  });
  controller.connect(runtime);
  await runtime.start();
  wire.emit({ type: 'open', server: 'ws://agent' });
  controller.login(ACCOUNT);
  wire.emit({ type: 'message', message: {
    route: 'agent', rpc: 'player_login', data: fixture('player-login-success.json'),
  } });
  armed = true;
  const framesBeforeStop = frames.length;

  wire.emit({ type: 'slow' });

  assert.equal(frames.length, framesBeforeStop + 1);
  const lateFrame = frames[frames.length - 1]!;
  assert.equal(lateFrame.cancelled, true);
  assert.equal(wire.stopCalls, 1);
  const rendered = [...renders];
  lateFrame.callback();
  wire.emit({ type: 'open', server: 'ws://agent' });
  assert.deepEqual(renders, rendered);
  assert.throws(() => runtime.login(ACCOUNT), /stopped/);
  runtime.stop();
});