v0.62.0: fixed 24x world clock — frozen when fully grounded (#135)

e2e/actions.spec.ts

@@ -98,10 +98,10 @@ async function setHealth(page: Page, planeId: string, fields: Record<string, unk
   expect(res.status()).toBe(200);
 }
 
-// A fully grounded fleet only advances at the idle real-time rate (ISS-128) — put the starter in
-// repair so the clock runs at FULL scale for tests that need fast-forwarding. The €1.5k repair cost
-// is why the expiry test captures its cash/rep baseline AFTER deactivateWorld; deactivateWorld
-// restores full health and no gate afterwards.
+// A fully grounded fleet freezes the world clock (#135) — put the starter in repair so the clock
+// runs at FULL scale for tests that need fast-forwarding. The €1.5k repair cost is why the expiry
+// test captures its cash/rep baseline AFTER deactivateWorld; deactivateWorld restores full health
+// and no gate afterwards.
 async function activateWorld(page: Page): Promise<void> {
   await setHealth(page, 'plane-starter', { health: 50 });
   expect((await page.request.post('/api/planes/plane-starter/repair')).status()).toBe(200);
@@ -344,9 +344,9 @@ test('expired packages deliver and abandon with no reward and no penalty', async
     expect(res.ok()).toBeTruthy();
   }
 
-  // A fully grounded fleet only advances at the idle real-time rate (ISS-128) — put the starter in
-  // repair for the expiry window so scale 1000 can fast-forward past both deadlines quickly. The €1.5k
-  // repair cost is why the cash/rep baseline below is captured AFTER deactivateWorld, not before it.
+  // A fully grounded fleet freezes the world clock (#135) — put the starter in repair for the expiry
+  // window so scale 1000 can fast-forward past both deadlines quickly. The €1.5k repair cost is why
+  // the cash/rep baseline below is captured AFTER deactivateWorld, not before it.
   await activateWorld(page);
   try {
     // Fast-forward past both deadlines — the tick flips loaded → expired (slot kept).

e2e/events.spec.ts

@@ -63,8 +63,10 @@ test('GET /api/events streams state snapshots over SSE', async () => {
   }
 
   // The initial snapshot arrives on connect; the second comes from a background tick within ~1 s.
+  // A grounded fleet freezes the clock (#135), so consecutive frames may carry the SAME clockMs —
+  // non-decreasing is what proves real pushes, not replays (advance itself is pinned in sim.spec.ts).
   expect(clocks.length).toBeGreaterThanOrEqual(2);
-  expect(clocks[1]).toBeGreaterThan(clocks[0]); // clock advanced between pushes — real updates, not replays
+  expect(clocks[1]).toBeGreaterThanOrEqual(clocks[0]);
 
   // ISS-133: no terminal package history in any frame (the DB keeps it forever; frames must not),
   // and a bounded frame size even on an instance with long-running history (~597 KB pre-v0.59.0).

e2e/panes.spec.ts

@@ -39,9 +39,9 @@ async function setHealth(page: Page, planeId: string, fields: Record<string, unk
   expect(res.status()).toBe(200);
 }
 
-// A fully grounded fleet only advances at the idle real-time rate (ISS-128) — put the starter in
-// repair so the clock runs at FULL scale for tests that need fast-forwarding. The €1.5k repair cost
-// is irrelevant to every spec's relative cash assertions; deactivateWorld restores full health and no gate afterwards.
+// A fully grounded fleet freezes the world clock (#135) — put the starter in repair so the clock
+// runs at FULL scale for tests that need fast-forwarding. The €1.5k repair cost is irrelevant to
+// every spec's relative cash assertions; deactivateWorld restores full health and no gate afterwards.
 async function activateWorld(page: Page): Promise<void> {
   await setHealth(page, STARTER, { health: 50 });
   expect((await page.request.post(`/api/planes/${STARTER}/repair`)).status()).toBe(200);
@@ -151,7 +151,7 @@ test('sim clock ticks smoothly between polls at the fixed world rate (ISS-007, I
   // 409s on non-available planes — it must be grounded before activateWorld.
   await flyHomeViaApi(page);
   await setScale(page, WORLD); // self-heal may have left the fast test rate behind
-  // A grounded fleet only advances at the idle real-time rate (ISS-128) — put the starter in repair for full scale.
+  // A fully grounded fleet freezes the world clock (#135) — put the starter in repair for full scale.
   await activateWorld(page);
   try {
     await page.goto('/');

e2e/right-pane.spec.ts

@@ -274,26 +274,17 @@ test('on-board list: fly-to-destination + abandon with penalty preview; flying p
 
   // The abandon button previews the penalty at its snapshot's clock (same formula as the server).
   // The fleet is grounded here (the starter just loaded; workers:1 and every spec's cleanup leave no
-  // other planes), so the world runs at the idle real-time rate (ISS-128) — verify it actually did,
-  // then bound the UI's staleness instead of racing a frozen clock.
+  // other planes), so the world clock is FROZEN (#135) — verify it actually is, then the preview must
+  // match the server exactly: a frozen clock means zero drift between any two snapshots.
   const c0 = (await getState(page)).simState.clockMs;
-  const t0 = Date.now();
   await new Promise((r) => setTimeout(r, 1_500)); // > one background-tick interval
   const state = await getState(page);
-  const idleDelta = state.simState.clockMs - c0;
-  expect(idleDelta, 'world should advance at the idle real-time rate while grounded (ISS-128)').toBeGreaterThan(0);
-  expect(idleDelta).toBeLessThan((Date.now() - t0) * WORLD); // clearly below the full world rate
+  expect(state.simState.clockMs - c0, 'the grounded clock must stay frozen (#135)').toBe(0);
 
-  // The UI renders the penalty from its last snapshot — up to one poll interval (~1 s, useGameState)
-  // older than `state`, i.e. ≤ ~2 game-seconds of clock drift at the idle real-time rate (ISS-128).
-  // Allow the formula's slope over that window instead of an exact string match.
-  const DRIFT_MS = 3_000; // a couple of poll intervals at the idle rate (= 1), margin for slow CI boxes
-  const span = pkg.deadlineSimTime - pkg.createdSimTime;
   const penaltyText = ((await page.getByTestId(`abandon-penalty-${pkg.id}`).textContent()) ?? '').replace(/[^0-9.]/g, '');
   expect(Number.isFinite(Number(penaltyText)), `penalty text: ${penaltyText}`).toBe(true);
   const expectedPenalty = penaltyFor(pkg.reward, pkg.createdSimTime, pkg.deadlineSimTime, state.simState.clockMs);
-  const slopePerGameMs = (pkg.reward * 0.45) / span; // abandonPenaltyPct's SPAN across the package lifetime
-  expect(Math.abs(Number(penaltyText) - expectedPenalty)).toBeLessThanOrEqual(slopePerGameMs * DRIFT_MS + 0.01);
+  expect(Number(penaltyText), 'frozen clock → the preview matches the server exactly').toBe(expectedPenalty);
 
   // Fly to the destination through the UI — the button is the destination's name.
   const flyBtn = page.getByTestId(`fly-to-${pkg.id}`);

e2e/sim.spec.ts

@@ -1,15 +1,14 @@
 import { test, expect, type Page } from '@playwright/test';
 
-// v0.52.0 (ISS-117) fixed world clock against the live origin: a fully grounded fleet slowing to
-// real time instead of freezing (ISS-128), background-tick advance at a raised rate while
-// something is active, package expiry via the FLIGHT_TEST_HOOKS hooks (enabled in docker-compose.yml),
-// and market top-up.
+// v0.52.0 (ISS-117), finalized in #135: fixed world clock against the live origin — a fully
+// grounded fleet freezes the clock, background-tick advance at a raised rate while something is
+// active, package expiry via the FLIGHT_TEST_HOOKS hooks (enabled in docker-compose.yml), and
+// market top-up.
 
 // Must match lib/sim/engine.ts — kept in sync manually (same pattern as MIN_ZOOM/MAX_ZOOM in map.spec.ts).
 const MAX_TICK_ELAPSED_MS = 2_000;
 const SCALE = 1000; // test rate for fast-forwarding legs
 const WORLD = 24; // the fixed world rate (ISS-117) — must match lib/worldClock.ts
-const IDLE = 1; // the idle real-time rate (ISS-128) — must match IDLE_WORLD_TIME_SCALE in lib/worldClock.ts (= WORLD / 24)
 const MAX_DELTA_PER_TICK = MAX_TICK_ELAPSED_MS * SCALE; // 2_000_000 game ms per tick at scale 1000
 // Must match MARKET_TARGET_OPEN_PACKAGES in lib/game/seed.ts.
 const MARKET_TARGET = 10;
@@ -48,10 +47,9 @@ async function setHealth(page: Page, planeId: string, fields: Record<string, unk
   expect(res.status()).toBe(200);
 }
 
-// A fully grounded fleet only advances at the idle real-time rate (ISS-128) — put the starter in
-// repair so the clock runs at FULL scale for tests that need fast-forwarding. The €1.5k repair
-// cost is irrelevant to every spec's relative cash assertions; deactivateWorld restores full health
-// and no gate afterwards.
+// A fully grounded fleet freezes the world clock (#135) — put the starter in repair so the clock
+// runs at FULL scale for tests that need fast-forwarding. The €1.5k repair cost is irrelevant to
+// every spec's relative cash assertions; deactivateWorld restores full health and no gate afterwards.
 async function activateWorld(page: Page): Promise<void> {
   await setHealth(page, STARTER, { health: 50 });
   expect((await page.request.post(`/api/planes/${STARTER}/repair`)).status()).toBe(200);
@@ -73,25 +71,15 @@ test.afterEach(async ({ page }) => {
   await setScale(page, WORLD);
 });
 
-test('a fully grounded fleet slows the clock to real time instead of freezing it (ISS-128)', async ({ page }) => {
+test('a fully grounded fleet freezes the world clock (#135)', async ({ page }) => {
   const s = await getState(page);
   expect(s.planes.every((p) => p.status === 'available'), 'fleet should be grounded at spec start').toBe(true);
 
-  const t0 = Date.now();
   const c0 = s.simState.clockMs;
   await sleep(2_500); // ~2.5 s of real idleness — several background ticks plus the reads below
   const after = await getState(page);
-  const elapsedReal = Date.now() - t0;
 
-  const delta = after.simState.clockMs - c0;
-  expect(delta, 'the idle clock must advance (no longer frozen)').toBeGreaterThan(0);
-  // ≈ real time: each tick counts min(gap, MAX_TICK_ELAPSED_MS) × IDLE rate, so the total can only fall
-  // short of the wall span when a tick gap was clamped — worst case is one clamped idle-rate tick.
-  expect(delta).toBeGreaterThanOrEqual(Math.min(elapsedReal * IDLE * 0.5, MAX_TICK_ELAPSED_MS * IDLE));
-  // …and never more than the wall span itself (plus one clamp of pre-read downtime for slow boxes)…
-  expect(delta).toBeLessThanOrEqual(elapsedReal + MAX_TICK_ELAPSED_MS);
-  // …which is clearly below the full world rate: at ×24 this window would be ≥ ~60 game seconds.
-  expect(delta).toBeLessThan(elapsedReal * WORLD);
+  expect(after.simState.clockMs - c0, 'the grounded clock must stay frozen').toBe(0);
 });
 
 test('timeScale 1000 advances the clock by roughly real-time × 1000 between polls', async ({ page }) => {

e2e/state.spec.ts

@@ -8,9 +8,6 @@ import { test, expect } from '@playwright/test';
 const repoRoot = path.join(__dirname, '..');
 const composeArgs = process.env.E2E_COMPOSE_ARGS ?? '';
 
-// Must match lib/sim/engine.ts — kept in sync manually (same pattern as e2e/sim.spec.ts).
-const MAX_TICK_ELAPSED_MS = 2_000;
-
 interface StateBody {
   account: { cash: number; reputation: number };
   simState: { clockMs: number }; // ISS-117: the snapshot carries only the game clock
@@ -45,9 +42,8 @@ test('GET /api/state returns a seeded snapshot', async ({ page }) => {
 test('state survives a container restart (sim clock + account persisted)', async ({ page }) => {
   test.setTimeout(180_000);
 
-  // Self-heal to a fully grounded fleet first — while idle the clock advances at real time
-  // (ISS-128), so the post-restart snapshot is bounded by one clamped tick of downtime plus live
-  // ticks, not byte-for-byte identical.
+  // Self-heal to a fully grounded fleet first — a grounded fleet freezes the world clock (#135),
+  // so no tick advances it across the restart and the post-restart clock is exactly unchanged.
   await expect
     .poll(async () => {
       const res = await page.request.get('/api/state');
@@ -60,7 +56,6 @@ test('state survives a container restart (sim clock + account persisted)', async
   const resBefore = await page.request.get('/api/state');
   expect(resBefore.status()).toBe(200);
   const before = (await resBefore.json()) as StateBody;
-  const tBefore = Date.now();
 
   execSync(`docker compose ${composeArgs} restart flight`, { cwd: repoRoot, stdio: 'pipe' });
 
@@ -80,17 +75,12 @@ test('state survives a container restart (sim clock + account persisted)', async
 
   expect(after).toBeDefined();
   const a = after!;
-  const tAfter = Date.now();
 
   // The DB file on the volume must be loaded, not re-seeded (PLAN.md: "sim clock persisted across
-  // sessions"): account and entity ids are byte-identical. With the fleet grounded above, ISS-128
-  // advances the clock at real time while idle — bounded tolerance instead of exact equality: no
-  // ticks run while the container is down, so the first post-restart tick counts the downtime
-  // clamped to MAX_TICK_ELAPSED_MS × IDLE rate (= 1), and every other counted gap lies inside the
-  // live wall span [tBefore, tAfter] at that same rate. A re-seed would reset clockMs backwards.
-  const delta = a.simState.clockMs - before.simState.clockMs;
-  expect(delta).toBeGreaterThanOrEqual(0); // never goes backwards — not re-seeded
-  expect(delta).toBeLessThanOrEqual(MAX_TICK_ELAPSED_MS + (tAfter - tBefore));
+  // sessions"): account and entity ids are byte-identical. With the fleet grounded above, the world
+  // clock is FROZEN (#135) — no tick advances it while the container is down or after restart, so
+  // the post-restart clock is EXACTLY unchanged; a re-seed would reset clockMs backwards instead.
+  expect(a.simState.clockMs - before.simState.clockMs).toBe(0);
   expect(a.account.cash).toBe(before.account.cash);
   expect(a.account.reputation).toBe(before.account.reputation);
   expect(a.planes.map((p) => p.id).sort()).toEqual(before.planes.map((p) => p.id).sort());