fix(platform): serialize runtime session transitions

cocoscreator_projects/framework-tests/architecture/import-boundaries.test.mjs

@@ -1,12 +1,14 @@
 import { afterEach, test } from 'node:test';
 import assert from 'node:assert/strict';
-import { existsSync, readFileSync } from 'node:fs';
+import { existsSync } from 'node:fs';
 import { mkdtemp, mkdir, rm, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import ts from 'typescript';
-import { scanImportBoundaries } from '../../scripts/lib/import-boundaries.mjs';
+import {
+  findCompatibilityDependency,
+  scanImportBoundaries,
+} from '../../scripts/lib/import-boundaries.mjs';
 
 const roots = [];
 
@@ -55,45 +57,13 @@ const legacyRuntimeFiles = new Set([
   'protocol/room-handlers.ts',
 ].map((file) => resolve(frameworkRoot, file)));
 
-function relativeImports(file) {
-  const source = readFileSync(file, 'utf8');
-  const sourceFile = ts.createSourceFile(file, source, ts.ScriptTarget.Latest, false, ts.ScriptKind.TS);
-  const imports = [];
-  const visit = (node) => {
-    let specifier;
-    if ((ts.isImportDeclaration(node) || ts.isExportDeclaration(node))
-      && node.moduleSpecifier && ts.isStringLiteral(node.moduleSpecifier)) {
-      specifier = node.moduleSpecifier.text;
-    } else if (ts.isImportTypeNode(node)
-      && ts.isLiteralTypeNode(node.argument)
-      && ts.isStringLiteral(node.argument.literal)) {
-      specifier = node.argument.literal.text;
-    } else if (ts.isCallExpression(node)
-      && node.expression.kind === ts.SyntaxKind.ImportKeyword
-      && node.arguments.length === 1 && ts.isStringLiteral(node.arguments[0])) {
-      specifier = node.arguments[0].text;
-    }
-    if (specifier?.startsWith('.')) {
-      const imported = resolve(dirname(file), specifier);
-      const candidates = [imported, `${imported}.ts`, join(imported, 'index.ts')];
-      const resolvedImport = candidates.find((candidate) => existsSync(candidate));
-      if (resolvedImport) imports.push(resolvedImport);
-    }
-    ts.forEachChild(node, visit);
-  };
-  ts.forEachChild(sourceFile, visit);
-  return imports;
-}
-
-function findLegacyDependency(entry, path = [], visited = new Set()) {
-  if (legacyRuntimeFiles.has(entry)) return [...path, entry];
-  if (visited.has(entry)) return null;
-  visited.add(entry);
-  for (const imported of relativeImports(entry)) {
-    const found = findLegacyDependency(imported, [...path, entry], visited);
-    if (found) return found;
-  }
-  return null;
+function scanCompatibilityFixture(root, entry = 'framework/protocol/router.ts', tsconfigPath) {
+  return findCompatibilityDependency({
+    entry: join(root, entry),
+    forbiddenFiles: [join(root, 'framework/platform/session.ts')],
+    traversalRoot: join(root, 'framework'),
+    tsconfigPath: tsconfigPath ? join(root, tsconfigPath) : undefined,
+  });
 }
 
 test('every existing modern runtime entry is transitively isolated from the legacy compatibility island', () => {
@@ -103,15 +73,114 @@ test('every existing modern runtime entry is transitively isolated from the lega
   assert.ok(entries.some((file) => file.endsWith(`${join('protocol', 'router.ts')}`)));
 
   for (const entry of entries) {
-    const dependencyPath = findLegacyDependency(entry);
+    const dependency = findCompatibilityDependency({
+      entry,
+      forbiddenFiles: [...legacyRuntimeFiles],
+      traversalRoot: frameworkRoot,
+      tsconfigPath: fileURLToPath(new URL('../../tsconfig.framework.json', import.meta.url)),
+    });
     assert.equal(
-      dependencyPath,
+      dependency,
       null,
-      dependencyPath?.map((file) => file.slice(frameworkRoot.length)).join(' -> '),
+      dependency?.path.map((file) => file.slice(frameworkRoot.length)).join(' -> '),
     );
   }
 });
 
+test('compatibility graph catches static imports, re-exports, and import types through barrels', async () => {
+  const cases = [
+    "import '../platform/session.ts'\n",
+    "export * from '../platform/session.ts'\n",
+    "export type { LegacySession } from '../platform/session.ts'\n",
+    "type Legacy = import('../platform/session.ts').LegacySession\n",
+  ];
+
+  for (const source of cases) {
+    const root = await createFixtureRoot();
+    await writeFixture(root, 'framework/platform/session.ts', 'export interface LegacySession {}\n');
+    await writeFixture(root, 'framework/protocol/barrel.ts', source);
+    await writeFixture(root, 'framework/protocol/router.ts', "export * from './barrel.ts'\n");
+
+    const found = scanCompatibilityFixture(root);
+    assert.equal(found?.kind, 'forbidden', source);
+    assert.deepEqual(
+      found?.path.map((file) => file.replaceAll('\\', '/').split('/framework/')[1]),
+      ['protocol/router.ts', 'protocol/barrel.ts', 'platform/session.ts'],
+      source,
+    );
+  }
+});
+
+test('compatibility graph reports direct and ordinary transitive dependency paths', async () => {
+  const directRoot = await createFixtureRoot();
+  await writeFixture(directRoot, 'framework/platform/session.ts', 'export const legacy = true\n');
+  await writeFixture(directRoot, 'framework/protocol/router.ts', "import '../platform/session.ts'\n");
+  assert.equal(scanCompatibilityFixture(directRoot)?.path.length, 2);
+
+  const transitiveRoot = await createFixtureRoot();
+  await writeFixture(transitiveRoot, 'framework/platform/session.ts', 'export const legacy = true\n');
+  await writeFixture(transitiveRoot, 'framework/protocol/helper.ts', "import '../platform/session.ts'\n");
+  await writeFixture(transitiveRoot, 'framework/protocol/router.ts', "import './helper.ts'\n");
+  assert.equal(scanCompatibilityFixture(transitiveRoot)?.path.length, 3);
+});
+
+test('compatibility graph catches string and no-substitution-template dynamic imports', async () => {
+  for (const source of [
+    "await import('../platform/session.ts')\n",
+    'await import(`../platform/session.ts`)\n',
+  ]) {
+    const root = await createFixtureRoot();
+    await writeFixture(root, 'framework/platform/session.ts', 'export const legacy = true\n');
+    await writeFixture(root, 'framework/protocol/router.ts', source);
+
+    assert.equal(scanCompatibilityFixture(root)?.kind, 'forbidden', source);
+  }
+});
+
+test('compatibility graph resolves tsconfig path aliases to canonical files', async () => {
+  const root = await createFixtureRoot();
+  await writeFixture(root, 'framework/platform/session.ts', 'export const legacy = true\n');
+  await writeFixture(root, 'framework/protocol/router.ts', "import '@legacy/session'\n");
+  await writeFixture(root, 'tsconfig.json', JSON.stringify({
+    compilerOptions: {
+      baseUrl: '.',
+      paths: { '@legacy/*': ['framework/platform/*'] },
+      module: 'ESNext',
+      moduleResolution: 'Bundler',
+      allowImportingTsExtensions: true,
+    },
+  }));
+
+  const found = scanCompatibilityFixture(root, undefined, 'tsconfig.json');
+  assert.equal(found?.kind, 'forbidden');
+  assert.ok(found?.path.at(-1)?.replaceAll('\\', '/').endsWith('/framework/platform/session.ts'));
+});
+
+test('compatibility graph fails closed on a reachable non-static dynamic import', async () => {
+  const root = await createFixtureRoot();
+  await writeFixture(root, 'framework/platform/session.ts', 'export const legacy = true\n');
+  await writeFixture(
+    root,
+    'framework/protocol/router.ts',
+    "const target = '../platform/session.ts'; void import(target)\n",
+  );
+
+  const found = scanCompatibilityFixture(root);
+  assert.equal(found?.kind, 'dynamic');
+  assert.ok(found?.path[0]?.replaceAll('\\', '/').endsWith('/framework/protocol/router.ts'));
+});
+
+test('compatibility graph applies the same isolation to a future platform/runtime.ts entry', async () => {
+  const root = await createFixtureRoot();
+  await writeFixture(root, 'framework/platform/session.ts', 'export const legacy = true\n');
+  await writeFixture(root, 'framework/application/barrel.ts', "export * from '../platform/session.ts'\n");
+  await writeFixture(root, 'framework/platform/runtime.ts', "import '../application/barrel.ts'\n");
+
+  const found = scanCompatibilityFixture(root, 'framework/platform/runtime.ts');
+  assert.equal(found?.kind, 'forbidden');
+  assert.equal(found?.path.length, 3);
+});
+
 test('scanner rejects sdk contracts importing a framework platform path', async () => {
   const root = await createFixtureRoot();
   await writeFixture(root, 'framework/sdk/contracts/bad.ts', "import '../platform/session.ts'\n");

cocoscreator_projects/framework-tests/platform/platform-store.test.ts

@@ -425,13 +425,24 @@ test('replaceRoom atomically replaces the complete room from a parsed DTO', () =
   assert.equal(after.players.entities[430511]?.ip, '127.0.0.1');
 });
 
-test('replaceRoom derives a reconnect stage only from deskinfo presence', () => {
-  for (const deskwar of [undefined, 0] as const) {
+test('replaceRoom consumes the parser-owned deskwar default and reconnect stage matrix', () => {
+  const cases = [
+    { deskwar: 'missing', deskinfo: false, expectedStage: 0 },
+    { deskwar: 0, deskinfo: false, expectedStage: 0 },
+    { deskwar: 1, deskinfo: false, expectedStage: 1 },
+    { deskwar: 'missing', deskinfo: true, expectedStage: 1 },
+    { deskwar: 0, deskinfo: true, expectedStage: 1 },
+    { deskwar: 1, deskinfo: true, expectedStage: 1 },
+  ] as const;
+  for (const row of cases) {
     const store = new PlatformStore();
     store.applyLoginSuccess(parseLoginResponse(fixture('player-login-success.json').data));
     const data = fixture('self-join-room.json').data;
-    if (deskwar === undefined) delete data.deskwar;
-    else data.deskwar = deskwar;
+    if (row.deskwar === 'missing') delete data.deskwar;
+    else data.deskwar = row.deskwar;
+    if (row.deskinfo) data.deskinfo = { round: 7 };
+    else delete data.deskinfo;
+    data.isbattle = 1;
     const parsed = parseSelfJoinRoomResponse(data);
 
     store.replaceRoom(parsed);
@@ -439,7 +450,7 @@ test('replaceRoom derives a reconnect stage only from deskinfo presence', () =>
     const state = store.getState();
     assert.equal(state.room.kind, 'inside');
     if (state.room.kind !== 'inside') continue;
-    assert.equal(state.room.stage, 1);
+    assert.equal(state.room.stage, row.expectedStage, JSON.stringify(row));
   }
 });
 
@@ -458,21 +469,7 @@ test('applyLoginSuccess requires isbattle even when raw deskwar is fabricated',
   assert.equal(notifications, 0);
 });
 
-test('replaceRoom without reconnect requires deskwar and never substitutes isbattle', () => {
-  const successfulStore = new PlatformStore();
-  successfulStore.applyLoginSuccess(
-    parseLoginResponse(fixture('player-login-success.json').data),
-  );
-  const successfulData = fixture('self-join-room.json').data;
-  delete successfulData.deskinfo;
-  successfulData.deskwar = 0;
-  successfulStore.replaceRoom(parseSelfJoinRoomResponse(successfulData));
-  const successfulState = successfulStore.getState();
-  assert.equal(successfulState.room.kind, 'inside');
-  if (successfulState.room.kind === 'inside') {
-    assert.equal(successfulState.room.stage, 0);
-  }
-
+test('replaceRoom never substitutes self-join isbattle for missing deskwar or deskinfo', () => {
   const store = new PlatformStore();
   store.applyLoginSuccess(parseLoginResponse(fixture('player-login-success.json').data));
   const data = fixture('self-join-room.json').data;
@@ -480,13 +477,12 @@ test('replaceRoom without reconnect requires deskwar and never substitutes isbat
   delete data.deskwar;
   data.isbattle = 1;
   const parsed = parseSelfJoinRoomResponse(data);
-  const before = store.getState();
-  let notifications = 0;
-  store.subscribe(() => { notifications += 1; });
 
-  assert.throws(() => store.replaceRoom(parsed), /deskwar/i);
-  assert.equal(store.getState(), before);
-  assert.equal(notifications, 0);
+  store.replaceRoom(parsed);
+
+  const state = store.getState();
+  assert.equal(state.room.kind, 'inside');
+  if (state.room.kind === 'inside') assert.equal(state.room.stage, 0);
 });
 
 test('clearRoom leaves no fabricated room fields and retains only the self entity', () => {

cocoscreator_projects/framework-tests/platform/runtime-session.test.ts

@@ -48,14 +48,20 @@ function makeSession() {
   };
   const gameSession = new GameSessionHost(entry);
   log.length = 0;
-  const gameHost: GameHost = {
-    seat: { toView: (seat) => seat, toServer: (seat) => seat },
-    getSnapshot: () => selectGameSnapshot(store.getState()),
-    subscribe: () => () => {},
-    sendGameMessage() {},
-    execute() {},
-  };
-  const session = new RuntimeSession({ store, gameSession, gameHost });
+  const session = new RuntimeSession({
+    store,
+    gameSession,
+    createGameHostLease: () => ({
+      host: {
+        seat: { toView: (seat) => seat, toServer: (seat) => seat },
+        getSnapshot: () => selectGameSnapshot(store.getState()),
+        subscribe: () => () => {},
+        sendGameMessage() {},
+        execute() {},
+      },
+      invalidate() {},
+    }),
+  });
   return { store, gameSession, session, log, restored, events };
 }
 
@@ -109,3 +115,254 @@ test('RuntimeSession self join commits, opens a fresh session, and restores the
   assert.equal(setup.restored[0], join.deskinfo);
   assert.deepEqual(setup.log, ['store', 'attach', 'event:room.entered', 'restore']);
 });
+
+test('RuntimeSession self join honors the parser-owned deskwar and deskinfo matrix', () => {
+  const cases = [
+    { deskwar: 'missing', deskinfo: false, expectedStage: 0 },
+    { deskwar: 0, deskinfo: false, expectedStage: 0 },
+    { deskwar: 1, deskinfo: false, expectedStage: 1 },
+    { deskwar: 'missing', deskinfo: true, expectedStage: 1 },
+    { deskwar: 0, deskinfo: true, expectedStage: 1 },
+    { deskwar: 1, deskinfo: true, expectedStage: 1 },
+  ] as const;
+
+  for (const row of cases) {
+    const setup = makeSession();
+    setup.session.handleLogin(fixture('player-login-success.json'));
+    const data = fixture('self-join-room.json');
+    if (row.deskwar === 'missing') delete data.deskwar;
+    else data.deskwar = row.deskwar;
+    const deskinfo = { round: 7 };
+    if (row.deskinfo) data.deskinfo = deskinfo;
+    else delete data.deskinfo;
+    data.isbattle = 1;
+
+    setup.session.handleSelfJoin(data);
+
+    const state = setup.store.getState();
+    assert.equal(state.room.kind, 'inside');
+    if (state.room.kind === 'inside') {
+      assert.equal(state.room.stage, row.expectedStage, JSON.stringify(row));
+    }
+    assert.equal(setup.restored.length, row.deskinfo ? 1 : 0, JSON.stringify(row));
+    if (row.deskinfo) assert.equal(setup.restored[0], deskinfo);
+  }
+});
+
+type LeaseFailurePoint =
+  | 'lease-factory'
+  | 'module-create'
+  | 'attach'
+  | 'event'
+  | 'restore'
+  | 'dispose'
+  | 'invalidate';
+
+interface LeaseRecord {
+  readonly host: GameHost;
+  invalidations: number;
+}
+
+function makeLeaseSession() {
+  const store = new PlatformStore();
+  const leases: LeaseRecord[] = [];
+  const attachedHosts: GameHost[] = [];
+  const failures = new Set<LeaseFailurePoint>();
+  const errors = Object.fromEntries([
+    'lease-factory', 'module-create', 'attach', 'event', 'restore', 'dispose', 'invalidate',
+  ].map((point) => [point, new Error(`failure:${point}`)])) as Record<LeaseFailurePoint, Error>;
+  let validatingEntry = true;
+  let moduleDisposals = 0;
+
+  function host(): GameHost {
+    return {
+      seat: { toView: (seat) => seat, toServer: (seat) => seat },
+      getSnapshot: () => selectGameSnapshot(store.getState()),
+      subscribe: () => () => {},
+      sendGameMessage() {},
+      execute() {},
+    };
+  }
+
+  const entry: GameEntry = {
+    key: 'lease-fixture',
+    gameId: 41,
+    route: 'fixture-game',
+    resolveSeatCount: () => 4,
+    createModule: (): GameModule => {
+      if (!validatingEntry && failures.has('module-create')) throw errors['module-create'];
+      return {
+        attach(attachedHost) {
+          if (!validatingEntry) attachedHosts.push(attachedHost);
+          if (!validatingEntry && failures.has('attach')) throw errors.attach;
+        },
+        handlePlatformEvent() {
+          if (!validatingEntry && failures.has('event')) throw errors.event;
+        },
+        handleGameMessage() {},
+        restore() {
+          if (!validatingEntry && failures.has('restore')) throw errors.restore;
+        },
+        dispose() {
+          if (validatingEntry) return;
+          moduleDisposals += 1;
+          if (failures.has('dispose')) throw errors.dispose;
+        },
+      };
+    },
+  };
+  const gameSession = new GameSessionHost(entry);
+  validatingEntry = false;
+  const sessionOptions = {
+    store,
+    gameSession,
+    createGameHostLease() {
+      if (failures.has('lease-factory')) throw errors['lease-factory'];
+      const record: LeaseRecord = { host: host(), invalidations: 0 };
+      leases.push(record);
+      return {
+        host: record.host,
+        invalidate() {
+          record.invalidations += 1;
+          if (failures.has('invalidate')) throw errors.invalidate;
+        },
+      };
+    },
+  };
+  const session = new RuntimeSession(sessionOptions);
+  return {
+    store,
+    gameSession,
+    session,
+    leases,
+    attachedHosts,
+    errors,
+    setFailures(...points: LeaseFailurePoint[]) {
+      failures.clear();
+      for (const point of points) failures.add(point);
+    },
+    getModuleDisposals: () => moduleDisposals,
+  };
+}
+
+function caughtError(operation: () => void): Error {
+  try {
+    operation();
+  } catch (error) {
+    assert.ok(error instanceof Error);
+    return error;
+  }
+  assert.fail('expected operation to throw');
+}
+
+test('RuntimeSession creates a fresh host lease per login/self-join replacement and invalidates on self exit', () => {
+  const setup = makeLeaseSession();
+
+  setup.session.handleLogin(fixture('player-login-room.json'));
+  setup.session.handleSelfJoin(fixture('self-join-room.json'));
+  setup.session.handleLogin(fixture('player-login-room.json'));
+
+  assert.equal(setup.leases.length, 3);
+  assert.equal(new Set(setup.attachedHosts).size, 3);
+  assert.deepEqual(setup.leases.map((lease) => lease.invalidations), [1, 1, 0]);
+  assert.equal(setup.attachedHosts[0], setup.leases[0]?.host);
+  assert.equal(setup.attachedHosts[1], setup.leases[1]?.host);
+  assert.equal(setup.attachedHosts[2], setup.leases[2]?.host);
+
+  setup.session.handleSelfExit({ raw: {} });
+
+  assert.deepEqual(setup.leases.map((lease) => lease.invalidations), [1, 1, 1]);
+  assert.equal(setup.gameSession.state, 'idle');
+  assert.equal(setup.session.state, 'operational');
+});
+
+test('RuntimeSession invalidates the active lease on a successful server switch', () => {
+  const setup = makeLeaseSession();
+  setup.session.handleLogin(fixture('player-login-room.json'));
+
+  setup.session.handleServerSwitch(() => {});
+
+  assert.equal(setup.leases[0]?.invalidations, 1);
+  assert.equal(setup.gameSession.state, 'idle');
+  assert.equal(setup.session.state, 'operational');
+});
+
+for (const failure of [
+  'lease-factory', 'module-create', 'attach', 'event', 'restore',
+] as const) {
+  test(`RuntimeSession cleans a failed room open and enters terminal fault at ${failure}`, () => {
+    const setup = makeLeaseSession();
+    setup.setFailures(failure);
+
+    const error = caughtError(() => setup.session.handleLogin(fixture('player-login-room.json')));
+
+    assert.equal(setup.session.state, 'faulted');
+    assert.equal(setup.session.fault, error);
+    assert.equal(setup.gameSession.state, 'idle');
+    if (failure === 'lease-factory') {
+      assert.equal(setup.leases.length, 0);
+    } else {
+      assert.equal(setup.leases.length, 1);
+      assert.equal(setup.leases[0]?.invalidations, 1);
+    }
+    assert.throws(
+      () => setup.session.handleLogin(fixture('player-login-success.json')),
+      /fault/i,
+    );
+  });
+}
+
+for (const replacement of ['login', 'self-join'] as const) {
+  test(`RuntimeSession invalidates the old lease and faults when ${replacement} replacement disposal fails`, () => {
+    const setup = makeLeaseSession();
+    setup.session.handleLogin(fixture('player-login-room.json'));
+    setup.setFailures('dispose');
+
+    const error = caughtError(() => {
+      if (replacement === 'login') setup.session.handleLogin(fixture('player-login-room.json'));
+      else setup.session.handleSelfJoin(fixture('self-join-room.json'));
+    });
+
+    assert.equal(setup.session.state, 'faulted');
+    assert.equal(setup.session.fault, error);
+    assert.equal(setup.gameSession.state, 'idle');
+    assert.equal(setup.leases.length, 1, 'a failed old-session cleanup must not create a new lease');
+    assert.equal(setup.leases[0]?.invalidations, 1);
+    assert.equal(setup.getModuleDisposals(), 1);
+  });
+}
+
+for (const operation of ['self-exit', 'switch'] as const) {
+  test(`RuntimeSession invalidates once and faults when ${operation} disposal fails`, () => {
+    const setup = makeLeaseSession();
+    setup.session.handleLogin(fixture('player-login-room.json'));
+    setup.setFailures('dispose');
+
+    const error = caughtError(() => {
+      if (operation === 'self-exit') setup.session.handleSelfExit({ raw: {} });
+      else setup.session.handleServerSwitch(() => {});
+    });
+
+    assert.equal(setup.session.state, 'faulted');
+    assert.equal(setup.session.fault, error);
+    assert.equal(setup.gameSession.state, 'idle');
+    assert.equal(setup.leases[0]?.invalidations, 1);
+    assert.equal(setup.getModuleDisposals(), 1);
+  });
+}
+
+test('RuntimeSession aggregates event, dispose, and invalidation failures after completing cleanup', () => {
+  const setup = makeLeaseSession();
+  setup.setFailures('event', 'dispose', 'invalidate');
+
+  const error = caughtError(() => setup.session.handleLogin(fixture('player-login-room.json')));
+
+  assert.equal(setup.session.state, 'faulted');
+  assert.equal(setup.session.fault, error);
+  assert.equal(setup.gameSession.state, 'idle');
+  assert.equal(setup.leases[0]?.invalidations, 1);
+  assert.deepEqual(
+    (error as Error & { errors?: readonly unknown[] }).errors,
+    [setup.errors.event, setup.errors.dispose, setup.errors.invalidate],
+  );
+});

cocoscreator_projects/framework-tests/protocol/contracts.test.ts

@@ -15,6 +15,7 @@ import {
   parseOtherOfflinePayload,
   parseOtherOnlinePayload,
   parsePlayerPreparePayload,
+  parseSelfExitRoomPayload,
   parseSelfJoinRoomResponse,
 } from '../../YouleNexus/assets/framework/protocol/contracts/index.ts';
 
@@ -214,6 +215,38 @@ test('parseSelfJoinRoomResponse 接受金样，不深验 roomtype/deskinfo 并
   assert.equal(parsed.reconnect.present && parsed.reconnect.value, opaqueDeskinfo);
 });
 
+test('parseSelfJoinRoomResponse defines the optional deskwar default once and deskinfo wins stage', () => {
+  const cases = [
+    { deskwar: 'missing', deskinfo: false, expectedStage: 0 },
+    { deskwar: 0, deskinfo: false, expectedStage: 0 },
+    { deskwar: 1, deskinfo: false, expectedStage: 1 },
+    { deskwar: 'missing', deskinfo: true, expectedStage: 1 },
+    { deskwar: 0, deskinfo: true, expectedStage: 1 },
+    { deskwar: 1, deskinfo: true, expectedStage: 1 },
+  ] as const;
+
+  for (const row of cases) {
+    const data = fixture('self-join-room.json').data;
+    if (row.deskwar === 'missing') delete data.deskwar;
+    else data.deskwar = row.deskwar;
+    if (row.deskinfo) data.deskinfo = { round: 7 };
+    else delete data.deskinfo;
+    data.isbattle = 1;
+
+    const parsed = parseSelfJoinRoomResponse(data);
+
+    assert.equal(parsed.stage, row.expectedStage, JSON.stringify(row));
+    assert.equal(parsed.reconnect.present, row.deskinfo, JSON.stringify(row));
+  }
+
+  for (const deskwar of [-1, 2, 1.5, '1', undefined]) {
+    assert.throws(
+      () => parseSelfJoinRoomResponse({ ...fixture('self-join-room.json').data, deskwar }),
+      /\$\.data\.deskwar/,
+    );
+  }
+});
+
 test('房间请求 builder 使用唯一 route，并仅发协议定义字段', () => {
   const room = { playerid: 430511, roomcode: '100001' };
   assert.deepEqual(buildPrepareRequest(runtimeConfig, room), {
@@ -311,6 +344,23 @@ test('座位事件 parser 校验实际消费字段并保留 raw', () => {
   assert.throws(() => parseOtherOnlinePayload({ seat: 1 }), /\$\.data\.ip.*undefined/);
 });
 
+test('self_exit_room parser accepts an omitted seat but strictly validates it when present', () => {
+  const withoutSeat = { isowner: 1, roomcode: '100001', extension: 'kept' };
+  const parsedWithoutSeat = parseSelfExitRoomPayload(withoutSeat);
+  assert.equal(parsedWithoutSeat.raw, withoutSeat);
+  assert.equal(Object.prototype.hasOwnProperty.call(parsedWithoutSeat, 'seat'), false);
+
+  const withSeat = { seat: 1, extension: 'kept' };
+  const parsedWithSeat = parseSelfExitRoomPayload(withSeat);
+  assert.equal(parsedWithSeat.raw, withSeat);
+  assert.equal(parsedWithSeat.seat, 1);
+
+  for (const seat of [-1, 1.2, '1', undefined]) {
+    assert.throws(() => parseSelfExitRoomPayload({ seat }), /\$\.data\.seat/);
+  }
+  assert.throws(() => parseOtherExitRoomPayload({}), /\$\.data\.seat/);
+});
+
 test('切服与踢出 parser 拒绝畸形载荷并保留未知扩展', () => {
   const roomSwitch = { roomserver: '127.0.0.1:9001', epoch: 7 };
   assert.deepEqual(parseConnectRoomserverPayload(roomSwitch), {

cocoscreator_projects/framework-tests/protocol/platform-handlers.test.ts

@@ -11,7 +11,10 @@ import type {
 } from '../../YouleNexus/assets/framework/sdk/contracts/index.ts';
 import { GameSessionHost } from '../../YouleNexus/assets/framework/sdk/runtime/game-session-host.ts';
 import type { ConnectionControlPort } from '../../YouleNexus/assets/framework/platform/connection-intent.ts';
-import { RuntimeSession } from '../../YouleNexus/assets/framework/platform/runtime-session.ts';
+import {
+  RuntimeSession,
+  RuntimeSessionFault,
+} from '../../YouleNexus/assets/framework/platform/runtime-session.ts';
 import { PlatformStore } from '../../YouleNexus/assets/framework/platform/stores/platform-store.ts';
 import { selectGameSnapshot } from '../../YouleNexus/assets/framework/platform/stores/selectors.ts';
 import { PlatformHandlers } from '../../YouleNexus/assets/framework/protocol/platform-handlers.ts';
@@ -21,15 +24,35 @@ function fixture(name: string): Record<string, unknown> {
   return JSON.parse(readFileSync(new URL(`../fixtures/contracts/${name}`, import.meta.url), 'utf8')).data;
 }
 
+function caughtError(operation: () => void): Error {
+  try {
+    operation();
+  } catch (error) {
+    assert.ok(error instanceof Error);
+    return error;
+  }
+  assert.fail('expected operation to throw');
+}
+
 class ConnectionFixture implements ConnectionControlPort {
   readonly switchCalls: Array<{ target: string; resend: OutboundEnvelope }> = [];
   readonly stopCalls: unknown[] = [];
+  switchFailure: Error | undefined;
+  switchObserver: () => void = () => {};
+  stopFailure: Error | undefined;
+  stopObserver: () => void = () => {};
 
   switchServer(target: string, resend: OutboundEnvelope): void {
     this.switchCalls.push({ target, resend });
+    this.switchObserver();
+    if (this.switchFailure) throw this.switchFailure;
   }
 
-  stopForKick(data: unknown): void { this.stopCalls.push(data); }
+  stopForKick(data: unknown): void {
+    this.stopCalls.push(data);
+    this.stopObserver();
+    if (this.stopFailure) throw this.stopFailure;
+  }
 }
 
 function makeHandlers() {
@@ -40,6 +63,8 @@ function makeHandlers() {
     snapshot: PlatformGameSnapshot,
   ) => void = () => {};
   let disposalObserver: () => void = () => {};
+  let invalidationObserver: () => void = () => {};
+  let invalidations = 0;
   const entry: GameEntry = {
     key: 'fixture', gameId: 41, route: 'fixture-game', resolveSeatCount: () => 4,
     createModule: (): GameModule => ({
@@ -54,12 +79,21 @@ function makeHandlers() {
   };
   const gameSession = new GameSessionHost(entry);
   disposals = 0;
-  const gameHost: GameHost = {
-    seat: { toView: (seat) => seat, toServer: (seat) => seat },
-    getSnapshot: () => selectGameSnapshot(store.getState()),
-    subscribe: () => () => {}, sendGameMessage() {}, execute() {},
-  };
-  const session = new RuntimeSession({ store, gameSession, gameHost });
+  const session = new RuntimeSession({
+    store,
+    gameSession,
+    createGameHostLease: () => ({
+      host: {
+        seat: { toView: (seat) => seat, toServer: (seat) => seat },
+        getSnapshot: () => selectGameSnapshot(store.getState()),
+        subscribe: () => () => {}, sendGameMessage() {}, execute() {},
+      },
+      invalidate() {
+        invalidations += 1;
+        invalidationObserver();
+      },
+    }),
+  });
   const connection = new ConnectionFixture();
   const handlers = new PlatformHandlers({ store, gameSession, session, connection });
   const router = new Router({ session, platform: handlers, gameSession });
@@ -71,11 +105,169 @@ function makeHandlers() {
     handlers,
     router,
     getDisposals: () => disposals,
+    getInvalidations: () => invalidations,
     observeEvent(observer: typeof eventObserver) { eventObserver = observer; },
     observeDisposal(observer: () => void) { disposalObserver = observer; },
+    observeInvalidation(observer: () => void) { invalidationObserver = observer; },
   };
 }
 
+function makeReentrantRouterFixture(log: string[]) {
+  const store = new PlatformStore();
+  let nextModuleId = 0;
+  const restores: Array<{ moduleId: number; deskinfo: unknown }> = [];
+  const entry: GameEntry = {
+    key: 'reentrant-fixture',
+    gameId: 41,
+    route: 'fixture-game',
+    resolveSeatCount: () => 4,
+    createModule: (): GameModule => {
+      const moduleId = ++nextModuleId;
+      let host: GameHost | undefined;
+      return {
+        attach(attachedHost) {
+          host = attachedHost;
+          log.push(`attach:${moduleId}:${attachedHost.getSnapshot().room.roomcode}`);
+        },
+        handlePlatformEvent(event) {
+          if (!host) throw new Error('fixture module has no host');
+          const snapshot = host.getSnapshot();
+          if (event.type === 'room.entered') {
+            log.push(`event:${moduleId}:room.entered:${snapshot.room.roomcode}`);
+            return;
+          }
+          if (event.type === 'room.player-offline' || event.type === 'room.player-online') {
+            const online = snapshot.seats.find((seat) => seat.seat === event.seat)?.online;
+            log.push(`event:${moduleId}:${event.type}:${String(online)}`);
+          }
+        },
+        handleGameMessage() {},
+        restore(deskinfo) {
+          restores.push({ moduleId, deskinfo });
+          log.push(`restore:${moduleId}`);
+        },
+        dispose() { log.push(`dispose:${moduleId}`); },
+      };
+    },
+  };
+  const gameSession = new GameSessionHost(entry);
+  nextModuleId = 0;
+  log.length = 0;
+  const session = new RuntimeSession({
+    store,
+    gameSession,
+    createGameHostLease: () => ({
+      host: {
+        seat: { toView: (seat) => seat, toServer: (seat) => seat },
+        getSnapshot: () => selectGameSnapshot(store.getState()),
+        subscribe: () => () => {},
+        sendGameMessage() {},
+        execute() {},
+      },
+      invalidate() {},
+    }),
+  });
+  const connection = new ConnectionFixture();
+  const handlers = new PlatformHandlers({ store, gameSession, session, connection });
+  const router = new Router({ session, platform: handlers, gameSession });
+  return { store, session, gameSession, router, restores };
+}
+
+test('Router drains reentrant room entries FIFO so each module receives its own committed room and deskinfo', () => {
+  const log: string[] = [];
+  const setup = makeReentrantRouterFixture(log);
+  setup.router.dispatch({
+    route: 'agent', rpc: 'player_login', data: fixture('player-login-success.json'),
+  });
+  const roomA = fixture('self-join-room.json');
+  const roomB = fixture('self-join-room.json');
+  roomA.roomcode = 'room-A';
+  roomB.roomcode = 'room-B';
+  roomA.deskinfo = { round: 'A' };
+  roomB.deskinfo = { round: 'B' };
+  let queuedResult: ReturnType<Router['dispatch']> | undefined;
+
+  setup.store.subscribe((state) => {
+    if (state.room.kind === 'inside' && state.room.roomcode === 'room-A') {
+      log.push('store:A');
+      queuedResult = setup.router.dispatch({
+        route: 'agent', rpc: 'self_join_room', data: roomB,
+      });
+    } else if (state.room.kind === 'inside' && state.room.roomcode === 'room-B') {
+      log.push('store:B');
+    }
+  });
+
+  const result = setup.router.dispatch({
+    route: 'agent', rpc: 'self_join_room', data: roomA,
+  });
+
+  assert.equal(result, 'handled-platform');
+  assert.equal(queuedResult, 'handled-platform');
+  assert.deepEqual(log, [
+    'store:A',
+    'attach:1:room-A',
+    'event:1:room.entered:room-A',
+    'restore:1',
+    'store:B',
+    'dispose:1',
+    'attach:2:room-B',
+    'event:2:room.entered:room-B',
+    'restore:2',
+  ]);
+  assert.deepEqual(setup.restores, [
+    { moduleId: 1, deskinfo: roomA.deskinfo },
+    { moduleId: 2, deskinfo: roomB.deskinfo },
+  ]);
+  assert.equal(setup.restores[0]?.deskinfo, roomA.deskinfo);
+  assert.equal(setup.restores[1]?.deskinfo, roomB.deskinfo);
+});
+
+test('Router finishes an offline state-first event before draining a reentrant online message', () => {
+  const log: string[] = [];
+  const setup = makeReentrantRouterFixture(log);
+  setup.router.dispatch({
+    route: 'agent', rpc: 'player_login', data: fixture('player-login-room.json'),
+  });
+  setup.router.dispatch({
+    route: 'room',
+    rpc: 'other_join_room',
+    data: {
+      seat: 2, playerid: 77, nickname: '对家', avatar: 'http://b', sex: 1,
+      ip: '127.0.0.2', onstate: 0, bean: 90, isprepare: 0,
+    },
+  });
+  log.length = 0;
+  let queuedResult: ReturnType<Router['dispatch']> | undefined;
+
+  setup.store.subscribe((state, previous) => {
+    if (state.room.kind !== 'inside' || previous.room.kind !== 'inside') return;
+    const wasOffline = previous.room.offlineSeats.includes(2);
+    const isOffline = state.room.offlineSeats.includes(2);
+    if (!wasOffline && isOffline) {
+      log.push('store:offline');
+      queuedResult = setup.router.dispatch({
+        route: 'room', rpc: 'other_online', data: { seat: 2, ip: '127.0.0.3' },
+      });
+    } else if (wasOffline && !isOffline) {
+      log.push('store:online');
+    }
+  });
+
+  const result = setup.router.dispatch({
+    route: 'room', rpc: 'other_offline', data: { seat: 2 },
+  });
+
+  assert.equal(result, 'handled-platform');
+  assert.equal(queuedResult, 'handled-platform');
+  assert.deepEqual(log, [
+    'store:offline',
+    'event:1:room.player-offline:false',
+    'store:online',
+    'event:1:room.player-online:true',
+  ]);
+});
+
 test('PlatformHandlers commits every room event before one typed game event reads the snapshot', () => {
   const setup = makeHandlers();
   setup.handlers.dispatch({
@@ -172,6 +364,41 @@ test('self_exit_room commits the outside snapshot before disposing the game sess
   assert.equal(setup.gameSession.state, 'idle');
 });
 
+test('self_exit_room accepts omitted seat, validates a present seat, and is idempotent outside', () => {
+  const setup = makeHandlers();
+  setup.router.dispatch({
+    route: 'agent', rpc: 'player_login', data: fixture('player-login-room.json'),
+  });
+  const inside = setup.store.getState();
+  const disposalsBefore = setup.getDisposals();
+
+  assert.throws(
+    () => setup.router.dispatch({ route: 'room', rpc: 'self_exit_room', data: { seat: 0 } }),
+    /self_exit_room.*seat.*expected 1.*received 0/i,
+  );
+  assert.equal(setup.store.getState(), inside);
+  assert.equal(setup.gameSession.state, 'active');
+  assert.equal(setup.getDisposals(), disposalsBefore);
+
+  let notifications = 0;
+  setup.store.subscribe(() => { notifications += 1; });
+  assert.equal(
+    setup.router.dispatch({ route: 'room', rpc: 'self_exit_room', data: { reason: 'done' } }),
+    'handled-platform',
+  );
+  assert.equal(setup.store.getState().room.kind, 'outside');
+  assert.equal(setup.gameSession.state, 'idle');
+  assert.equal(notifications, 1);
+  assert.equal(setup.getDisposals(), disposalsBefore + 1);
+
+  assert.equal(
+    setup.router.dispatch({ route: 'room', rpc: 'self_exit_room', data: { reason: 'duplicate' } }),
+    'handled-platform',
+  );
+  assert.equal(notifications, 1);
+  assert.equal(setup.getDisposals(), disposalsBefore + 1);
+});
+
 test('PlatformHandlers preserves complete switch payloads and builds the exact resend envelopes', () => {
   const setup = makeHandlers();
   const roomData = { roomserver: '10.0.0.2:3088', epoch: 7 };
@@ -227,6 +454,142 @@ test('PlatformHandlers rejects unknown, route-mismatched, missing, and invalid s
   assert.deepEqual(setup.connection.switchCalls, []);
 });
 
+test('unknown and every route-mismatched platform rpc leave all observable state unchanged', () => {
+  const setup = makeHandlers();
+  setup.router.dispatch({
+    route: 'agent', rpc: 'player_login', data: fixture('player-login-room.json'),
+  });
+  const before = setup.store.getState();
+  let notifications = 0;
+  let gameEvents = 0;
+  setup.store.subscribe(() => { notifications += 1; });
+  setup.observeEvent(() => { gameEvents += 1; });
+  const rpcsByRoute = [
+    ['player_login', 'agent'],
+    ['self_join_room', 'agent'],
+    ['player_prepare', 'room'],
+    ['self_exit_room', 'room'],
+    ['other_join_room', 'room'],
+    ['other_exit_room', 'room'],
+    ['other_offline', 'room'],
+    ['other_online', 'room'],
+    ['connect_roomserver', 'room'],
+    ['connect_agentserver', 'agent'],
+    ['kick_server', 'agent'],
+  ] as const;
+
+  for (const route of ['platform', 'agent', 'room'] as const) {
+    assert.throws(
+      () => setup.router.dispatch({ route, rpc: 'unknown_rpc', data: {} }),
+      /unsupported.*unknown_rpc/i,
+      `${route}:unknown_rpc`,
+    );
+  }
+  for (const [rpc, expectedRoute] of rpcsByRoute) {
+    for (const route of ['platform', 'agent', 'room'] as const) {
+      if (route === expectedRoute) continue;
+      assert.throws(
+        () => setup.router.dispatch({ route, rpc, data: {} }),
+        /route mismatch/i,
+        `${route}:${rpc}`,
+      );
+    }
+  }
+
+  assert.equal(setup.store.getState(), before);
+  assert.equal(setup.gameSession.state, 'active');
+  assert.equal(setup.session.state, 'operational');
+  assert.equal(notifications, 0);
+  assert.equal(gameEvents, 0);
+  assert.equal(setup.getDisposals(), 0);
+  assert.equal(setup.getInvalidations(), 0);
+  assert.deepEqual(setup.connection.switchCalls, []);
+  assert.deepEqual(setup.connection.stopCalls, []);
+});
+
+test('PlatformHandlers validates every switch URL before closing the active game', () => {
+  const invalidTargets = [
+    'http://invalid.example',
+    'ws://user@example.com',
+    'ws://example.com/#fragment',
+    'ws:///path',
+    'ws://example.com:99999',
+    'ws://example.com:abc',
+    'ws://',
+  ];
+
+  for (const roomserver of invalidTargets) {
+    const setup = makeHandlers();
+    setup.router.dispatch({
+      route: 'agent', rpc: 'player_login', data: fixture('player-login-room.json'),
+    });
+    const before = setup.store.getState();
+
+    assert.throws(
+      () => setup.router.dispatch({
+        route: 'room', rpc: 'connect_roomserver', data: { roomserver },
+      }),
+      /roomserver|WebSocket/i,
+      roomserver,
+    );
+
+    assert.equal(setup.store.getState(), before, roomserver);
+    assert.equal(setup.gameSession.state, 'active', roomserver);
+    assert.equal(setup.session.state, 'operational', roomserver);
+    assert.equal(setup.getDisposals(), 0, roomserver);
+    assert.equal(setup.getInvalidations(), 0, roomserver);
+    assert.deepEqual(setup.connection.switchCalls, [], roomserver);
+  }
+});
+
+test('PlatformHandlers accepts case-insensitive WS/WSS schemes and preserves full payload identity', () => {
+  const setup = makeHandlers();
+  const roomData = { roomserver: 'WS://EXAMPLE.com:80/path?x=1', extra: { trace: 1 } };
+  const agentData = {
+    agentserver: 'WSS://secure.example:443/socket', opt: 'free_room', extra: { trace: 2 },
+  };
+
+  setup.router.dispatch({ route: 'room', rpc: 'connect_roomserver', data: roomData });
+  setup.router.dispatch({ route: 'agent', rpc: 'connect_agentserver', data: agentData });
+
+  assert.equal(setup.connection.switchCalls[0]?.target, roomData.roomserver);
+  assert.equal(setup.connection.switchCalls[0]?.resend.data, roomData);
+  assert.equal(setup.connection.switchCalls[1]?.target, agentData.agentserver);
+  assert.equal(setup.connection.switchCalls[1]?.resend.data, agentData);
+  assert.equal(
+    (setup.connection.switchCalls[1]?.resend.data as typeof agentData).extra,
+    agentData.extra,
+  );
+});
+
+test('PlatformHandlers attempts a validated switch after cleanup errors and aggregates all failures', () => {
+  const setup = makeHandlers();
+  setup.router.dispatch({
+    route: 'agent', rpc: 'player_login', data: fixture('player-login-room.json'),
+  });
+  const data = { roomserver: 'wss://switch.example/socket', epoch: 9 };
+  const disposeError = new Error('switch:dispose');
+  const invalidateError = new Error('switch:invalidate');
+  const switchError = new Error('switch:connection');
+  setup.observeDisposal(() => { throw disposeError; });
+  setup.observeInvalidation(() => { throw invalidateError; });
+  setup.connection.switchFailure = switchError;
+
+  const error = caughtError(() => setup.router.dispatch({
+    route: 'room', rpc: 'connect_roomserver', data,
+  }));
+
+  assert.ok(error instanceof RuntimeSessionFault);
+  assert.deepEqual(error.errors, [disposeError, invalidateError, switchError]);
+  assert.equal(setup.gameSession.state, 'idle');
+  assert.equal(setup.session.state, 'faulted');
+  assert.equal(setup.getDisposals(), 1);
+  assert.equal(setup.getInvalidations(), 1);
+  assert.equal(setup.connection.switchCalls.length, 1);
+  assert.equal(setup.connection.switchCalls[0]?.target, data.roomserver);
+  assert.equal(setup.connection.switchCalls[0]?.resend.data, data);
+});
+
 test('kick_server closes the game, marks the runtime session, and stops the connection once', () => {
   const setup = makeHandlers();
   setup.handlers.dispatch({ route: 'agent', rpc: 'player_login', data: fixture('player-login-room.json') });
@@ -242,3 +605,64 @@ test('kick_server closes the game, marks the runtime session, and stops the conn
   assert.deepEqual(setup.connection.stopCalls, [kickData]);
   assert.equal(setup.connection.stopCalls[0], kickData);
 });
+
+test('kick_server latches before cleanup and makes a reentrant duplicate a no-op', () => {
+  const setup = makeHandlers();
+  setup.router.dispatch({ route: 'agent', rpc: 'player_login', data: fixture('player-login-room.json') });
+  const kickData = { msg: 'same-reference' };
+  let reentrantResult: ReturnType<Router['dispatch']> | undefined;
+
+  setup.session.markLoginPending();
+  setup.observeDisposal(() => {
+    assert.equal(setup.session.kicked, true);
+    assert.equal(setup.session.loginPending, false);
+    reentrantResult = setup.router.dispatch({ route: 'agent', rpc: 'kick_server', data: kickData });
+  });
+
+  assert.equal(
+    setup.router.dispatch({ route: 'agent', rpc: 'kick_server', data: kickData }),
+    'handled-platform',
+  );
+  assert.equal(reentrantResult, 'handled-platform');
+  assert.equal(setup.getDisposals(), 1);
+  assert.equal(setup.getInvalidations(), 1);
+  assert.equal(setup.connection.stopCalls.length, 1);
+  assert.equal(setup.connection.stopCalls[0], kickData);
+  assert.equal(setup.session.state, 'kicked');
+});
+
+test('kick_server attempts dispose, invalidate, mark, and stop once then aggregates failures', () => {
+  const setup = makeHandlers();
+  setup.router.dispatch({ route: 'agent', rpc: 'player_login', data: fixture('player-login-room.json') });
+  const kickData = { msg: 'cleanup-failures' };
+  const disposeError = new Error('kick:dispose');
+  const invalidateError = new Error('kick:invalidate');
+  const stopError = new Error('kick:stop');
+  setup.observeDisposal(() => { throw disposeError; });
+  setup.observeInvalidation(() => { throw invalidateError; });
+  setup.connection.stopFailure = stopError;
+  setup.session.markLoginPending();
+
+  const error = caughtError(
+    () => setup.router.dispatch({ route: 'agent', rpc: 'kick_server', data: kickData }),
+  );
+
+  assert.ok(error instanceof RuntimeSessionFault);
+  assert.deepEqual(error.errors, [disposeError, invalidateError, stopError]);
+  assert.equal(setup.gameSession.state, 'idle');
+  assert.equal(setup.session.kicked, true);
+  assert.equal(setup.session.state, 'kicked');
+  assert.equal(setup.session.loginPending, false);
+  assert.equal(setup.getDisposals(), 1);
+  assert.equal(setup.getInvalidations(), 1);
+  assert.equal(setup.connection.stopCalls.length, 1);
+  assert.equal(setup.connection.stopCalls[0], kickData);
+
+  assert.equal(
+    setup.router.dispatch({ route: 'agent', rpc: 'kick_server', data: kickData }),
+    'handled-platform',
+  );
+  assert.equal(setup.getDisposals(), 1);
+  assert.equal(setup.getInvalidations(), 1);
+  assert.equal(setup.connection.stopCalls.length, 1);
+});

cocoscreator_projects/framework-tests/protocol/router.test.ts

@@ -9,6 +9,7 @@ import type {
 } from '../../YouleNexus/assets/framework/sdk/contracts/index.ts';
 import { GameSessionHost } from '../../YouleNexus/assets/framework/sdk/runtime/game-session-host.ts';
 import { Router } from '../../YouleNexus/assets/framework/protocol/router.ts';
+import { FIRST_SLICE_RPC_ROUTE } from '../../YouleNexus/assets/framework/protocol/first-slice-routes.ts';
 
 class LoginGateFixture {
   private pending = false;
@@ -110,6 +111,41 @@ test('Router lets kick_server through the login gate but ignores every other rpc
   assert.deepEqual(calls, [kick]);
 });
 
+test('Router login gate enforces the complete route by rpc cross matrix', () => {
+  const platformRoutes = ['platform', 'agent', 'room'] as const;
+  const routes = [...platformRoutes, 'fixture-game'] as const;
+  const rpcs = [...Object.keys(FIRST_SLICE_RPC_ROUTE), 'unknown_rpc'];
+
+  for (const route of routes) {
+    for (const rpc of rpcs) {
+      const gate = new LoginGateFixture();
+      const platformCalls: InboundMessage[] = [];
+      const gameCalls: InboundMessage[] = [];
+      const router = new Router({
+        session: gate,
+        platform: {
+          dispatch(message: InboundMessage) {
+            platformCalls.push(message);
+            return 'handled-platform' as const;
+          },
+        },
+        gameSession: makeGameSession(gameCalls),
+      });
+      const message: InboundMessage = { route, rpc, data: { marker: `${route}:${rpc}` } };
+      gate.markLoginPending();
+
+      const passes = route === 'agent' && (rpc === 'player_login' || rpc === 'kick_server');
+      assert.equal(
+        router.dispatch(message),
+        passes ? 'handled-platform' : 'ignored-login-gate',
+        `${route}:${rpc}`,
+      );
+      assert.deepEqual(platformCalls, passes ? [message] : [], `${route}:${rpc}`);
+      assert.deepEqual(gameCalls, [], `${route}:${rpc}`);
+    }
+  }
+});
+
 test('Router sends all platform routes to PlatformHandlers exactly once', () => {
   const gate = new LoginGateFixture();
   const calls: InboundMessage[] = [];