CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## v0.64.0 — 2026-09-23 10:06
+- **Market keeps topping up while the fleet is grounded (#135 follow-up).** Root cause of a soft-lock introduced by v0.62.0's frozen clock: in `tickOnce` (`lib/sim/engine.ts`) every package-CREATION path (market top-up + coverage spawn) sat behind the same `advanceMs > 0` gate as expiry/delivery/repairs, while removal paths did not — `ignorePackage` runs on any request regardless of advance. A fully grounded fleet therefore froze the clock AND stopped all spawning, so repeated ignores could drain the market below `MARKET_TARGET_OPEN_PACKAGES = 10` (down to zero) and no code path ever created new jobs again: a player with a grounded fleet and an empty market was stuck forever. Fix: only the two spawn calls moved OUT of the gate — `spawnOpenPackages` + `spawnCoveragePackages` now run on EVERY tick, including frozen ones, passing the current (possibly frozen) `clockMs`; `expirePackages`, `deliverPackages` and `finishRepairs` stay inside it. Both spawns were already idempotent no-ops when satisfied (count-gated at target / set-gated by uncovered grounded airports), so advancing ticks behave exactly as before and the clock stays EXACTLY frozen while grounded — only new packages appear, created at game time. No schema change, no migration, no other engine behavior touched.
+- **Tests.** Unit: `lib/sim/engine.test.ts` — "a frozen tick still tops up the market so a grounded fleet never starves (#135 follow-up)": fully grounded fleet (advance=false), open market drained to zero via direct DB writes, one tick → asserts BOTH that `sim.clockMs` is unchanged (freeze preserved) AND that the open count is back at ≥ `MARKET_TARGET_OPEN_PACKAGES` with ≥1 open package originating at the grounded starter's airport (EDDF coverage). E2E: `e2e/sim.spec.ts` — "a grounded fleet never starves: ignoring every open package cannot empty the market (#135 follow-up)": self-heals to a fully grounded fleet, drains by calling `POST /api/packages/[id]/ignore` for every open package in repeated passes (pre-fix this reached zero and stayed there; post-fix each request's tick re-tops-up before its removal, so it can't), then `expect.poll`s that the open count from `/api/state` is above 0 within ~5 s of real time while asserting `simState.clockMs` stays EXACTLY equal to its pre-drain value and no plane took off — pinning both starvation-fixed and clock-still-frozen.
+
 ## v0.63.0 — 2026-09-23 08:43
 - **Overlay colors retuned for the Fiord default (ISS-118).** The first half of this issue landed in v0.4.0 (`DEFAULT_STYLE_ID = 'fiord'` + top-bar switcher, e2e already pins `toHaveValue('fiord')`); this completes the second half — auditing every color drawn on the map against Fiord's actual palette. Key finding: OpenFreeMap's Fiord is a DARK cool-toned basemap (land #45516E slate, water #38435C navy — verified byte-identical between the self-hosted `public/styles/fiord.json` and `tiles.openfreemap.org/styles/fiord`), not a light one. WCAG contrast audit of all nine overlay colors against both base surfaces: seven already read fine (≥ 3.3:1 on land AND water) and are untouched — amber flying leg #f59e0b, gold dotted queue line #d4a017 (ISS-098 picked it for light+dark), sky-blue grounded plane + hover halo #38bdf8, green flying plane #22c55e, yellow hover ring/trace #facc15, green target ring #4ade80. Two were weak and got brightened one step within the same hue family: airport dot fill rose-600 #e11d48 (1.68:1 on slate land — the weakest element on the map) → rose-500 #f43f5e (2.15:1), and the hovered-route highlight red-500 #ef4444 (2.10:1, below the 3:1 graphical-object bar for an emphasis layer) → red-400 #f87171 (2.86:1 on land / 3.57:1 on water). White strokes and all other paint values unchanged; no new constants — both colors are single-use inline paint values, matching the existing style of this file.
 - **Tests.** No test changes needed: `components/map.test.ts` pins only #d4a017 (untouched), e2e specs query rendered features by id/layer rather than color, and `lib/mapStyles.test.ts` already pins `DEFAULT_STYLE_ID = 'fiord'`.

e2e/sim.spec.ts

@@ -82,6 +82,51 @@ test('a fully grounded fleet freezes the world clock (#135)', async ({ page }) =
   expect(after.simState.clockMs - c0, 'the grounded clock must stay frozen').toBe(0);
 });
 
+test('a grounded fleet never starves: ignoring every open package cannot empty the market (#135 follow-up)', async ({ page }) => {
+  // Self-heal to a fully grounded fleet first — that is what freezes the world clock (#135), and
+  // the freeze is exactly what used to let the drain stick (no frozen tick spawned replacements).
+  await expect
+    .poll(async () => {
+      const res = await page.request.get('/api/state');
+      if (res.status() !== 200) return 'down';
+      const body = (await res.json()) as StateBody;
+      return body.planes.every((p) => p.status === 'available') ? 'idle' : 'busy';
+    }, { timeout: 120_000, message: 'waiting for the fleet to be fully grounded' })
+    .toBe('idle');
+
+  const before = await getState(page);
+  expect(before.planes.every((p) => p.status === 'available'), 'fleet should be grounded at spec start').toBe(true);
+  const clockBefore = before.simState.clockMs;
+
+  // Drain: ignore every open package, pass after pass. Pre-fix (v0.62.0) a frozen tick never
+  // spawned replacements, so this reached zero and stayed there — the soft-lock. Post-fix every
+  // request's tick re-tops-up BEFORE its removal, so the market can never empty; cap the passes to
+  // bound runtime either way (a zero-open snapshot would mean the bug is back).
+  for (let pass = 0; pass < 3; pass++) {
+    const s = await getState(page);
+    const open = s.packages.filter((p) => p.status === 'open');
+    if (open.length === 0) break; // drained — the pre-fix soft-lock state
+    for (const p of open) {
+      expect((await page.request.post(`/api/packages/${p.id}/ignore`)).status()).toBe(200);
+    }
+  }
+
+  // The ~1 s background tick must top the market back up within ~5 s of real time…
+  let topped: StateBody | undefined;
+  await expect
+    .poll(async () => {
+      const body = await getState(page);
+      if (body.packages.some((p) => p.status === 'open')) topped = body;
+      return !!topped;
+    }, { timeout: 5_000, message: 'waiting for the market to refill while grounded' })
+    .toBe(true);
+
+  const after = topped!;
+  expect(after.packages.filter((p) => p.status === 'open').length).toBeGreaterThan(0); // starvation fixed…
+  expect(after.planes.every((p) => p.status === 'available'), 'no plane may have taken off during the drain').toBe(true); // …with no plane flying…
+  expect(after.simState.clockMs, 'the grounded clock must stay exactly frozen while the market refills').toBe(clockBefore); // …and the world still frozen
+});
+
 test('timeScale 1000 advances the clock by roughly real-time × 1000 between polls', async ({ page }) => {
   await activateWorld(page);
   try {

lib/sim/engine.test.ts

@@ -641,6 +641,24 @@ describe('grounded fleet freezes the world clock (#135)', () => {
 
     expect(sim.clockMs).toBeGreaterThan(STARTING_CLOCK_MS); // the repair gate is what keeps time moving
   });
+
+  it('a frozen tick still tops up the market 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 to zero the way repeated ignores would (removal paths run while frozen).
+    for (const p of await inst.db.select().from(schema.packages)) {
+      if (p.status === 'open') {
+        await inst.db.update(schema.packages).set({ status: 'ignored' }).where(eq(schema.packages.id, p.id));
+      }
+    }
+
+    vi.setSystemTime(T0 + 1_000); // a background tick while the fleet is grounded
+    const sim = await tickOnce(inst);
+
+    expect(sim.clockMs).toBe(STARTING_CLOCK_MS); // freeze preserved…
+    const openRows = (await inst.db.select().from(schema.packages)).filter((p) => p.status === 'open');
+    expect(openRows.length).toBeGreaterThanOrEqual(MARKET_TARGET_OPEN_PACKAGES); // …but the market is topped back up…
+    expect(openRows.some((p) => p.originIcao === 'EDDF')).toBe(true); // …including coverage for the grounded starter's airport
+  });
 });
 
 describe('spawnOpenPackages', () => {

lib/sim/engine.ts

@@ -69,8 +69,8 @@ function withLock<T>(fn: () => Promise<T>): Promise<T> {
 
 // #135: advance decision — pure, so unit tests feed it synthetic fleets. The world clock runs at
 // full scale only while something is happening (at least one plane flying OR in repair); a fully
-// grounded fleet freezes it entirely — no expiry/spawn/repair progress until a dispatch or repair
-// starts again.
+// grounded fleet freezes it entirely — no expiry/delivery/repair progress until a dispatch or
+// repair starts again (the market top-up still runs on frozen ticks, #135 follow-up).
 export function shouldAdvanceTime(planes: Array<{ status: string }>): { advance: boolean; flying: number; repairing: number } {
   let flying = 0;
   let repairing = 0;
@@ -87,8 +87,9 @@ export async function tickOnce(inst: GameDb): Promise<schema.SimStateRow> {
   if (!sim) throw new Error('sim_state row missing');
 
   const nowMs = Date.now();
-  // #135: a fully grounded fleet freezes the world — no advance, no expiry/spawn/repair progress.
-  // lastRealTickMs always tracks real time, so resuming activity never fast-forwards the frozen span.
+  // #135: a fully grounded fleet freezes the world — no advance, no expiry/delivery/repair progress
+  // (the market top-up still runs on frozen ticks — see below). lastRealTickMs always tracks real
+  // time, so resuming activity never fast-forwards the frozen span.
   const planeRows = await inst.db.select().from(schema.planes);
   const { advance } = shouldAdvanceTime(planeRows.map((p) => ({ status: p.status })));
   // #135 (v0.62.0): production ALWAYS runs at the fixed world rate — legacy saves may hold a stale
@@ -105,11 +106,15 @@ export async function tickOnce(inst: GameDb): Promise<schema.SimStateRow> {
     // v0.39.0 (ISS-069): repairs whose gate has passed flip back to 'available' — runs even when
     // nothing landed this tick; BEFORE the spawns so a just-repaired plane gets coverage work too.
     await finishRepairs(inst, clockMs);
-    await spawnOpenPackages(inst, clockMs);
-    // AFTER delivery on purpose: a plane that just landed gets work spawned
-    // at its new location within the same tick.
-    await spawnCoveragePackages(inst, clockMs);
   }
+  // #135 follow-up (v0.64.0): market top-up + coverage spawn run on EVERY tick — frozen ones
+  // included — because while grounded nothing else creates packages but removal paths (ignore)
+  // still run; without this a grounded fleet could drain the market to zero and soft-lock forever.
+  // Both are idempotent no-ops when satisfied, so advancing ticks behave exactly as before.
+  await spawnOpenPackages(inst, clockMs);
+  // AFTER delivery on purpose: a plane that just landed gets work spawned
+  // at its new location within the same tick.
+  await spawnCoveragePackages(inst, clockMs);
 
   // Persist lastRealTickMs even when nothing advanced — it is the tick anchor.
   await inst.db.update(schema.simState).set({ clockMs, lastRealTickMs: nowMs });

package.json

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