castle-web-cli 0.4.170 → 0.4.171

package/kits/turn-based/testing.js

@@ -49,13 +49,49 @@ register(import.meta.url);
 //   - messages cross as JSON, so a payload holding a live reference to server
 //     state arrives as a copy, and an unstringifiable one throws here.
 //
-// It is not a transport. Callbacks run synchronously and a returned promise is
-// not awaited; a two-client game over the real socket is the wider test.
+// It is not a transport. `join` and `leave` await the deck's callback, because
+// a join reads storage; a two-client game over the real socket is the wider test.
 
 let sessionCounter = 0;
 
+// Deck storage, in memory. Rows are JSON, as they are in the real store, so a
+// server that saves a live reference to its own state reads back a copy.
+// Two harnesses sharing one of these are two processes sharing one deck.
+export function createTestStorage() {
+  const rows = new Map();
+  const scope = {
+    get: async (keys) => {
+      const found = {};
+      for (const key of keys) {
+        if (rows.has(key)) {
+          found[key] = encode(rows.get(key));
+        }
+      }
+      return found;
+    },
+    set: async (values) => {
+      for (const [key, value] of Object.entries(values)) {
+        rows.set(key, encode(value));
+      }
+    },
+    remove: async (keys) => {
+      for (const key of keys) {
+        rows.delete(key);
+      }
+    },
+  };
+  return { rows, deck: scope, user: () => scope };
+}
+
+// Everything a pending storage write is waiting on. `keepAlive` starts a save
+// nobody awaits, so a check that reads the store waits for this first.
+export function settleStorage() {
+  return new Promise((resolve) => setImmediate(resolve));
+}
+
 // `server` is the deck's default export from `server/index.js`.
-// Options: `mode` ('public' | 'named' | 'party'), `sessionId`, `deckId`.
+// Options: `mode` ('public' | 'named' | 'party'), `sessionId`, `deckId`,
+// `storage` (share one to make two harnesses two processes of one deck).
 export function createSessionHarness(server, options = {}) {
   const sessionId = options.sessionId ?? `test-session-${++sessionCounter}`;
   const players = new Map();
@@ -65,10 +101,12 @@ export function createSessionHarness(server, options = {}) {
     session,
     outbox,
     sessionId,
+    storage: session.storage,
     start: () => server.onStart?.(session),
     join: (playerId, identity) => joinPlayer(server, session, players, playerId, identity),
     leave: (player) => leavePlayer(server, session, players, player),
     message: (player, data) => messageFrom(server, session, players, player, data),
+    shutdown: () => server.onShutdown?.(session),
 
     // Every message this player has been sent, oldest first, already decoded.
     sent: (playerId) =>
@@ -90,6 +128,7 @@ function createSession(sessionId, options, players, outbox) {
     sessionId,
     deckId: options.deckId ?? 'test-deck',
     mode: options.mode ?? 'public',
+    storage: options.storage ?? createTestStorage(),
     send(playerId, data) {
       outbox.push({ playerId, data: encode(data) });
     },
@@ -125,7 +164,7 @@ function encode(data) {
   return JSON.parse(text);
 }
 
-function joinPlayer(server, session, players, playerId, identity = {}) {
+async function joinPlayer(server, session, players, playerId, identity = {}) {
   const player = {
     playerId,
     userId: identity.userId ?? playerId,
@@ -133,17 +172,17 @@ function joinPlayer(server, session, players, playerId, identity = {}) {
     isAnonymous: identity.isAnonymous ?? false,
   };
   players.set(playerId, player); // in the roster before the callback, as upstream
-  server.onPlayerJoin?.(session, player);
+  await server.onPlayerJoin?.(session, player);
   return player;
 }
 
-function leavePlayer(server, session, players, player) {
+async function leavePlayer(server, session, players, player) {
   const known = players.get(player.playerId);
   if (!known) {
     return null;
   }
   players.delete(player.playerId); // out of the roster before the callback
-  server.onPlayerLeave?.(session, known);
+  await server.onPlayerLeave?.(session, known);
   return known;
 }
 
@@ -208,6 +247,8 @@ export function createTestClock(startAt = Date.now()) {
 // the bug this kit was extracted to prevent. A shipped deck cleared the board
 // when a seated player's connection dropped.
 //
+// `checkRoom` returns a promise: a join reads storage, so the scenarios await.
+//
 // The deck supplies four hooks, all small:
 //
 //   play(harness, seated)        make one move the server will accept, from
@@ -228,8 +269,16 @@ export function createTestClock(startAt = Date.now()) {
 //
 // plus `server` (the deck's default export), `seats` (how many), `idleMs`,
 // `graceMs`, and `minPlayers` if it is not every seat.
+//
+// `reload` is optional: an async hook returning a fresh import of the deck's
+// server, which is a restarted process for the three checks that need one.
+//
+//   reload: () => import(`../code/server/index.js?fresh=${Date.now()}`)
+//             .then((module) => module.default)
+//
+// Without it those checks are skipped.
 
-export function checkRoom(options) {
+export async function checkRoom(options) {
   const ctx = { ...options, minPlayers: options.minPlayers ?? options.seats, results: [] };
 
   // The whole run happens on the movable clock, so the idle and grace windows
@@ -238,7 +287,7 @@ export function checkRoom(options) {
   clock.install();
   try {
     for (const scenario of SCENARIOS) {
-      scenario(ctx, clock);
+      await scenario(ctx, clock);
     }
   } finally {
     clock.uninstall();
@@ -266,12 +315,22 @@ const SCENARIOS = [
   partyTableIsNeverCleared,
   namedBehavesLikePublic,
   sessionsDoNotLeak,
+  movesAreSaved,
+  seatComesBackToTheAccount,
+  aSecondConnectionDoesNotTakeTheSeat,
+  namedRoomComesBack,
+  publicRoomComesBackInsideTheWindow,
+  publicRoomStartsCleanPastTheWindow,
 ];
 
 // Prints one line per check and returns the failure count, so a deck's test
-// script is `process.exit(printRoomChecks(checkRoom({...})))`.
+// script is `process.exit(printRoomChecks(await checkRoom({...})))`.
 export function printRoomChecks(outcome) {
   for (const result of outcome.results) {
+    if (result.skipped) {
+      console.log(`skip  ${result.name} -- ${result.label}`);
+      continue;
+    }
     const detail = result.ok
       ? ''
       : `\n        got  ${json(result.actual)}\n        want ${result.label}`;
@@ -295,31 +354,48 @@ function checkNot(ctx, name, actual, unexpected) {
   ctx.results.push({ name, ok, actual, label: `anything but ${json(unexpected)}` });
 }
 
+function skip(ctx, name, why) {
+  ctx.results.push({ name, ok: true, skipped: true, label: why });
+}
+
 // --- scenario scaffolding -------------------------------------------------
 
 let counter = 0;
 
 // A session with every seat taken, and nothing played yet.
-function seatedTable(ctx, mode = 'public') {
+async function seatedTable(ctx, mode = 'public') {
   const harness = createSessionHarness(ctx.server, { mode, sessionId: `check-${++counter}` });
   const seated = [];
   for (let i = 0; i < ctx.seats; i++) {
-    seated.push(harness.join(`${harness.sessionId}-p${i}`));
+    seated.push(await harness.join(`${harness.sessionId}-p${i}`));
   }
   return { harness, seated };
 }
 
 // The same, with one accepted move on it.
-function playedTable(ctx, mode = 'public') {
-  const table = seatedTable(ctx, mode);
-  ctx.play(table.harness, table.seated);
+async function playedTable(ctx, mode = 'public') {
+  const table = await seatedTable(ctx, mode);
+  await ctx.play(table.harness, table.seated);
   return table;
 }
 
+// A played table whose players have accounts, so another process can recognize
+// them. `options` is the harness's, and a second harness given the same ones is
+// the same room seen by a restarted server.
+async function accountTable(ctx, options) {
+  const harness = createSessionHarness(ctx.server, options);
+  const seated = [];
+  for (let i = 0; i < ctx.seats; i++) {
+    seated.push(await harness.join(`${options.sessionId}-p${i}`, { userId: `u${i}` }));
+  }
+  await ctx.play(harness, seated);
+  return { harness, seated };
+}
+
 // The game as a brand-new table looks, for comparing a cleared table against.
-function freshGame(ctx) {
+async function freshGame(ctx) {
   if (ctx.freshCache === undefined) {
-    const { harness, seated } = seatedTable(ctx);
+    const { harness, seated } = await seatedTable(ctx);
     ctx.freshCache = ctx.snapshot(harness, seated[0].playerId);
   }
   return ctx.freshCache;
@@ -330,17 +406,17 @@ function dropsToUncover(ctx) {
   return ctx.seats - ctx.minPlayers + 1;
 }
 
-function leaveSome(table, count) {
+async function leaveSome(table, count) {
   const gone = table.seated.slice(-count);
   for (const player of gone) {
-    table.harness.leave(player);
+    await table.harness.leave(player);
   }
   return gone;
 }
 
-function leaveAll(table) {
+async function leaveAll(table) {
   for (const player of table.seated) {
-    table.harness.leave(player);
+    await table.harness.leave(player);
   }
 }
 
@@ -348,42 +424,42 @@ function leaveAll(table) {
 
 // If this one fails, nothing below means anything: the hooks are wrong, not the
 // deck.
-function hooksWork(ctx) {
-  const { harness, seated } = playedTable(ctx);
+async function hooksWork(ctx) {
+  const { harness, seated } = await playedTable(ctx);
   checkNot(
     ctx,
     'the play hook changes the game',
     ctx.snapshot(harness, seated[0].playerId),
-    freshGame(ctx)
+    await freshGame(ctx)
   );
 }
 
-function seating(ctx) {
-  const { harness, seated } = seatedTable(ctx);
+async function seating(ctx) {
+  const { harness, seated } = await seatedTable(ctx);
   const held = seated.map((p) => ctx.seatOf(harness, p.playerId));
   check(ctx, 'every seat is taken, each by a different player', new Set(held).size, ctx.seats);
   check(ctx, 'no arrival is left seatless while a seat is free', held.includes(null), false);
-  const watcher = harness.join(`${harness.sessionId}-extra`);
+  const watcher = await harness.join(`${harness.sessionId}-extra`);
   check(ctx, 'past the last seat, an arrival watches', ctx.seatOf(harness, watcher.playerId), null);
 }
 
 // Seats belong to connections, so two tabs of one account can play each other
 // locally.
-function twoTabsOfOneAccount(ctx) {
+async function twoTabsOfOneAccount(ctx) {
   const harness = createSessionHarness(ctx.server, { sessionId: `check-${++counter}` });
-  const a = harness.join('tab-a', { userId: 'one-account', username: 'nikki' });
-  const b = harness.join('tab-b', { userId: 'one-account', username: 'nikki' });
+  const a = await harness.join('tab-a', { userId: 'one-account', username: 'nikki' });
+  const b = await harness.join('tab-b', { userId: 'one-account', username: 'nikki' });
   const held = [ctx.seatOf(harness, a.playerId), ctx.seatOf(harness, b.playerId)];
   check(ctx, 'two tabs of one account take two seats', new Set(held).size, 2);
 }
 
 // The bug this kit exists for: one player's connection blips and the other
 // player's game disappears from under them.
-function dropDoesNotDestroy(ctx) {
-  const table = playedTable(ctx);
+async function dropDoesNotDestroy(ctx) {
+  const table = await playedTable(ctx);
   const stays = table.seated[0].playerId;
   const before = ctx.snapshot(table.harness, stays);
-  leaveSome(table, dropsToUncover(ctx));
+  await leaveSome(table, dropsToUncover(ctx));
   check(
     ctx,
     'a seated player dropping leaves the game standing',
@@ -392,12 +468,12 @@ function dropDoesNotDestroy(ctx) {
   );
 }
 
-function watcherIsPromoted(ctx) {
-  const table = playedTable(ctx);
-  const watcher = table.harness.join(`${table.harness.sessionId}-w`);
+async function watcherIsPromoted(ctx) {
+  const table = await playedTable(ctx);
+  const watcher = await table.harness.join(`${table.harness.sessionId}-w`);
   const leaver = table.seated[table.seated.length - 1];
   const freed = ctx.seatOf(table.harness, leaver.playerId);
-  table.harness.leave(leaver);
+  await table.harness.leave(leaver);
   check(
     ctx,
     'a watcher is promoted into the vacated seat',
@@ -406,15 +482,15 @@ function watcherIsPromoted(ctx) {
   );
 }
 
-function reconnectKeepsItsSeat(ctx, clock) {
-  const table = playedTable(ctx);
+async function reconnectKeepsItsSeat(ctx, clock) {
+  const table = await playedTable(ctx);
   const stays = table.seated[0].playerId;
   const before = ctx.snapshot(table.harness, stays);
   const leaver = table.seated[table.seated.length - 1];
   const seat = ctx.seatOf(table.harness, leaver.playerId);
-  table.harness.leave(leaver);
+  await table.harness.leave(leaver);
   clock.advance(Math.max(1, Math.floor(ctx.graceMs / 2)));
-  table.harness.join(leaver.playerId);
+  await table.harness.join(leaver.playerId);
   check(
     ctx,
     'a reconnect inside the grace window gets its own seat back',
@@ -424,13 +500,13 @@ function reconnectKeepsItsSeat(ctx, clock) {
   check(ctx, '...and the game with it', ctx.snapshot(table.harness, stays), before);
 }
 
-function presentOutranksGhost(ctx) {
-  const table = playedTable(ctx);
-  const watcher = table.harness.join(`${table.harness.sessionId}-w`);
+async function presentOutranksGhost(ctx) {
+  const table = await playedTable(ctx);
+  const watcher = await table.harness.join(`${table.harness.sessionId}-w`);
   const leaver = table.seated[table.seated.length - 1];
   const seat = ctx.seatOf(table.harness, leaver.playerId);
-  table.harness.leave(leaver);
-  table.harness.join(leaver.playerId);
+  await table.harness.leave(leaver);
+  await table.harness.join(leaver.playerId);
   check(
     ctx,
     'a promoted watcher outranks a reconnecting ghost',
@@ -447,12 +523,12 @@ function presentOutranksGhost(ctx) {
 
 // Everyone dropped and one of them came back inside the window: still their own
 // game, however alone they are.
-function reconnectAloneKeepsTheGame(ctx, clock) {
-  const table = playedTable(ctx);
+async function reconnectAloneKeepsTheGame(ctx, clock) {
+  const table = await playedTable(ctx);
   const before = ctx.snapshot(table.harness, table.seated[0].playerId);
-  leaveAll(table);
+  await leaveAll(table);
   clock.advance(Math.max(1, Math.floor(ctx.graceMs / 2)));
-  const back = table.harness.join(table.seated[0].playerId);
+  const back = await table.harness.join(table.seated[0].playerId);
   check(
     ctx,
     'a lone reconnect inside the grace window keeps its own game',
@@ -461,38 +537,38 @@ function reconnectAloneKeepsTheGame(ctx, clock) {
   );
 }
 
-function loneArrivalGetsACleanTable(ctx, clock) {
-  const table = playedTable(ctx);
-  leaveAll(table);
+async function loneArrivalGetsACleanTable(ctx, clock) {
+  const table = await playedTable(ctx);
+  await leaveAll(table);
   clock.advance(ctx.graceMs + 1);
-  const arrival = table.harness.join(`${table.harness.sessionId}-new`);
+  const arrival = await table.harness.join(`${table.harness.sessionId}-new`);
   check(
     ctx,
     'a lone arrival gets a clean table',
     ctx.snapshot(table.harness, arrival.playerId),
-    freshGame(ctx)
+    await freshGame(ctx)
   );
 }
 
-function staleTableIsCleared(ctx, clock) {
-  const table = playedTable(ctx);
-  leaveSome(table, dropsToUncover(ctx));
+async function staleTableIsCleared(ctx, clock) {
+  const table = await playedTable(ctx);
+  await leaveSome(table, dropsToUncover(ctx));
   clock.advance(ctx.idleMs + 1);
-  const arrival = table.harness.join(`${table.harness.sessionId}-new`);
+  const arrival = await table.harness.join(`${table.harness.sessionId}-new`);
   check(
     ctx,
     'a table untouched for the idle window is cleared for an arrival',
     ctx.snapshot(table.harness, arrival.playerId),
-    freshGame(ctx)
+    await freshGame(ctx)
   );
 }
 
-function recentTableIsKept(ctx, clock) {
-  const table = playedTable(ctx);
+async function recentTableIsKept(ctx, clock) {
+  const table = await playedTable(ctx);
   const before = ctx.snapshot(table.harness, table.seated[0].playerId);
-  leaveSome(table, dropsToUncover(ctx));
+  await leaveSome(table, dropsToUncover(ctx));
   clock.advance(Math.max(1, Math.floor(ctx.idleMs / 2)));
-  const arrival = table.harness.join(`${table.harness.sessionId}-new`);
+  const arrival = await table.harness.join(`${table.harness.sessionId}-new`);
   check(
     ctx,
     'a recently played table with a free seat is kept',
@@ -503,11 +579,11 @@ function recentTableIsKept(ctx, clock) {
 
 // The idle window is only ever consulted when the table is short of players, so
 // however long the people at it stare at the board, nothing takes it away.
-function coveredTableSurvivesALongThink(ctx, clock) {
-  const table = playedTable(ctx);
+async function coveredTableSurvivesALongThink(ctx, clock) {
+  const table = await playedTable(ctx);
   const before = ctx.snapshot(table.harness, table.seated[0].playerId);
   clock.advance(ctx.idleMs * 10);
-  const arrival = table.harness.join(`${table.harness.sessionId}-w`);
+  const arrival = await table.harness.join(`${table.harness.sessionId}-w`);
   check(
     ctx,
     'a long think with the seats covered is never cleared',
@@ -517,31 +593,31 @@ function coveredTableSurvivesALongThink(ctx, clock) {
   check(ctx, '...and the arrival watches', ctx.seatOf(table.harness, arrival.playerId), null);
 }
 
-function refusedMessagesDoNotRefreshTheClock(ctx, clock) {
-  const table = playedTable(ctx);
+async function refusedMessagesDoNotRefreshTheClock(ctx, clock) {
+  const table = await playedTable(ctx);
   const half = Math.max(1, Math.floor(ctx.idleMs * 0.6));
   clock.advance(half);
-  ctx.junk(table.harness, table.seated[0]);
+  await ctx.junk(table.harness, table.seated[0]);
   clock.advance(half);
-  leaveSome(table, dropsToUncover(ctx));
-  const arrival = table.harness.join(`${table.harness.sessionId}-new`);
+  await leaveSome(table, dropsToUncover(ctx));
+  const arrival = await table.harness.join(`${table.harness.sessionId}-new`);
   check(
     ctx,
     'refused messages do not refresh the idle clock',
     ctx.snapshot(table.harness, arrival.playerId),
-    freshGame(ctx)
+    await freshGame(ctx)
   );
 }
 
-function acceptedMovesDoRefreshTheClock(ctx, clock) {
-  const table = playedTable(ctx);
+async function acceptedMovesDoRefreshTheClock(ctx, clock) {
+  const table = await playedTable(ctx);
   const half = Math.max(1, Math.floor(ctx.idleMs * 0.6));
   clock.advance(half);
-  ctx.play(table.harness, table.seated);
+  await ctx.play(table.harness, table.seated);
   const before = ctx.snapshot(table.harness, table.seated[0].playerId);
   clock.advance(half);
-  leaveSome(table, dropsToUncover(ctx));
-  const arrival = table.harness.join(`${table.harness.sessionId}-new`);
+  await leaveSome(table, dropsToUncover(ctx));
+  const arrival = await table.harness.join(`${table.harness.sessionId}-new`);
   check(
     ctx,
     'an accepted move does refresh it',
@@ -552,12 +628,12 @@ function acceptedMovesDoRefreshTheClock(ctx, clock) {
 
 // Every party gets its own session, so whatever a party session holds belongs
 // to that party. Nothing in it is ever cleared.
-function partyTableIsNeverCleared(ctx, clock) {
-  const table = playedTable(ctx, 'party');
+async function partyTableIsNeverCleared(ctx, clock) {
+  const table = await playedTable(ctx, 'party');
   const before = ctx.snapshot(table.harness, table.seated[0].playerId);
-  leaveAll(table);
+  await leaveAll(table);
   clock.advance(ctx.graceMs + ctx.idleMs + 1);
-  const arrival = table.harness.join(`${table.harness.sessionId}-new`);
+  const arrival = await table.harness.join(`${table.harness.sessionId}-new`);
   check(
     ctx,
     'a party table survives a lone arrival and the idle window',
@@ -568,34 +644,142 @@ function partyTableIsNeverCleared(ctx, clock) {
 
 // A local serve reports `named` for every session, so that is the branch a serve
 // exercises. It must behave like public, not like party.
-function namedBehavesLikePublic(ctx, clock) {
-  const table = playedTable(ctx, 'named');
-  leaveAll(table);
+async function namedBehavesLikePublic(ctx, clock) {
+  const table = await playedTable(ctx, 'named');
+  await leaveAll(table);
   clock.advance(ctx.graceMs + 1);
-  const arrival = table.harness.join(`${table.harness.sessionId}-new`);
+  const arrival = await table.harness.join(`${table.harness.sessionId}-new`);
   check(
     ctx,
     'a named session still clears for a lone arrival',
     ctx.snapshot(table.harness, arrival.playerId),
-    freshGame(ctx)
+    await freshGame(ctx)
   );
 }
 
 // Two sessions must not share a table. A module-level game object is the usual
 // way this goes wrong.
-function sessionsDoNotLeak(ctx) {
-  const a = playedTable(ctx);
-  const b = seatedTable(ctx);
+async function sessionsDoNotLeak(ctx) {
+  const a = await playedTable(ctx);
+  const b = await seatedTable(ctx);
   check(
     ctx,
     'a second session has its own table',
     ctx.snapshot(b.harness, b.seated[0].playerId),
-    freshGame(ctx)
+    await freshGame(ctx)
   );
   checkNot(
     ctx,
     '...and the first one still has its game',
     ctx.snapshot(a.harness, a.seated[0].playerId),
-    freshGame(ctx)
+    await freshGame(ctx)
+  );
+}
+
+// --- persistence ----------------------------------------------------------
+
+async function movesAreSaved(ctx) {
+  const sessionId = `check-${++counter}`;
+  const { harness } = await accountTable(ctx, { mode: 'named', sessionId });
+  await settleStorage();
+  const rows = [...harness.storage.rows.values()];
+  check(ctx, 'an accepted move is saved, under one key', rows.length, 1);
+  checkNot(ctx, '...with the game in it', rows[0]?.game ?? null, null);
+}
+
+// The grace window is over and the connection is a different one, so only the
+// account can put this player back in their seat.
+async function seatComesBackToTheAccount(ctx, clock) {
+  const sessionId = `check-${++counter}`;
+  const { harness, seated } = await accountTable(ctx, { mode: 'named', sessionId });
+  const before = ctx.snapshot(harness, seated[0].playerId);
+  const seat = ctx.seatOf(harness, seated[0].playerId);
+  await harness.leave(seated[0]);
+  clock.advance(ctx.graceMs + 1);
+  const back = await harness.join(`${sessionId}-again`, { userId: 'u0' });
+  check(
+    ctx,
+    'a new connection from the same account takes that seat back',
+    ctx.seatOf(harness, back.playerId),
+    seat
   );
+  check(ctx, '...and the game with it', ctx.snapshot(harness, back.playerId), before);
+}
+
+// The user's rule: joining again while your own play is running is an arrival.
+async function aSecondConnectionDoesNotTakeTheSeat(ctx) {
+  const sessionId = `check-${++counter}`;
+  const { harness, seated } = await accountTable(ctx, { mode: 'named', sessionId });
+  const held = ctx.seatOf(harness, seated[0].playerId);
+  const second = await harness.join(`${sessionId}-tab2`, { userId: 'u0' });
+  check(
+    ctx,
+    'a second connection leaves the seat with the connection holding it',
+    ctx.seatOf(harness, seated[0].playerId),
+    held
+  );
+  checkNot(ctx, '...and arrives as someone else', ctx.seatOf(harness, second.playerId), held);
+}
+
+// A fresh import of the deck's server is a restarted process: new tables, same
+// storage.
+async function restartedInto(ctx, options) {
+  const server = await ctx.reload();
+  return createSessionHarness(server, options);
+}
+
+const NO_RELOAD = 'no `reload` hook';
+
+async function namedRoomComesBack(ctx) {
+  const name = 'a named room comes back on a fresh process';
+  if (!ctx.reload) {
+    skip(ctx, name, NO_RELOAD);
+    return;
+  }
+  const options = { mode: 'named', sessionId: `check-${++counter}`, storage: createTestStorage() };
+  const { harness, seated } = await accountTable(ctx, options);
+  const before = ctx.snapshot(harness, seated[0].playerId);
+  const seat = ctx.seatOf(harness, seated[0].playerId);
+  await leaveAll({ harness, seated });
+  await settleStorage();
+
+  const restarted = await restartedInto(ctx, options);
+  const back = await restarted.join('later-connection', { userId: 'u0' });
+  check(ctx, name, ctx.snapshot(restarted, back.playerId), before);
+  check(ctx, '...seat and all', ctx.seatOf(restarted, back.playerId), seat);
+}
+
+async function publicRoomComesBackInsideTheWindow(ctx, clock) {
+  const name = 'a public room inside the idle window comes back';
+  if (!ctx.reload) {
+    skip(ctx, name, NO_RELOAD);
+    return;
+  }
+  const options = { mode: 'public', sessionId: `check-${++counter}`, storage: createTestStorage() };
+  const { harness, seated } = await accountTable(ctx, options);
+  const before = ctx.snapshot(harness, seated[0].playerId);
+  await leaveAll({ harness, seated });
+  await settleStorage();
+  clock.advance(Math.max(1, Math.floor(ctx.idleMs / 2)));
+
+  const restarted = await restartedInto(ctx, options);
+  const back = await restarted.join('later-connection', { userId: 'u0' });
+  check(ctx, name, ctx.snapshot(restarted, back.playerId), before);
+}
+
+async function publicRoomStartsCleanPastTheWindow(ctx, clock) {
+  const name = 'a public room past the idle window starts clean';
+  if (!ctx.reload) {
+    skip(ctx, name, NO_RELOAD);
+    return;
+  }
+  const options = { mode: 'public', sessionId: `check-${++counter}`, storage: createTestStorage() };
+  const { harness, seated } = await accountTable(ctx, options);
+  await leaveAll({ harness, seated });
+  await settleStorage();
+  clock.advance(ctx.idleMs + 1);
+
+  const restarted = await restartedInto(ctx, options);
+  const back = await restarted.join('later-connection', { userId: 'u0' });
+  check(ctx, name, ctx.snapshot(restarted, back.playerId), await freshGame(ctx));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "castle-web-cli",
-  "version": "0.4.170",
+  "version": "0.4.171",
   "type": "module",
   "bin": {
     "castle-web": "./dist/index.js"
@@ -41,7 +41,6 @@
     "@xterm/headless": "^6.0.0",
     "@xterm/xterm": "^6.0.0",
     "codemirror": "^6.0.2",
-    "dockview": "^4.13.1",
     "html2canvas": "^1.4.1",
     "marked": "^18.0.5",
     "nanoid": "^5.1.7",