Merge pull request 'v1.9.0: e2e relocation speedup — FAST rate for self-heal cleanup legs' (#163) from feat/e2e-relocation-speedup into master

- actions/hover/two-planes: FAST=10_000 for expiry fast-forwards, landing
  waits and fly-home cleanups; queue: + CHAIN=4_000 for auto-chain
  observation, refuel test at explicit 2_000 with relaxed fuel bound
- map-interactions: FAST=50_000 chain hops (~3 min -> ~15 s per direction);
  crossing leg stays at SCALE and now sets it BEFORE dispatch (a leftover
  fast rate would let the dispatch tick consume most of the leg)
- hover fleet-row test asserts flying from the fly endpoint's own snapshot
  and freezes immediately instead of speeding up then freezing mid-leg
- two-planes parallel-flight: both-grounded poll after cleanup dispatches so
  afterEach heal no longer pays the range-edge return leg at SCALE

CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## v1.9.0 — 2026-09-27 20:57
+- **E2E speedup follow-up (test-only, no game code changed).** `e2e/relocation.spec.ts`'s self-heal helper `flyHomeViaApi` now fast-forwards its cleanup legs at the v1.8.0 `FAST = 10_000` rate instead of a blanket `SCALE = 1000` — every scale-dependent wait in that file is a pure arrival wait (status `'available'` / `locationIcao === HUB`) with no mid-leg observation, so the higher rate is safe and the now-unused `SCALE` constant was dropped. Expected CI wall time for the file drops from ~40 s to ~25 s (~2–3 s off test 1, ~10–11 s each off tests 2 and 3). Test 3's deliberate `setScale(page, 1)` guard is untouched; `map.spec.ts` wheel-zoom (real-time-bound) and `multiplayer.spec.ts`'s N-player clock (measures sim-vs-real elapsed time) stay as-is.
+
+## v1.8.0 — 2026-09-27 20:13
+- **E2E speedup (test-only, no game code changed).** Every Playwright spec that fast-forwards legs now uses the fastest rate its assertions allow instead of a blanket `SCALE = 1000`: pure arrival waits (no mid-leg observation) run at `FAST` — a lagged tick can only land a plane sooner, never skip an observed state. Expected CI wall time for the affected tests drops ~5–6× overall (e.g. the antimeridian test's relocation chains go from ~3 min to ~15 s per direction; two-planes' parallel-flight test loses its ~24 s afterEach heal leg).
+- **Per-test rates.** `actions.spec.ts` + `hover.spec.ts` + `two-planes.spec.ts`: new local `FAST = 10_000` for expiry fast-forwards, landing waits and fly-home cleanups. `queue.spec.ts`: same `FAST`, plus `CHAIN = 4_000` for the auto-chain observation (max per-tick advance 2 s × S stays below the LEMD-length leg's ~1e7 sim-ms duration so one lagged tick can't complete it before a poll sees the chained state); its refuel-before-chained-leg test moves to an explicit `2_000` with the fuel lower bound relaxed from `> 1.3×required` to `> required` (at 2_000× the snapshot can land ~0.4×required into leg 2's burn under dind load; a wrong top-up level still lands far below the bound, and the exact level stays pinned by the unchanged cash assertion). `map-interactions.spec.ts`: `FAST = 50_000` for chain hops (≤3400 km each) and arrival waits.
+- **Kept at SCALE = 1000 where mid-leg observation is real.** The antimeridian crossing leg itself (freshness gate ~700 km ≈ 5 s of flight + >3 fresh samples assume ~14 s of real-time flight), the queue spec's final-hop chain window (EHAM→EDDF is only 2_587 sim-s — at higher rates a `/api/state` 500-retry gap could advance past it), and map-interactions' mid-flight click window. The antimeridian crossing dispatch now sets SCALE BEFORE the fly POST: with FAST-rate chains, a leftover fast rate would let the dispatch tick itself consume most of the leg before the setScale lands (flake path).
+- **hover.spec.ts fleet-row test restructured.** It no longer speeds up to 1000× and then freezes mid-leg; it asserts `flying` from the fly endpoint's OWN post-action snapshot (no poll race) and freezes at scale 1 immediately — same pattern as its package-hover sibling, so the ~10 s leg can't land under the assertions.
+- **two-planes parallel-flight test.** Landing waits move to FAST, and a new both-grounded poll after the cleanup dispatches lets the range-edge return legs finish while the clock is still at FAST — previously afterEach's `healPlaneHome` paid that ~24 s leg back at SCALE.
+
+## v1.7.0 — 2026-09-26 20:24
+- **Multiplayer step 12/12 (ISS-116): multiplayer test coverage.** The final campaign step closes the two remaining verification gaps with tests only — no production game code changed: the #135 freeze rule (`shouldAdvanceTime`) already counts ALL planes regardless of owner, and the mint hook has supported a username override since v1.1.0 (the e2e helper just never forwarded it).
+- **E2E.** New `e2e/multiplayer.spec.ts` (serial) plays two live sessions: player A is the suite's usual local player; player B is a second account minted through the same hook with a username override. Test 1 verifies the N-player clock end-to-end (#135 × ISS-113): while A flies and B stays grounded, the world clock advances on every read (one owner airborne is enough to keep time moving), then after A lands — EVERY player grounded — the clock freezes exactly across ~2.5 s of real idleness. Test 2 verifies ownership isolation: both sessions see the same shared fleet with `ownerId`/`ownerName`, A gets 403 "not your plane" on B's starter (fly AND sell — the 403 must beat B's last-plane 409), B gets 403 on A's, a grant to local moves only A's account row while B's stays untouched, and both sessions see the v1.6.0 `players` summary with per-owner plane counts.
+- **Test hooks.** `e2e/auth.ts`'s `mintPlayerSession(page)` now forwards an optional username (the route already supported it). New FLIGHT_TEST_HOOKS-gated `POST /api/test/delete-plane {username}` — deletes every plane owned by that player's row (any bound packages unbound first), idempotent for unknown usernames, returns the local-scoped snapshot like its siblings. Needed because B's onboarding starter is unsellable (per-owner last-plane guard) and would break later specs' single-fleet self-heal within the same CI run; an `afterAll` deletes it even when tests fail.
+- **Tests.** Unit: two new engine tests — a tickOnce-level N-player clock test (A flying + B grounded → advances at exactly the fixed world rate; all owners grounded → frozen with the real-time anchor still tracking, ISS-113) and the symmetric spawn-quality case (local leads → MAX picks local's row, not "prefer non-local"). No existing e2e spec changed: they are additive-safe against a second player.
+
 ## v1.6.0 — 2026-09-26 19:35
 - **Multiplayer step 11/12 (ISS-115): leaderboard panel.** Small UI listing every player in the world with cash, reputation and plane count, rendered from snapshot data — no new endpoint. The known gap from step 8 is closed additively: `getStateSnapshot(playerId)` (`lib/game/state.ts`) now projects a `players` array (`PlayerSummary[]`: `{ id, username, cash, reputation, planeCount }`, planeCount = planes owned) into the ONE shared snapshot projection, so GET /api/state, action responses and every SSE frame all carry it in sync automatically. No extra query — the players rows were already loaded for the v1.4.0 owner joins; plane counts are a single in-memory pass over the already-loaded plane rows.
 - **UI.** New "Leaderboard" button on the right side of the map top bar (next to Admin) opens the panel as a modal, reusing the existing `Modal` + `.pane-btn` conventions — per the 2026-09-23 placement decision it is NOT embedded in the left pane. New `components/Leaderboard.tsx`: one row per player (username, cash via `formatCash`, reputation, plane count), sorted by reputation descending with cash then username as deterministic tie-breaks so rows don't shuffle between snapshots on equal rep. Small `.leaderboard` table styles mirror `.admin-rows`.

app/api/test/delete-plane/route.ts

@@ -0,0 +1,69 @@
+import { eq } from 'drizzle-orm';
+import { getGameDb, persist } from '@/lib/db/client';
+import { LOCAL_PLAYER } from '@/lib/db/localPlayer';
+import * as schema from '@/lib/db/schema';
+import { getStateSnapshot } from '@/lib/game/state';
+import { tickNow } from '@/lib/sim/engine';
+
+// TEST-ONLY hook (v1.7.0, ISS-116) — deletes every plane owned by a player so the e2e suite can
+// remove planes no API path can get rid of: a minted second account's onboarding starter is its
+// LAST plane, and the per-owner last-plane guard (v1.2.0, ISS-109) makes it unsellable. Leftover
+// foreign planes would break later specs' single-fleet self-heal (two-planes.spec.ts sells every
+// non-starter as local → 403). Disabled unless FLIGHT_TEST_HOOKS=1; sibling of /api/test/set-fuel —
+// same gate, same conventions.
+//
+// POST /api/test/delete-plane
+//   body { username: string } — required. Deletes all planes owned by that player's row (any bound
+//   packages are unbound first) and returns the full state snapshot after ticking, like siblings.
+//   Idempotent: an unknown username deletes nothing and still 200s, so cleanup can run unconditionally.
+
+export async function POST(req: Request) {
+  if (process.env.FLIGHT_TEST_HOOKS !== '1') {
+    return Response.json({ error: 'test hooks disabled' }, { status: 404 });
+  }
+
+  let body: unknown = {};
+  try {
+    const text = await req.text();
+    body = text ? JSON.parse(text) : {};
+  } catch {
+    return Response.json({ error: 'invalid JSON body' }, { status: 400 });
+  }
+  if (typeof body !== 'object' || body === null || Array.isArray(body)) {
+    return Response.json({ error: 'body must be a JSON object' }, { status: 400 });
+  }
+  const input = body as Record<string, unknown>;
+  for (const key of Object.keys(input)) {
+    if (key !== 'username') {
+      return Response.json({ error: `unknown field "${key}"` }, { status: 400 });
+    }
+  }
+  const username = input.username;
+  if (typeof username !== 'string' || username.length === 0) {
+    return Response.json({ error: 'username is required and must be a non-empty string' }, { status: 400 });
+  }
+
+  try {
+    const inst = await getGameDb();
+    await tickNow(); // clock is current before the snapshot we return (same as siblings)
+    const players = await inst.db.select().from(schema.players).where(eq(schema.players.username, username));
+    let deleted = 0;
+    if (players[0]) {
+      const owned = await inst.db.select().from(schema.planes).where(eq(schema.planes.ownerId, players[0].id));
+      for (const plane of owned) {
+        // Free any bound packages' slots — a deleted plane must never leave dangling planeIds.
+        await inst.db.update(schema.packages).set({ planeId: null }).where(eq(schema.packages.planeId, plane.id));
+        await inst.db.delete(schema.planes).where(eq(schema.planes.id, plane.id));
+        deleted++;
+      }
+    }
+    if (deleted > 0) {
+      await persist(inst);
+    }
+    // v1.3.0 (ISS-110): admin-style hook — no session; the snapshot reports the seeded local account.
+    return Response.json({ deleted, ...(await getStateSnapshot(LOCAL_PLAYER.id)) });
+  } catch (err) {
+    console.error('test hook failed', err);
+    return Response.json({ error: 'test hook failed' }, { status: 500 });
+  }
+}

e2e/actions.spec.ts

@@ -20,6 +20,7 @@ test.beforeEach(async ({ page }) => { await authenticate(page); });
 // penalty. Mirrors lib/game/penalty.ts for exact-value assertions.
 
 const SCALE = 1000; // test rate for fast-forwarding legs — keeps flights to seconds of real time
+const FAST = 10_000; // pure arrival waits (no mid-leg observation) — LEMD-length legs land in ~1 s
 const WORLD = 24; // the fixed world rate (ISS-117) — must match lib/worldClock.ts
 const HUB = 'EDDF'; // Frankfurt Main — the seeded starter plane's home base (lib/game/seed.ts)
 
@@ -334,7 +335,7 @@ test('abandon while grounded deducts exactly the formula penalty', async ({ page
 });
 
 test('expired packages deliver and abandon with no reward and no penalty', async ({ page }) => {
-  test.setTimeout(480_000); // two ~10 s real-time legs at 1000× (HUB↔LEMD) plus expiry wait
+  test.setTimeout(480_000); // two ~1 s real-time legs at 10_000× (HUB↔LEMD) plus expiry wait
   await flyHomeViaApi(page);
 
   // A: load, let it expire while loaded, then FLY to its destination — arrival must
@@ -350,12 +351,12 @@ test('expired packages deliver and abandon with no reward and no penalty', async
   }
 
   // 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
+  // window so scale 10_000 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).
-    await setScale(page, SCALE);
+    await setScale(page, FAST);
     let s = await getState(page);
     await expect.poll(async () => ((await getState(page)).packages.find((p) => p.id === pkgA.id)!.status), { timeout: 30_000 }).toBe('expired');
     s = await getState(page);
@@ -387,9 +388,9 @@ test('expired packages deliver and abandon with no reward and no penalty', async
   expect(s.packages.find((p) => p.id === pkgB.id)!.status).toBe('abandoned');
   expect(s.account.cash).toBe(cashBeforeAbandon); // free — expired abandons cost nothing
 
-  // Restore: top up + fly home at SCALE.
+  // Restore: top up + fly home at FAST (pure arrival wait).
   await setFuelFull(page, 'plane-starter');
-  await setScale(page, SCALE);
+  await setScale(page, FAST);
   const homeRes = await page.request.post('/api/planes/plane-starter/fly', { data: { destIcao: HUB } });
   expect(homeRes.ok()).toBeTruthy();
   await expect.poll(async () => ((await getState(page)).planes.find((p) => p.id === 'plane-starter')!.locationIcao), { timeout: 240_000 }).toBe(HUB);

e2e/auth.ts

@@ -9,8 +9,11 @@ import { expect } from '@playwright/test';
 
 export const SESSION_KEY = 'flight.session'; // must match lib/authClient.ts
 
-export async function mintPlayerSession(page: Page): Promise<string> {
+// v1.7.0 (ISS-116): optional username — mints a SECOND account with onboarding (the route has
-  const res = await page.request.post('/api/test/mint-player-session');
+// supported the override since v1.1.0; this helper just never forwarded it). No arg = the suite's
+// usual local player, exactly as before.
+export async function mintPlayerSession(page: Page, username?: string): Promise<string> {
+  const res = await page.request.post('/api/test/mint-player-session', { data: username ? { username } : {} });
   expect(res.status(), 'mint-player-session hook should be enabled in the CI stack (FLIGHT_TEST_HOOKS=1)').toBe(200);
   return ((await res.json()) as { sessionId: string }).sessionId;
 }

e2e/hover.spec.ts

@@ -17,6 +17,7 @@ test.beforeEach(async ({ page }) => { await authenticate(page); });
 // additionally gets a distinct green ring in `airports-target-highlight` (ISS-022).
 
 const SCALE = 1000; // test rate for fast-forwarding legs — keeps flights to seconds of real time
+const FAST = 10_000; // pure arrival waits (no mid-leg observation) — LEMD-length legs land in ~1 s
 const WORLD = 24; // the fixed world rate (ISS-117) — must match lib/worldClock.ts
 const HUB = 'EDDF'; // must match HUB_ICAO in lib/game/seed.ts
 // Madrid–Barajas — same long leg as e2e/map-interactions.spec.ts: ~1420 km → ~10 s at scale 1000.
@@ -516,7 +517,7 @@ test('hovering the Relocate section previews the planned route and target airpor
 });
 
 test('hovering the fleet row of a flying plane highlights its route', async ({ page }) => {
-  test.setTimeout(600_000); // self-heal + one flight at scale 1000 + fly-home cleanup
+  test.setTimeout(600_000); // self-heal + one flight (frozen mid-leg) + FAST fly-home cleanup
   await flyHomeViaApi(page);
 
   // Full tank before departure — deterministic baseline (ISS-082 hook; dispatch would auto-refuel anyway).
@@ -525,23 +526,26 @@ test('hovering the fleet row of a flying plane highlights its route', async ({ p
   await page.goto('/');
   await waitForAirportCount(page);
 
-  // Load + fly via the API (same pattern as e2e/map-interactions.spec.ts), then speed up.
+  // Load + fly via the API (same pattern as e2e/map-interactions.spec.ts). The endpoint's OWN
+  // post-action snapshot already shows the plane flying — no poll race.
   const pkg = await createPackage(page, HUB, DEST);
   const load = await page.request.post(`/api/packages/${pkg.id}/load`, { data: { planeId: 'plane-starter' } });
   expect(load.status()).toBe(200);
   const fly = await page.request.post('/api/planes/plane-starter/fly', { data: { destIcao: DEST } });
   expect(fly.status()).toBe(200);
-  await setScale(page, SCALE);
+  const flyBody = (await fly.json()) as StateBody;
+  expect(flyBody.planes.find((p) => p.id === 'plane-starter')?.status).toBe('flying');
+
+  // Freeze immediately: at a leftover scale of 1000 the ~10 s leg could otherwise land under us and
+  // empty the route line while we assert. At scale 1 every /api/state snapshot reports the same state
+  // for minutes, so no mid-flight position window is needed at all (same pattern as the package-hover
+  // test below).
+  await setScale(page, 1);
 
   // The fleet row shows the plane in flight once a snapshot with status 'flying' lands (ISS-054).
   const block = page.getByTestId('plane-plane-starter');
   await expect(block).toContainText(/in flight/i, { timeout: 15_000 });
 
-  // Freeze mid-flight so the ~10 s leg can't land under us while we assert (same pattern as
-  // e2e/map-interactions.spec.ts' marker click): at scale 1 the leg takes minutes of real time, and
-  // the route line stays drawn while frozen.
-  await setScale(page, 1);
-
   await block.hover();
   await expect.poll(async () => {
     const feats = (await renderedFeatures(page, ['routes-highlight'])) as Array<{ properties: Record<string, unknown> }>;
@@ -554,9 +558,10 @@ test('hovering the fleet row of a flying plane highlights its route', async ({ p
     message: 'waiting for the highlight to clear after mouseleave',
   }).toBe(0);
 
-  // Resume and fast-forward to arrival, then fly home so the live instance stays in its
+  // Fast-forward to arrival (pure wait — no mid-leg observation), then fly home so the live instance
-  // onboarding state (starter grounded at EDDF) for the other specs.
+  // stays in its onboarding state (starter grounded at EDDF) for the other specs. Both legs are pure
-  await setScale(page, SCALE);
+  // arrivals → FAST (~1 s each instead of ~10 s).
+  await setScale(page, FAST);
   await expect
     .poll(async () => {
       const p = (await getState(page)).planes.find((x) => x.id === 'plane-starter');
@@ -564,8 +569,8 @@ test('hovering the fleet row of a flying plane highlights its route', async ({ p
     }, { timeout: 120_000, message: `waiting for plane-starter to land at ${DEST}` })
     .toBe(true);
 
-  // Re-set SCALE for the return leg.
+  // Re-set FAST for the return leg.
-  await setScale(page, SCALE);
+  await setScale(page, FAST);
   const home = await page.request.post('/api/planes/plane-starter/fly', { data: { destIcao: HUB } });
   expect(home.status()).toBe(200);
   await expect
@@ -577,7 +582,7 @@ test('hovering the fleet row of a flying plane highlights its route', async ({ p
 });
 
 test('hovering an on-board package while its carrier is mid-flight traces from the landing airport', async ({ page }) => {
-  test.setTimeout(600_000); // self-heal + one flight at scale 1000 + fly-home cleanup
+  test.setTimeout(600_000); // self-heal + one flight (frozen mid-leg) + FAST fly-home cleanup
   await flyHomeViaApi(page);
 
   // Full tank before departure — deterministic baseline (ISS-082 hook; dispatch would auto-refuel anyway).
@@ -651,7 +656,8 @@ test('hovering an on-board package while its carrier is mid-flight traces from t
   // not DEST — it never delivered), then fly home.
   const cancelRes = await page.request.post('/api/planes/plane-starter/queue/cancel', { data: { index: 0 } });
   expect(cancelRes.status()).toBe(200);
-  await setScale(page, SCALE);
+  // Pure arrival wait (the queue is empty — nothing to observe mid-leg) → FAST.
+  await setScale(page, FAST);
   await expect
     .poll(async () => {
       const p = (await getState(page)).planes.find((x) => x.id === 'plane-starter');
@@ -662,8 +668,8 @@ test('hovering an on-board package while its carrier is mid-flight traces from t
   const abandon = await page.request.post(`/api/packages/${pkg.id}/abandon`);
   expect(abandon.status()).toBe(200); // only possible once grounded — the poll above guarantees it
 
-  // Re-set SCALE for the return leg.
+  // Re-set FAST for the return leg (~1 s instead of ~10 s).
-  await setScale(page, SCALE);
+  await setScale(page, FAST);
   const home = await page.request.post('/api/planes/plane-starter/fly', { data: { destIcao: HUB } });
   expect(home.status()).toBe(200);
   await expect

e2e/map-interactions.spec.ts

@@ -20,6 +20,9 @@ const HUB = 'EDDF'; // must match HUB_ICAO in lib/game/seed.ts
 // the 6300 L tank, so a full-tank departure always makes it home.
 const DEST = 'LEMD';
 const SCALE = 1000; // test rate for fast-forwarding legs
+// Pure arrival waits and relocation-chain hops (no mid-leg observation): a lagged tick can only finish
+// the leg sooner, never skip an observed state. Max hop ≤3400 km lands in <1 s at this rate.
+const FAST = 50_000;
 const WORLD = 24; // the fixed world rate (ISS-117) — must match lib/worldClock.ts
 
 interface PlaneState {
@@ -106,15 +109,15 @@ async function setFuelFull(page: Page, planeId: string): Promise<void> {
   expect((await page.request.post('/api/test/set-fuel', { data: { planeId, fuel: p.maxFuel } })).status()).toBe(200);
 }
 
-// Load a package onto plane-starter and fly it from → to via the API, then poll at
+// Load a package onto plane-starter and fly it from → to via the API, then fast-forward at FAST
-// scale 1000 until the plane lands at `to`. Same pattern as e2e/actions.spec.ts.
+// (pure arrival wait — no mid-leg observation) until the plane lands at `to`. Same pattern as e2e/actions.spec.ts.
 async function loadAndFly(page: Page, fromIcao: string, toIcao: string): Promise<PackageState> {
   const pkg = await createPackage(page, fromIcao, toIcao);
   const load = await page.request.post(`/api/packages/${pkg.id}/load`, { data: { planeId: 'plane-starter' } });
   expect(load.status()).toBe(200);
   const fly = await page.request.post('/api/planes/plane-starter/fly', { data: { destIcao: toIcao } });
   expect(fly.status()).toBe(200);
-  await setScale(page, SCALE);
+  await setScale(page, FAST);
   await expect
     .poll(async () => {
       const body = await getState(page);
@@ -204,7 +207,7 @@ test('airport popup shows name, ICAO, local time and generated weather', async (
 });
 
 test('plane markers move while flying and the plane popup shows status + route', async ({ page }) => {
-  test.setTimeout(600_000); // self-heal from a far airport (~20 s worst case at 1000×) + main flight + cleanup
+  test.setTimeout(600_000); // self-heal from a far airport (~3 s worst case at 50_000×) + main flight + cleanup
 
   await page.goto('/');
   await waitForAirportCount(page);
@@ -215,7 +218,7 @@ test('plane markers move while flying and the plane popup shows status + route',
   const foundStarter = (await getState(page)).planes.find((p) => p.id === 'plane-starter');
   expect(foundStarter).toBeDefined();
   if (foundStarter!.status === 'flying') {
-    await setScale(page, SCALE);
+    await setScale(page, FAST); // pure arrival wait — no mid-leg observation needed here
     await expect
       .poll(async () => (await getState(page)).planes.find((p) => p.id === 'plane-starter')?.status === 'available', {
         timeout: 240_000,
@@ -348,8 +351,8 @@ test('plane markers move while flying and the plane popup shows status + route',
   // The popup's route line is the plane's own leg: origin name → destination name.
   await expect(page.getByTestId('plane-route')).toContainText(`${live.locationName} → ${live.destName}`);
 
-  // Restore SCALE before step 5 — the landing wait needs a fast clock.
+  // Fast-forward to arrival (pure wait — no mid-leg observation) at FAST: ~0.2 s instead of ~4 s.
-  await setScale(page, SCALE);
+  await setScale(page, FAST);
 
   // 5) Let the flight finish, then fly home so the live instance stays in its
   // onboarding state (starter grounded at EDDF) for the other specs. The loaded
@@ -478,7 +481,7 @@ async function fitToAirports(page: Page, icaos: string[]): Promise<void> {
 }
 
 test('plane marker stays continuous across the antimeridian (no 360° teleport)', async ({ page }) => {
-  test.setTimeout(900_000); // relocation chain (~3 min at 1000×) + crossing leg + return chain + margin
+  test.setTimeout(900_000); // relocation chain (~15 s per direction at 50_000×) + crossing leg + return chain + margin
 
   await page.goto('/');
   await waitForAirportCount(page);
@@ -489,7 +492,7 @@ test('plane marker stays continuous across the antimeridian (no 360° teleport)'
   // Self-heal: full health, let any in-flight leg finish, then relocate to ORIGIN via the chain.
   expect((await page.request.post('/api/test/set-health', { data: { planeId: 'plane-starter', health: 100, repairUntilMs: 0 } })).status()).toBe(200);
   if ((await getState(page)).planes.find((p) => p.id === 'plane-starter')!.status === 'flying') {
-    await setScale(page, SCALE);
+    await setScale(page, FAST); // pure arrival wait — no mid-leg observation needed here
     await expect.poll(async () => (await getState(page)).planes.find((p) => p.id === 'plane-starter')?.status ?? '', { timeout: 240_000 }).toBe('available');
   }
   // Relocate + crossing leg. The finally ALWAYS runs — even when a poll below fails, the plane must end
@@ -500,7 +503,7 @@ test('plane marker stays continuous across the antimeridian (no 360° teleport)'
       for (const next of await chainTo(page, loc, ORIGIN)) {
         await setFuelFull(page, 'plane-starter'); // full tank → auto-refuel tops up 0 L and costs nothing
         expect((await page.request.post('/api/planes/plane-starter/fly', { data: { destIcao: next } })).status()).toBe(200);
-        await setScale(page, SCALE);
+        await setScale(page, FAST); // pure arrival wait per hop — a lagged tick can only land it sooner
         await expect.poll(async () => (await getState(page)).planes.find((p) => p.id === 'plane-starter')?.locationIcao ?? '', { timeout: 240_000 }).toBe(next);
       }
     }
@@ -521,9 +524,12 @@ test('plane marker stays continuous across the antimeridian (no 360° teleport)'
     const pkg = await createPackage(page, ORIGIN, CROSS_DEST);
     expect((await page.request.post(`/api/packages/${pkg.id}/load`, { data: { planeId: 'plane-starter' } })).status()).toBe(200);
     console.log(`[antimeridian] pkg=${pkg.id} leg ${ORIGIN}->${CROSS_DEST}; BEFORE dispatch: ${fmtPlane((await getState(page)).planes.find((x) => x.id === 'plane-starter')!)}`);
+    // The crossing leg must run at SCALE (1000×): the freshness gate (~700 km ≈ 5 s of flight) and the
+    // >3 fresh samples both assume ~14 s of real-time flight. Set it BEFORE dispatch — a leftover FAST
+    // rate would let the dispatch tick itself consume most of the leg before this setScale lands.
+    await setScale(page, SCALE);
     const fly = await page.request.post('/api/planes/plane-starter/fly', { data: { destIcao: CROSS_DEST } });
     if (fly.status() !== 200) throw new Error(`dispatch POST /api/planes/plane-starter/fly → ${fly.status()} (expected 200)`);
-    await setScale(page, SCALE);
     console.log(`[antimeridian] AFTER dispatch: ${fmtPlane((await getState(page)).planes.find((x) => x.id === 'plane-starter')!)}`);
 
     // querySourceFeatures only sees LOADED tiles — the v0.70.0 default view ([0,0] z2) doesn't cover this
@@ -591,16 +597,16 @@ test('plane marker stays continuous across the antimeridian (no 360° teleport)'
     expect(lons.some((lon) => Math.abs(lon) > 180), `sampled lons (n=${lons.length}): ${JSON.stringify(lons)}`).toBe(true); // crossed onto a world copy, either side of ±180
     expect(Math.max(...lons) - Math.min(...lons), `lon span: min=${Math.min(...lons).toFixed(4)} max=${Math.max(...lons).toFixed(4)} over ${JSON.stringify(lons)}`).toBeGreaterThan(4); // traversed the crossing region, not a static window
   } finally {
-    // Cleanup: let any in-flight leg land, then chain back home so the other specs start from the canonical
+    // Cleanup: let any in-flight leg land (pure arrival wait → FAST), then chain back home so the other
-    // state. The package was delivered on arrival (generous deadline).
+    // specs start from the canonical state. The package was delivered on arrival (generous deadline).
-    await setScale(page, SCALE);
+    await setScale(page, FAST);
     await expect.poll(async () => (await getState(page)).planes.find((p) => p.id === 'plane-starter')?.status ?? '', { timeout: 240_000 }).toBe('available');
     const endLoc = (await getState(page)).planes.find((p) => p.id === 'plane-starter')!.locationIcao;
     if (endLoc !== HUB) {
       for (const next of await chainTo(page, endLoc, HUB)) {
         await setFuelFull(page, 'plane-starter');
         expect((await page.request.post('/api/planes/plane-starter/fly', { data: { destIcao: next } })).status()).toBe(200);
-        await setScale(page, SCALE);
+        await setScale(page, FAST); // pure arrival wait per hop — a lagged tick can only land it sooner
         await expect.poll(async () => (await getState(page)).planes.find((p) => p.id === 'plane-starter')?.locationIcao ?? '', { timeout: 240_000 }).toBe(next);
       }
     }

e2e/multiplayer.spec.ts

@@ -0,0 +1,283 @@
+import type { Browser, BrowserContext, Page } from '@playwright/test';
+import { expect, test } from '@playwright/test';
+
+import { applySession, authenticate, mintPlayerSession } from './auth';
+
+// v1.7.0 (ISS-116) — multiplayer e2e coverage: the N-player world clock (#135 rule × step 9/ISS-113)
+// and ownership isolation across two live sessions. Player A is the suite's usual minted local
+// player; player B is a second account minted through the same hook with a username override (the
+// route has supported it since v1.1.0 — e2e/auth.ts now forwards it).
+//
+// The CI DB volume persists across specs within one run, so this spec must leave no trace later
+// specs can't handle: player B's onboarding starter is unsellable (per-owner last-plane guard), so
+// an afterAll deletes it via the new /api/test/delete-plane hook. Between tests the plane stays —
+// re-minting is idempotent and test 2 needs a B-owned plane to exist.
+
+const WORLD = 24; // fixed world rate (ISS-117) — must match lib/worldClock.ts
+const SCALE = 1000; // test rate for fast-forwarding legs
+const HUB = 'EDDF'; // must match HUB_ICAO in lib/game/seed.ts
+const STARTER = 'plane-starter'; // the seeded plane's id (lib/game/seed.ts)
+const LOCAL_USERNAME = 'kamilkrzywda'; // must match LOCAL_PLAYER.username in lib/db/localPlayer.ts
+const PLAYER_B = 'e2e-player-b'; // stable username — minting is idempotent across runs
+
+interface PlaneState {
+  id: string;
+  status: string;
+  locationIcao: string;
+  maxFuel: number;
+  queue: string[];
+  ownerId: string;
+  ownerName: string;
+}
+
+interface PlayerSummary {
+  id: string;
+  username: string;
+  cash: number;
+  reputation: number;
+  planeCount: number;
+}
+
+interface StateBody {
+  account: { cash: number; reputation: number };
+  simState: { clockMs: number };
+  planes: PlaneState[];
+  players: PlayerSummary[];
+}
+
+const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));
+
+async function getState(page: Page): Promise<StateBody> {
+  // ISS-127: /api/state intermittently 500s under scale-1000 dind load; retry briefly instead of throwing.
+  for (let attempt = 1; ; attempt++) {
+    const res = await page.request.get('/api/state');
+    if (res.status() === 200) return (await res.json()) as StateBody;
+    if (attempt >= 3) throw new Error(`/api/state returned ${res.status()} after 3 attempts`);
+    await page.waitForTimeout(500);
+  }
+}
+
+// Test hook (FLIGHT_TEST_HOOKS=1): set the world rate and VERIFY from the response that it stuck.
+async function setScale(page: Page, scale: number): Promise<void> {
+  const res = await page.request.post('/api/test/set-timescale', { data: { timeScale: scale } });
+  expect(res.status()).toBe(200);
+  const body = (await res.json()) as { timeScale: number };
+  expect(body.timeScale, `timeScale should be ${scale} after POST /api/test/set-timescale`).toBe(scale);
+}
+
+// Test hook (FLIGHT_TEST_HOOKS=1): top a plane's tank back to full.
+async function setFuelFull(page: Page, planeId: string): Promise<void> {
+  const p = (await getState(page)).planes.find((x) => x.id === planeId)!;
+  expect(p.status).toBe('available'); // only tops up grounded planes — the fly call right after needs it
+  expect((await page.request.post('/api/test/set-fuel', { data: { planeId, fuel: p.maxFuel } })).status()).toBe(200);
+}
+
+// Cancel every queued leg of a plane via the API (works while flying — the server checks no status).
+async function clearQueueViaApi(page: Page, planeId: string): Promise<void> {
+  for (;;) {
+    const q = (await getState(page)).planes.find((p) => p.id === planeId)?.queue ?? [];
+    if (q.length === 0) return;
+    expect((await page.request.post(`/api/planes/${planeId}/queue/cancel`, { data: { index: 0 } })).status()).toBe(200);
+  }
+}
+
+// Closest airport to the hub — a short, full-tank-flyable leg for the clock test.
+async function nearestToHub(page: Page): Promise<string> {
+  const fc = (await (await page.request.get('/api/airports')).json()) as {
+    features: Array<{ properties: { icao: string; lat: number; lon: number } }>;
+  };
+  const hub = fc.features.find((f) => f.properties.icao === HUB)!.properties;
+  return fc.features
+    .filter((f) => f.properties.icao !== HUB)
+    .map((f) => ({ icao: f.properties.icao, d: haversineKm(hub.lat, hub.lon, f.properties.lat, f.properties.lon) }))
+    .sort((x, y) => x.d - y.d)[0].icao;
+}
+
+// Mirrors haversineKm in lib/geo.ts (same formula → identical floats).
+function haversineKm(lat1: number, lon1: number, lat2: number, lon2: number): number {
+  const toRad = (d: number) => (d * Math.PI) / 180;
+  const dLat = toRad(lat2 - lat1);
+  const dLon = toRad(lon2 - lon1);
+  const a =
+    Math.sin(dLat / 2) ** 2 +
+    Math.cos(toRad(lat1)) * Math.cos(toRad(lat2)) * Math.sin(dLon / 2) ** 2;
+  return 2 * 6371 * Math.asin(Math.min(1, Math.sqrt(a)));
+}
+
+// Mint the second account in its OWN context — sessions are per-context (headers + localStorage).
+async function mintPlayerB(browser: Browser): Promise<{ ctx: Awaited<ReturnType<Browser['newContext']>>; page: Page }> {
+  const ctx = await browser.newContext();
+  const page = await ctx.newPage();
+  const sessionId = await mintPlayerSession(page, PLAYER_B);
+  await applySession(page, sessionId);
+  return { ctx, page };
+}
+
+// Heal the starter to "grounded at the hub" — same pattern as healPlaneHome in two-planes.spec.ts.
+async function healStarterHome(page: Page): Promise<void> {
+  await clearQueueViaApi(page, STARTER);
+  let p = (await getState(page)).planes.find((x) => x.id === STARTER);
+  if (!p) return; // cannot happen — the starter is local's last plane and unsellable
+  await setScale(page, SCALE); // fast-forward any in-flight leg during cleanup
+  if (p.status === 'flying') {
+    // While flying, locationIcao stays at the DEPARTURE airport — re-read state after landing.
+    await expect
+      .poll(async () => ((await getState(page)).planes.find((x) => x.id === STARTER)?.status ?? ''), {
+        timeout: 240_000,
+        message: 'waiting for an in-flight starter to land during cleanup',
+      })
+      .toBe('available');
+    p = (await getState(page)).planes.find((x) => x.id === STARTER)!;
+  }
+  if (p.locationIcao !== HUB) {
+    const flyHome = await page.request.post(`/api/planes/${STARTER}/fly`, { data: { destIcao: HUB } });
+    expect(flyHome.status()).toBe(200);
+    await expect
+      .poll(async () => ((await getState(page)).planes.find((x) => x.id === STARTER)?.locationIcao ?? ''), {
+        timeout: 240_000,
+        message: 'waiting for the starter to land back at the hub during cleanup',
+      })
+      .toBe(HUB);
+  }
+}
+
+// Wait until every plane in the world is grounded — an interrupted earlier spec (or a previous run's
+// retry) may have left the starter mid-flight, and both tests need a deterministic baseline.
+async function waitForGroundedFleet(page: Page): Promise<void> {
+  await expect
+    .poll(async () => ((await getState(page)).planes.every((p) => p.status === 'available') ? 'idle' : 'busy'), {
+      timeout: 120_000,
+      message: 'waiting for the fleet to be fully grounded',
+    })
+    .toBe('idle');
+}
+
+test.describe.configure({ mode: 'serial' }); // shared world + one minted second account — order matters
+
+let bCtx: Awaited<ReturnType<Browser['newContext']>> | null = null;
+
+test.beforeEach(async ({ page }) => {
+  await authenticate(page); // player A — the seeded local player that owns plane-starter
+});
+
+test.afterEach(async ({ page }) => {
+  try {
+    // Leave the world exactly as found: starter grounded at the hub, fixed world rate.
+    await healStarterHome(page);
+    await setScale(page, WORLD);
+  } finally {
+    if (bCtx) await bCtx.close();
+    bCtx = null;
+  }
+});
+
+// File-level cleanup: player B's starter is unsellable, so it must be deleted — later specs'
+// single-fleet self-heal would otherwise hit a foreign plane. Runs even when tests failed (the hook
+// is idempotent), and needs no session: /api/test/* hooks are unauthenticated by design.
+test.afterAll(async ({ browser }) => {
+  const ctx = await browser.newContext();
+  const page = await ctx.newPage();
+  try {
+    expect((await page.request.post('/api/test/delete-plane', { data: { username: PLAYER_B } })).status()).toBe(200);
+    // Verify through the same surface the game uses — mint a local session just for this read.
+    const sessionId = await mintPlayerSession(page);
+    await applySession(page, sessionId);
+    const s = (await getState(page)) as StateBody;
+    expect(s.planes.filter((p) => p.ownerName === PLAYER_B)).toEqual([]);
+  } finally {
+    await ctx.close();
+  }
+});
+
+test('N-player clock: one player flying keeps the world advancing; all grounded freezes it (ISS-113)', async ({ page, browser }) => {
+  test.setTimeout(480_000); // self-heal + one short hop at scale 1000
+  const b = await mintPlayerB(browser);
+  bCtx = b.ctx;
+
+  await waitForGroundedFleet(page);
+  await setScale(page, WORLD); // deterministic rate for the advance phase — sim.spec.ts pins the ×scale math
+
+  const dest = await nearestToHub(page);
+  await clearQueueViaApi(page, STARTER); // no auto-chain on landing — A's plane must come to rest
+  await setFuelFull(page, STARTER);
+  expect((await page.request.post(`/api/planes/${STARTER}/fly`, { data: { destIcao: dest } })).status()).toBe(200);
+
+  // Phase 1 — A flying while B stays grounded: the clock advances on every read. #135's freeze rule
+  // is fleet-wide, not per-player: ONE owner airborne is enough to keep world time moving.
+  let prev = (await getState(page)).simState.clockMs;
+  for (let i = 0; i < 3; i++) {
+    await sleep(500);
+    const s = await getState(page); // tick-on-read — advances while any plane flies
+    expect(s.planes.find((p) => p.id === STARTER)?.status).toBe('flying'); // A still airborne…
+    expect(s.planes.filter((p) => p.ownerName === PLAYER_B).every((p) => p.status === 'available')).toBe(true); // …B grounded the whole time
+    const now = s.simState.clockMs;
+    expect(now, 'the clock must advance while any player is flying').toBeGreaterThan(prev);
+    prev = now;
+  }
+
+  // Phase 2 — land A: with EVERY player grounded, the clock freezes exactly (no idle creep).
+  await setScale(page, SCALE);
+  await expect
+    .poll(async () => ((await getState(page)).planes.find((p) => p.id === STARTER)?.status ?? ''), {
+      timeout: 240_000,
+      message: "waiting for A's plane to land",
+    })
+    .toBe('available');
+
+  const frozen1 = await getState(page);
+  expect(frozen1.planes.every((p) => p.status === 'available'), 'every player must be grounded').toBe(true);
+  await sleep(2_500); // ~2.5 s of real idleness — several background ticks
+  const frozen2 = await getState(page);
+  expect(frozen2.simState.clockMs, 'a fully grounded multi-player fleet must freeze the clock').toBe(frozen1.simState.clockMs);
+});
+
+test('ownership isolation: 403 on foreign planes; per-session account rows; shared fleet with owner info', async ({ page, browser }) => {
+  const b = await mintPlayerB(browser);
+  bCtx = b.ctx;
+
+  // Deterministic baseline: a fully grounded fleet (no delivery can move cash mid-test).
+  await waitForGroundedFleet(page);
+
+  const sA = await getState(page); // A's (local session's) view of the shared world
+  const sB = await getState(b.page); // B's view — same world…
+  expect(sB.planes.map((p) => p.id).sort()).toEqual(sA.planes.map((p) => p.id).sort()); // …both see every plane
+
+  // Owner info on every surface (v1.4.0): the starter belongs to local, B's starter to B.
+  const starter = sA.planes.find((p) => p.id === STARTER)!;
+  expect(starter.ownerId).toBe('local');
+  expect(starter.ownerName).toBe(LOCAL_USERNAME);
+  const bSummary = sB.players.find((pl) => pl.username === PLAYER_B);
+  expect(bSummary, 'the players summary lists player B').toBeDefined();
+  const bPlane = sA.planes.find((p) => p.ownerId === bSummary!.id)!;
+  expect(bPlane.ownerName).toBe(PLAYER_B); // A sees WHOSE plane it is…
+  expect(sB.planes.find((p) => p.id === bPlane.id)?.ownerName).toBe(PLAYER_B); // …and so does B
+
+  // A cannot act on B's plane — ownership wins over every state check (403, not the last-plane 409:
+  // B's starter is B's only plane, so a missing ownership check would surface as 409 instead).
+  const flyForeign = await page.request.post(`/api/planes/${bPlane.id}/fly`, { data: { destIcao: HUB } });
+  expect(flyForeign.status()).toBe(403);
+  expect((await flyForeign.json() as { error: string }).error).toMatch(/not your plane/i);
+  const sellForeign = await page.request.post('/api/market/sell-plane', { data: { planeId: bPlane.id } });
+  expect(sellForeign.status()).toBe(403);
+
+  // …and B cannot act on A's.
+  const flyA = await b.page.request.post(`/api/planes/${STARTER}/fly`, { data: { destIcao: HUB } });
+  expect(flyA.status()).toBe(403);
+
+  // Per-session account rows (v1.3.0): a grant to local moves ONLY A's row — the world is frozen,
+  // so nothing else can touch either economy between reads.
+  const cA = sA.account.cash;
+  const cB = sB.account.cash;
+  const grant = await page.request.post('/api/test/add-cash', { data: { amount: 1_000 } });
+  expect(grant.status()).toBe(200);
+  const granted = ((await grant.json()) as StateBody).account.cash;
+  expect(Math.abs(granted - (cA + 1_000))).toBeLessThan(0.001); // A's row moved…
+  const sBAfter = await getState(b.page);
+  expect(sBAfter.account.cash, "B's account is untouched by a grant to local").toBe(cB);
+
+  // The players summary (v1.6.0) is visible in both sessions with per-owner plane counts.
+  for (const s of [sA, sBAfter]) {
+    expect(s.players.find((pl) => pl.username === LOCAL_USERNAME)?.planeCount).toBeGreaterThanOrEqual(1);
+    expect(s.players.find((pl) => pl.username === PLAYER_B)?.planeCount).toBe(1);
+  }
+});

e2e/queue.spec.ts

@@ -20,6 +20,12 @@ test.beforeEach(async ({ page }) => { await authenticate(page); });
 // the next queued leg server-side (part 1); test 3 exercises that chain end-to-end through the API.
 
 const SCALE = 1000; // test rate for fast-forwarding legs — keeps flights to seconds of real time
+// Pure arrival waits (no mid-leg observation): LEMD-length legs land in ~1 s. Safe at any scale —
+// a lagged tick can only finish the leg sooner, never skip an observed state.
+const FAST = 10_000;
+// Chained-leg observation: max per-tick advance (2 s × S) must stay below the LEMD-length leg's
+// sim-duration (~1e7 sim-ms) so one lagged tick can't complete it before a poll sees the chain.
+const CHAIN = 4_000;
 const WORLD = 24; // the fixed world rate (ISS-117) — must match lib/worldClock.ts
 const HUB = 'EDDF'; // must match HUB_ICAO in lib/game/seed.ts
 const DEST = 'LEMD'; // Madrid–Barajas — the typical long leg (~10 s at scale 1000)
@@ -285,14 +291,15 @@ test('queue display + cancel via UI (ISS-043 part 2)', async ({ page }) => {
   await expect(page.getByTestId('queue-leg-plane-starter-0'), 'the cancelled leg is removed from the queue').toHaveCount(0, { timeout: 15_000 });
 
   // Cleanup: resume + fast-forward to arrival at DEST (empty queue → plain landing), then fly home.
-  await setScale(page, SCALE);
+  // Both waits are pure arrivals — FAST is safe and ~10× quicker than SCALE here.
+  await setScale(page, FAST);
   await expect.poll(async () => {
     const p = (await getState(page)).planes.find((x) => x.id === 'plane-starter');
     return !!p && p.status === 'available' && p.locationIcao === DEST;
   }, { timeout: 120_000, message: `waiting for plane-starter to land at ${DEST}` }).toBe(true);
 
-  // Re-set SCALE for the return leg.
+  // Re-set FAST for the return leg.
-  await setScale(page, SCALE);
+  await setScale(page, FAST);
   const home = await page.request.post('/api/planes/plane-starter/fly', { data: { destIcao: HUB } });
   expect(home.status()).toBe(200);
   await expect.poll(async () => ((await getState(page)).planes.find((p) => p.id === 'plane-starter')?.locationIcao ?? ''), {
@@ -366,14 +373,15 @@ test('dotted queue line renders the queued path on the map (ISS-043 part 2)', as
   // to arrival, then fly home.
   const cancelRes = await page.request.post('/api/planes/plane-starter/queue/cancel', { data: { index: 0 } });
   expect(cancelRes.status()).toBe(200);
-  await setScale(page, SCALE);
+  // Pure arrival waits — FAST is safe and ~10× quicker than SCALE here.
+  await setScale(page, FAST);
   await expect.poll(async () => {
     const p = (await getState(page)).planes.find((x) => x.id === 'plane-starter');
     return !!p && p.status === 'available' && p.locationIcao === DEST;
   }, { timeout: 120_000, message: `waiting for plane-starter to land at ${DEST}` }).toBe(true);
 
-  // Re-set SCALE for the return leg.
+  // Re-set FAST for the return leg.
-  await setScale(page, SCALE);
+  await setScale(page, FAST);
   const home = await page.request.post('/api/planes/plane-starter/fly', { data: { destIcao: HUB } });
   expect(home.status()).toBe(200);
   await expect.poll(async () => ((await getState(page)).planes.find((p) => p.id === 'plane-starter')?.locationIcao ?? ''), {
@@ -457,9 +465,9 @@ test('landing auto-starts the next queued leg (ISS-043 chain end-to-end)', async
   expect(flyRes.status()).toBe(200);
 
   // Fast-forward (also clears any pause). On landing at DEST the server must AUTO-START the queued
-  // return leg — no manual dispatch. The chained state persists for the whole ~10 s return leg, so a
+  // return leg — no manual dispatch. The chained state persists for the whole ~2.5 s return leg at
-  // poll can't miss it: status 'flying' with destIcao = the first (only) queued ICAO.
+  // CHAIN, so a poll can't miss it: status 'flying' with destIcao = the first (only) queued ICAO.
-  await setScale(page, SCALE);
+  await setScale(page, CHAIN);
   await expect.poll(async () => {
     const p = (await getState(page)).planes.find((x) => x.id === 'plane-starter');
     return !!p && p.status === 'flying' && p.destIcao === HUB;
@@ -566,8 +574,10 @@ test('a drained tank is topped up before a chained leg at exactly the rep-discou
   const rate = repRate(s0.account.reputation, FUEL_DISCOUNT_PER_REP, MAX_FUEL_DISCOUNT);
   const expectedCost = Math.round(liters * FUEL_PRICE_PER_L * (1 - rate) * 100) / 100;
 
-  // Landing at DEST auto-chains QUEUE with the top-up…
+  // Landing at DEST auto-chains QUEUE with the top-up… 2_000× (not SCALE): leg 2's chained state must
-  await setScale(page, SCALE);
+  // stay observable — max per-tick advance (2 s × S) stays below its ~1e7 sim-ms duration, and the
+  // snapshot window below is sized for this rate.
+  await setScale(page, 2_000);
   await expect.poll(async () => {
     const x = (await getState(page)).planes.find((y) => y.id === 'plane-starter');
     return !!x && x.status === 'flying' && x.destIcao === QUEUE;
@@ -577,9 +587,9 @@ test('a drained tank is topped up before a chained leg at exactly the rep-discou
   // Exact fuel equality is impossible — this snapshot lands after leg 2's departure burn; the exact top-up level × rep-discounted price is pinned by the cash assertion below.
   const fuel = s.planes.find((x) => x.id === 'plane-starter')!.fuel;
   expect(fuel).toBeLessThanOrEqual(target); // can only have burned since departure…
-  // 1.3× not 1.4×: under dind load the snapshot can land ~0.1×required2 into leg 2's departure burn;
+  // > required2 (not 1.3×): at 2_000× the snapshot can land ~0.4×required2 into leg 2's burn under dind
-  // a wrong top-up level (≤ required2, or none at all) still lands far below this bound.
+  // load; a wrong top-up level (≤ required2, or none at all) still lands far below this bound.
-  expect(fuel).toBeGreaterThan(1.3 * required2);
+  expect(fuel).toBeGreaterThan(required2);
   expect(s.account.cash).toBeCloseTo(cashBeforeChain - expectedCost, 6); // at exactly the rep-discounted cost
 
   // Let leg 2 finish so the next test starts from a known airport.
@@ -603,7 +613,8 @@ test('cancelling the only queued leg mid-flight leaves a plain landing (v0.46.0)
   const cancel = await page.request.post('/api/planes/plane-starter/queue/cancel', { data: { index: 0 } });
   expect(cancel.status()).toBe(200);
 
-  await setScale(page, SCALE);
+  // Pure arrival wait (the queue is empty — nothing to observe mid-leg) → FAST.
+  await setScale(page, FAST);
   await expect.poll(async () => {
     const x = (await getState(page)).planes.find((y) => y.id === 'plane-starter');
     return !!x && x.status === 'available' && x.locationIcao === DEST;

e2e/relocation.spec.ts

@@ -14,7 +14,7 @@ test.beforeEach(async ({ page }) => { await authenticate(page); });
 // works for FLYING planes — it then appends to POST /api/planes/{id}/queue instead of flying now.
 // Marker-size regression is covered by the existing e2e/map.spec.ts click tests, not here.
 
-const SCALE = 1000; // test rate for fast-forwarding legs — keeps cleanup flights to seconds of real time
+const FAST = 10_000; // pure arrival waits (no mid-leg observation) — cleanup legs land in ~1 s
 const WORLD = 24; // the fixed world rate (ISS-117) — must match lib/worldClock.ts
 const HUB = 'EDDF'; // Frankfurt Main — the seeded starter plane's home base (lib/game/seed.ts)
 // LFRS Nantes Atlantique — same isolated marker as e2e/map.spec.ts. The v0.70.0 default view ([0,0] z2)
@@ -93,8 +93,8 @@ async function flyHomeViaApi(page: Page): Promise<void> {
   let s = await getState(page);
   let plane = s.planes.find((p) => p.id === 'plane-starter')!;
   if (plane.status === 'flying' || plane.locationIcao !== HUB) {
-    // Fast-forward any leftover leg / repositioning flight (~20 s real time worst case at 1000×).
+    // Fast-forward any leftover leg / repositioning flight (~2 s real time worst case at FAST).
-    await setScale(page, SCALE);
+    await setScale(page, FAST);
   }
   if (plane.status === 'flying') {
     // While flying, locationIcao stays at the DEPARTURE airport — re-read state after landing
@@ -104,8 +104,8 @@ async function flyHomeViaApi(page: Page): Promise<void> {
     plane = s.planes.find((p) => p.id === 'plane-starter')!;
   }
   if (plane.locationIcao !== HUB) {
-    // Make sure the world rate is back at SCALE so the return leg fast-forwards.
+    // Make sure the world rate is back at FAST so the return leg fast-forwards.
-    await setScale(page, SCALE);
+    await setScale(page, FAST);
     const res = await page.request.post(`/api/planes/${plane.id}/fly`, { data: { destIcao: HUB } });
     expect(res.ok()).toBeTruthy(); // repositioning needs no package (v0.12.0 manual flight)
     await expect.poll(async () => ((await getState(page)).planes.find((p) => p.id === 'plane-starter')!.locationIcao), { timeout: 240_000 }).toBe(HUB);
@@ -122,7 +122,7 @@ test.afterEach(async ({ page }) => {
 test.describe.configure({ mode: 'serial' }); // shared live DB — order matters within this file
 
 test('left pane Relocate section relocates a grounded plane', async ({ page }) => {
-  test.setTimeout(300_000); // self-heal (worst case ~20 s at 1000×) + one short leg
+  test.setTimeout(300_000); // self-heal (worst case ~2 s at FAST) + one short leg
   await flyHomeViaApi(page);
 
   // Full tank before departure — deterministic baseline (ISS-082 hook; dispatch would auto-refuel anyway).
@@ -154,7 +154,7 @@ test('left pane Relocate section relocates a grounded plane', async ({ page }) =
 });
 
 test('airport popup offers Relocate options for grounded planes', async ({ page }) => {
-  test.setTimeout(300_000); // self-heal (worst case ~20 s at 1000×) + one leg to LFRS
+  test.setTimeout(300_000); // self-heal (worst case ~2 s at FAST) + one leg to LFRS
   await flyHomeViaApi(page);
 
   // Full tank before departure — deterministic baseline (ISS-082 hook; dispatch would auto-refuel anyway).
@@ -221,7 +221,7 @@ test('airport popup offers Relocate options for grounded planes', async ({ page
 });
 
 test('airport popup Relocate queues a leg for a flying plane', async ({ page }) => {
-  test.setTimeout(300_000); // self-heal (worst case ~20 s at 1000×) + one short leg, fast-forwarded in cleanup
+  test.setTimeout(300_000); // self-heal (worst case ~2 s at FAST) + one short leg, fast-forwarded in cleanup
   await flyHomeViaApi(page);
 
   // Full tank before departure — deterministic baseline (ISS-082 hook; dispatch would auto-refuel anyway).

e2e/two-planes.spec.ts

@@ -23,6 +23,7 @@ test.beforeEach(async ({ page }) => { await authenticate(page); });
 // guarantee the fleet is exactly one plane (the starter, grounded at EDDF) before and after.
 
 const SCALE = 1000; // test rate for fast-forwarding legs — keeps flights to seconds of real time
+const FAST = 10_000; // pure arrival waits (no mid-leg observation) — range-edge legs land in ~2.5 s
 const WORLD = 24; // the fixed world rate (ISS-117) — must match lib/worldClock.ts
 const HUB = 'EDDF'; // must match HUB_ICAO in lib/game/seed.ts
 const STARTER = 'plane-starter'; // the seeded plane's id (lib/game/seed.ts)
@@ -349,7 +350,7 @@ test('two grounded planes: Load is one-click with a preselected plane; the picke
 });
 
 test('two planes fly in parallel and both deliver their packages', async ({ page }) => {
-  test.setTimeout(300_000); // self-heal + one long leg each way at scale 1000
+  test.setTimeout(300_000); // self-heal + range-edge legs fast-forwarded at 10_000×
   const secondId = await buySecondPlaneViaUi(page);
 
   // Full tanks for both — the starter's may be partial from an earlier run.
@@ -379,8 +380,9 @@ test('two planes fly in parallel and both deliver their packages', async ({ page
   expect(s1.planes.find((p) => p.id === secondId)?.status).toBe('flying');
   expect(s1.planes.find((p) => p.id === secondId)?.destIcao).toBe(farthest.icao);
 
-  // Fast-forward to the FIRST landing (the short hop)…
+  // Fast-forward to the FIRST landing (the short hop)… FAST is safe here — pure arrival waits, and a
-  await setScale(page, SCALE);
+  // lagged tick can only land a plane sooner. The range-edge leg takes ~2.5 s at this rate.
+  await setScale(page, FAST);
   await expect
     .poll(async () => ((await getState(page)).planes.some((p) => p.status === 'available')), {
       timeout: 240_000,
@@ -403,9 +405,17 @@ test('two planes fly in parallel and both deliver their packages', async ({ page
   // The outbound to the range edge left the tank nearly empty — top it back up (ISS-082 hook).
   await setFuelFull(page, secondId);
 
-  // Cleanup: fly both home so the live instance stays in its onboarding state for later specs.
+  // Cleanup: fly both home so the live instance stays in its onboarding state for later specs. The legs
+  // dispatch at FAST (inherited above) — let them finish HERE, otherwise afterEach's heal pays the
+  // range-edge return leg at SCALE (~24 s).
   expect((await page.request.post(`/api/planes/${secondId}/fly`, { data: { destIcao: HUB } })).status()).toBe(200);
   expect((await page.request.post(`/api/planes/${STARTER}/fly`, { data: { destIcao: HUB } })).status()).toBe(200);
+  await expect
+    .poll(async () => ((await getState(page)).planes.every((p) => p.status === 'available')), {
+      timeout: 120_000,
+      message: 'waiting for both planes to land back at the hub',
+    })
+    .toBe(true);
 });
 
 // ISS-082 (v0.42.0): the "refuel section lists both planes" test is gone with the manual refuel UI —

lib/sim/engine.test.ts

@@ -742,6 +742,32 @@ describe('grounded fleet freezes the world clock (#135)', () => {
     expect(sim.clockMs).toBeGreaterThan(STARTING_CLOCK_MS); // the repair gate is what keeps time moving
   });
 
+  it('N-player fleet: one owner airborne keeps the clock running; all owners grounded freezes it (ISS-113)', async () => {
+    const inst = await freshDb('nplayer-clock.db');
+    // A second player with their own GROUNDED plane — the world now has two owners.
+    await inst.db.insert(schema.players).values({ id: 'player-b', provider: 'test', username: 'b', cash: 1_000, reputation: STARTING_REPUTATION });
+    await inst.db.insert(schema.planes).values({
+      id: 'plane-b', ownerId: 'player-b', model: 'atr72', status: 'available', fuel: 100, maxFuel: PLANE_TYPES.atr72.maxFuel,
+      locationIcao: 'EDDF', destIcao: null, lat: 50.03, lon: 8.57, departureSimTime: null,
+    });
+
+    // A (local) takes off while B stays grounded → the world advances — one owner flying is enough…
+    await makeWorldActive(inst);
+    vi.setSystemTime(T0 + 1_000);
+    const sim = await tickOnce(inst);
+    expect(sim.clockMs).toBe(STARTING_CLOCK_MS + 1_000 * WORLD_TIME_SCALE); // …at the fixed world rate
+
+    // …and grounding A's plane (B was already grounded) freezes the whole world.
+    await inst.db.update(schema.planes)
+      .set({ status: 'available', destIcao: null, departureSimTime: null })
+      .where(eq(schema.planes.id, 'plane-starter'));
+    vi.setSystemTime(T0 + 2_000); // a full second of real idleness with every owner grounded
+    const frozen = await tickOnce(inst);
+
+    expect(frozen.clockMs).toBe(STARTING_CLOCK_MS + 1_000 * WORLD_TIME_SCALE); // frozen — no advance…
+    expect(frozen.lastRealTickMs).toBe(T0 + 2_000); // …but the real-time anchor keeps tracking
+  });
+
   it('a frozen tick still refills the pool so a grounded fleet never starves (#135 follow-up)', async () => {
     const inst = await freshDb('frozen-topup.db'); // seeded starter is on the ground → frozen
     // Drain the open market the way wall-clock expiry would (removal paths run while frozen).
@@ -944,6 +970,24 @@ describe('spawnPoolPackages (v0.65.0 per-airport pools)', () => {
     }
   });
 
+  it('MAX picks the local row when local leads — symmetric to the player-b case (v1.5.0)', async () => {
+    const inst = await freshDb('pool-shared-rep-local.db');
+    // Local is far ahead of b's starting rep — a "prefer non-local" implementation would pick b and fail here.
+    await updateLocalPlayerEconomy(inst, { reputation: 60 });
+    await inst.db.insert(schema.players).values({ id: 'player-b', provider: 'test', username: 'b', cash: 1_000, reputation: STARTING_REPUTATION });
+    for (const p of await inst.db.select().from(schema.packages)) {
+      await inst.db.delete(schema.packages).where(eq(schema.packages.id, p.id));
+    }
+
+    expect(await spawnPoolPackages(inst, T0 + 5_000, mulberry32(7), T0)).toBe(POOL_TARGET_PER_AIRPORT);
+
+    const openRows = (await inst.db.select().from(schema.packages)).filter((p) => p.status === 'open');
+    for (const p of openRows) {
+      expect(p.reward).toBe(await expectedRewardAt(p, 60)); // every job scaled to the MAX…
+      expect(p.reward).not.toBe(await expectedRewardAt(p, STARTING_REPUTATION)); // …not to b's starting rep
+    }
+  });
+
   it("single player: spawn quality is that player's own reputation (v1.5.0 regression guard)", async () => {
     const inst = await freshDb('pool-single-rep.db');
     // Raise the only player's rep so the bonus is non-trivial, then respawn from zero with a fixed RNG —

package.json

@@ -1,6 +1,6 @@
 {
   "name": "flight-ops",
-  "version": "1.6.0",
+  "version": "1.9.0",
   "private": true,
   "scripts": {
     "dev": "next dev -p 3000",