Auto-refuel on dispatch; remove manual refueling UI/API/action (ISS-082, v0.42.0)

e2e/right-pane.spec.ts

@@ -4,9 +4,9 @@ import { expect, test } from '@playwright/test';
 // the repo's tsconfig paths, so importing beats mirroring a third copy of the formulas.
 import { initialBearingDeg } from '../lib/geo';
 import { weatherFor } from '../lib/weather';
-import { windBurnFactor } from '../lib/sim/movement';
+import { fuelAtWeighted, windBurnFactor } from '../lib/sim/movement';
 // v0.38.0 (ISS-072) — reputation discounts: expectations computed from the LIVE snapshot's rep with the real helpers.
-import { FUEL_DISCOUNT_PER_REP, MAX_FUEL_DISCOUNT, MAX_PLANE_DISCOUNT, PLANE_DISCOUNT_PER_REP, repRate } from '../lib/game/catalog';
+import { conditionBurnMultiplier, FUEL_DISCOUNT_PER_REP, MAX_FUEL_DISCOUNT, MAX_PLANE_DISCOUNT, PLANE_DISCOUNT_PER_REP, repRate } from '../lib/game/catalog';
 import { STARTING_REPUTATION } from '../lib/game/seed';
 
 // v0.12.0 — right Jobs & Market pane against the live origin: open packages render with
@@ -14,8 +14,8 @@ import { STARTING_REPUTATION } from '../lib/game/seed';
 // (moved to the left pane in v0.20.0, ISS-021) shows loaded packages with fly-to-destination +
 // abandon buttons (penalty preview from the same
 // formula as the server); flying planes show their current leg; market buy/sell previews match
-// the catalog + economy constants exposed in /api/state, and the Refuel-to-full row (moved to the
-// left pane in v0.23.0, ISS-035) deducts exactly its cost. Packages are created via
+// the catalog + economy constants exposed in /api/state, and dispatch auto-refuels a low tank to
+// 150% of the leg requirement at exactly its rep-discounted cost (ISS-082). Packages are created via
 // POST /api/test/create-package (FLIGHT_TEST_HOOKS=1), same pattern as e2e/actions.spec.ts.
 
 const SCALE = 1000; // fastest sim speed (v0.14.0 ladder top) — keeps flights to seconds of real time
@@ -27,6 +27,7 @@ interface PlaneState {
   status: 'available' | 'flying';
   fuel: number;
   maxFuel: number;
+  health: number; // v0.39.0 (ISS-069) — feeds conditionBurnMultiplier in the auto-refuel math
   locationIcao: string;
   destIcao: string | null;
 }
@@ -112,7 +113,8 @@ function penaltyFor(reward: number, createdSimTime: number, deadlineSimTime: num
 }
 
 // Closest airport to EDDF from /api/airports → shortest possible arrival time at scale 1000.
-async function nearestToHub(page: Page): Promise<{ icao: string; lat: number; lon: number }> {
+// Returns both endpoints' coordinates so exact-km fuel assertions can mirror lib/geo.ts.
+async function nearestToHub(page: Page): Promise<{ icao: string; lat: number; lon: number; hubLat: number; hubLon: number }> {
   const fc = (await (await page.request.get('/api/airports')).json()) as {
     features: Array<{ properties: { icao: string; lat: number; lon: number } }>;
   };
@@ -124,38 +126,7 @@ async function nearestToHub(page: Page): Promise<{ icao: string; lat: number; lo
       nearest = f.properties;
     }
   }
-  return nearest;
-}
-
-// Farthest airport from EDDF whose leg still FITS A FULL TANK — the longest flyable leg (v0.16.0
-// refuel-for-flight test). The dataset's absolute farthest can exceed the aircraft's range, so a
-// full-tank fly there would rightly 409; this test wants a long-but-flyable leg instead. Wind-
-// adjusted (v0.36.0): BOTH directions must fit — the outbound is flown from a full tank and the
-// return leg is what the forFlight refuel below buys, which also 409s if it doesn't fit.
-async function farthestFlyableToHub(
-  page: Page,
-  entry: CatalogEntry,
-): Promise<{ icao: string; lat: number; lon: number; d: number; hubLat: number; hubLon: number }> {
-  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;
-  const wHub = weatherFor(HUB);
-  let farthest: { icao: string; lat: number; lon: number; d: number } | null = null;
-  for (const f of fc.features) {
-    if (f.properties.icao === HUB) continue;
-    const d = haversineKm(hub.lat, hub.lon, f.properties.lat, f.properties.lon);
-    const wDest = weatherFor(f.properties.icao);
-    const outBurn = entry.burnPerKm * windBurnFactor(wHub.windKt, wHub.windDirDeg, initialBearingDeg(hub.lat, hub.lon, f.properties.lat, f.properties.lon));
-    if (requiredFuelFor(outBurn, entry.emptyWeightKg, entry.maxFuel, d) > entry.maxFuel) continue; // beyond range
-    const backBurn = entry.burnPerKm * windBurnFactor(wDest.windKt, wDest.windDirDeg, initialBearingDeg(f.properties.lat, f.properties.lon, hub.lat, hub.lon));
-    if (requiredFuelFor(backBurn, entry.emptyWeightKg, entry.maxFuel, d) > entry.maxFuel) continue; // return leg wouldn't fit a full tank either
-    if (!farthest || d > farthest.d) {
-      farthest = { icao: f.properties.icao, lat: f.properties.lat, lon: f.properties.lon, d };
-    }
-  }
-  if (!farthest) throw new Error('no full-tank-flyable airport found in the dataset');
-  return { ...farthest, hubLat: hub.lat, hubLon: hub.lon };
+  return { ...nearest, hubLat: hub.lat, hubLon: hub.lon };
 }
 
 // Mirrors lib/sim/movement.ts (v0.16.0): fuel required to cover distanceKm arriving empty —
@@ -204,14 +175,10 @@ async function flyHomeViaApi(page: Page): Promise<void> {
   }
   if (starter.locationIcao !== HUB) {
     // ISS-041: the landing above paused the sim — setScale clears pause so the return leg
-    // fast-forwards instead of taking real-time hours.
+    // fast-forwards instead of taking real-time hours. ISS-082: dispatch auto-refuels, so a
+    // grounded plane can always start any full-tank-flyable leg when cash allows — no top-up retry needed.
     await setScale(page, SCALE);
-    let flyHome = await page.request.post('/api/planes/plane-starter/fly', { data: { destIcao: HUB } });
-    if (!flyHome.ok()) {
-      // A long outbound leg can leave the tank too empty for the return — top up and retry.
-      expect((await page.request.post('/api/planes/plane-starter/refuel')).status()).toBe(200);
-      flyHome = await page.request.post('/api/planes/plane-starter/fly', { data: { destIcao: HUB } });
-    }
+    const flyHome = await page.request.post('/api/planes/plane-starter/fly', { data: { destIcao: HUB } });
     expect(flyHome.status()).toBe(200); // repositioning needs no package (v0.12.0 manual flight)
     await expect
       .poll(async () => (await getState(page)).planes.find((p) => p.id === 'plane-starter')?.locationIcao === HUB, {
@@ -361,7 +328,7 @@ test('on-board list: fly-to-destination + abandon with penalty preview; flying p
     .toBe(true);
 });
 
-test('market buy/sell render with previews from the catalog in /api/state; left-pane Refuel deducts exactly', async ({ page }) => {
+test('market buy/sell render with previews from the catalog in /api/state', async ({ page }) => {
   test.setTimeout(300_000); // self-heal can take minutes after an interrupted run
   await flyHomeViaApi(page); // grounded starter at EDDF (tank partial after the previous test's flight)
 
@@ -397,117 +364,80 @@ test('market buy/sell render with previews from the catalog in /api/state; left-
   await page.getByTestId('market-sell-plane').selectOption('plane-starter', { timeout: 15_000 });
   const payout = Math.round(entry.price * body.sellFraction * 100) / 100;
   await expect(page.getByTestId('market-sell-payout')).toContainText(eur(payout));
-
-  // ISS-035 (v0.23.0): the Refuel-to-full row now lives in the LEFT pane next to Relocate — same global testids.
-  await expect(page.getByTestId('left-pane').getByTestId('market-refuel')).toBeVisible({ timeout: 15_000 });
-
-  // Refuel through the pane: the flight genuinely burned fuel…
-  if (starter.fuel < starter.maxFuel) {
-    // v0.38.0 (ISS-072): rep-scaled cost — same formula as the server's refuelPlane 'full'.
-    const fuelRate = repRate(body.account.reputation, FUEL_DISCOUNT_PER_REP, MAX_FUEL_DISCOUNT);
-    const expectedCost = Math.round((starter.maxFuel - starter.fuel) * body.fuelPricePerL * (1 - fuelRate) * 100) / 100;
-    const cashBefore = body.account.cash;
-
-    // …the refuel picker lists it, the preview matches the exact cost, and the click deducts it.
-    await expect(page.getByTestId('market-refuel-plane')).toBeVisible({ timeout: 15_000 });
-    await page.getByTestId('market-refuel-plane').selectOption('plane-starter');
-    await expect(page.getByTestId('market-refuel-cost')).toContainText(eur(expectedCost));
-    await page.getByTestId('market-refuel').click();
-
-    // Cash decreased by exactly the expected cost and the tank is full (server truth).
-    await expect
-      .poll(async () => {
-        const b = await getState(page);
-        return Math.abs(b.account.cash - (cashBefore - expectedCost)) < 0.001;
-      }, { timeout: 15_000, message: 'waiting for the refuel cost to land in /api/state' })
-      .toBe(true);
-    const after = await getState(page);
-    expect(after.planes.find((p) => p.id === 'plane-starter')!.fuel).toBe(starter.maxFuel);
-  }
 });
 
-test('on-board row Refuel buys 150% of the weather-adjusted leg requirement; left-pane button says "Refuel to full"', async ({ page }) => {
-  test.setTimeout(300_000); // self-heal + one long flight each way at scale 1000
+// ISS-082 (v0.42.0): manual refuel is gone — dispatch auto-refuels instead. This test pins the new
+// behavior end-to-end: drop a grounded starter to low fuel via the hook, fly a leg, and assert the
+// cash delta equals the EXACT rep-discounted top-up cost (computed from the snapshot + real lib
+// helpers) while the post-flight landed fuel matches the weighted burn from the topped start value.
+test('dispatch auto-refuels: a low tank tops up to 150% of the leg requirement and deducts exactly', async ({ page }) => {
+  test.setTimeout(300_000); // self-heal + one short flight each way at scale 1000
   await flyHomeViaApi(page);
 
   const body = await getState(page);
   const entry = body.catalog.find((e) => e.model === 'atr72')!;
 
-  // Deterministic baseline: a full tank.
-  expect((await page.request.post('/api/planes/plane-starter/refuel')).status()).toBe(200);
+  // Drop the grounded starter to a low, deterministic fuel level via the test hook — well below the
+  // 150%-of-requirement target even for the shortest dataset leg (EDFH, ~93 km), so a top-up is guaranteed.
+  const LOW_FUEL = 50;
+  expect((await page.request.post('/api/test/set-fuel', { data: { planeId: 'plane-starter', fuel: LOW_FUEL } })).status()).toBe(200);
 
-  // Longest FLYABLE leg from the hub (fits a full tank) — long enough that 150% of its requirement
-  // exceeds what's left on arrival.
-  const farthest = await farthestFlyableToHub(page, entry);
-  const pkg1 = await createPackage(page, HUB, farthest.icao, 24 * 3_600_000);
-  expect((await page.request.post(`/api/packages/${pkg1.id}/load`, { data: { planeId: 'plane-starter' } })).status()).toBe(200);
+  // Nearest airport to the hub → short leg, fast at scale 1000.
+  const nearest = await nearestToHub(page);
+  const pre = await getState(page);
+  const starter = pre.planes.find((p) => p.id === 'plane-starter')!;
+  expect(starter.fuel).toBe(LOW_FUEL); // the hook stuck
 
-  // Fly there (delivers pkg1 on arrival) — the tank is now partial.
-  expect((await page.request.post('/api/planes/plane-starter/fly', { data: { destIcao: farthest.icao } })).status()).toBe(200);
+  // Expected top-up from the snapshot constants — mirrors flyPlane's math (lib/game/actions.ts):
+  // wind-adjusted requirement × condition multiplier, 150% margin capped at tank capacity.
+  const km = haversineKm(nearest.hubLat, nearest.hubLon, nearest.lat, nearest.lon);
+  const wHub = weatherFor(HUB);
+  const required = requiredFuelFor(
+    entry.burnPerKm * windBurnFactor(wHub.windKt, wHub.windDirDeg, initialBearingDeg(nearest.hubLat, nearest.hubLon, nearest.lat, nearest.lon)) * conditionBurnMultiplier(starter.health),
+    entry.emptyWeightKg,
+    entry.maxFuel,
+    km,
+  );
+  const target = Math.min(entry.maxFuel, Math.max(LOW_FUEL, required * 1.5)); // ISS-082: 150% margin, capped at tank capacity
+  const liters = Math.max(0, target - LOW_FUEL);
+  expect(liters).toBeGreaterThan(0); // the low tank genuinely needs a top-up
+  const fuelRate = repRate(pre.account.reputation, FUEL_DISCOUNT_PER_REP, MAX_FUEL_DISCOUNT);
+  const expectedCost = Math.round(liters * pre.fuelPricePerL * (1 - fuelRate) * 100) / 100;
+  const cashBefore = pre.account.cash;
+
+  // Dispatch via the API — the response snapshot is authoritative at the action's clock.
+  const flyRes = await page.request.post('/api/planes/plane-starter/fly', { data: { destIcao: nearest.icao } });
+  expect(flyRes.status()).toBe(200); // auto-refuel made the low tank flyable…
+  const post = (await flyRes.json()) as StateBody;
+  expect(post.planes.find((p) => p.id === 'plane-starter')!.fuel).toBeCloseTo(target, 6); // …departing with exactly the topped level
+  expect(post.account.cash).toBeCloseTo(cashBefore - expectedCost, 6); // …at exactly the rep-discounted cost
+
+  // Fast-forward to arrival; the landed fuel is the weighted burn from the TOPPED start value.
   await setScale(page, SCALE);
   await expect
     .poll(async () => {
       const b = await getState(page);
       const p = b.planes.find((x) => x.id === 'plane-starter');
-      return !!p && p.status === 'available' && p.locationIcao === farthest.icao;
-    }, { timeout: 240_000, message: `waiting for arrival at ${farthest.icao} (scale 1000)` })
+      return !!p && p.status === 'available' && p.locationIcao === nearest.icao;
+    }, { timeout: 120_000, message: `waiting for arrival at ${nearest.icao} (scale 1000)` })
     .toBe(true);
 
-  // New work at the far end: a package back to the hub — its leg is exactly what we refuel for.
-  const pkg2 = await createPackage(page, farthest.icao, HUB, 24 * 3_600_000);
-  expect((await page.request.post(`/api/packages/${pkg2.id}/load`, { data: { planeId: 'plane-starter' } })).status()).toBe(200);
-
-  // Expected "150% of the requirement" from the snapshot constants (mirrors requiredFuelFor in
-  // lib/sim/movement.ts, wind-adjusted per v0.36.0 — departure weather at the far end vs heading home).
-  const pre = await getState(page);
-  const fuelBefore = pre.planes.find((p) => p.id === 'plane-starter')!.fuel;
-  const cashBefore = pre.account.cash;
-  const km = haversineKm(farthest.hubLat, farthest.hubLon, farthest.lat, farthest.lon); // symmetric: hub ↔ far end
-  const wFar = weatherFor(farthest.icao);
-  const required = requiredFuelFor(
-    entry.burnPerKm * windBurnFactor(wFar.windKt, wFar.windDirDeg, initialBearingDeg(farthest.lat, farthest.lon, farthest.hubLat, farthest.hubLon)),
-    entry.emptyWeightKg,
-    entry.maxFuel,
-    km,
+  const landed = await getState(page);
+  expect(landed.planes.find((p) => p.id === 'plane-starter')!.fuel).toBeCloseTo(
+    fuelAtWeighted(target, entry.burnPerKm * windBurnFactor(wHub.windKt, wHub.windDirDeg, initialBearingDeg(nearest.hubLat, nearest.hubLon, nearest.lat, nearest.lon)) * conditionBurnMultiplier(starter.health), entry.emptyWeightKg, entry.maxFuel, km, 1),
+    6,
   );
-  const target = Math.min(entry.maxFuel, required * 1.5); // ISS-071: 150% margin, capped at tank capacity
-  const liters = Math.max(0, target - fuelBefore);
-  expect(liters).toBeGreaterThan(0); // the long leg genuinely needs more than what's left
-  // v0.38.0 (ISS-072): rep-scaled cost — same formula as the server's refuelPlane 'forFlight'.
-  const fuelRate = repRate(pre.account.reputation, FUEL_DISCOUNT_PER_REP, MAX_FUEL_DISCOUNT);
-  const expectedCost = Math.round(liters * pre.fuelPricePerL * (1 - fuelRate) * 100) / 100;
 
-  await page.goto('/');
-  const refuelBtn = page.getByTestId(`refuel-for-${pkg2.id}`);
-  await expect(refuelBtn, 'row Refuel button appears for the loaded package').toBeVisible({ timeout: 15_000 });
-  // Capture the endpoint's OWN response — the full post-action snapshot at the action's clock.
-  const [res] = await Promise.all([
-    page.waitForResponse((r) => r.url().includes(`/api/planes/plane-starter/refuel`), { timeout: 15_000 }),
-    refuelBtn.click(),
-  ]);
-  expect(res.status()).toBe(200);
-  const post = (await res.json()) as StateBody;
-
-  // Cash dropped by exactly L × price and fuel rose by exactly L.
-  expect(post.account.cash).toBeCloseTo(cashBefore - expectedCost, 6);
-  expect(post.planes.find((p) => p.id === 'plane-starter')!.fuel).toBeCloseTo(fuelBefore + liters, 6);
-
-  // Left pane (moved from the market in v0.23.0, ISS-035): the fill-up button is labeled "Refuel to full" (testid unchanged).
-  await expect(page.getByTestId('market-refuel')).toHaveText('Refuel to full');
-
-  // Restore: fly home — pkg2's destination IS the hub, so it delivers on arrival. The tank holds
-  // 150% of the leg requirement (or a full tank), so the return is comfortably feasible. ISS-041:
-  // the far-end arrival above paused the sim, so re-set SCALE for this leg (setScale clears pause).
+  // Restore: fly home (auto-refuel covers the return leg) and top the tank back up for later specs.
   await setScale(page, SCALE);
   expect((await page.request.post('/api/planes/plane-starter/fly', { data: { destIcao: HUB } })).status()).toBe(200);
   await expect
     .poll(async () => (await getState(page)).planes.find((p) => p.id === 'plane-starter')?.locationIcao === HUB, {
-      timeout: 240_000,
+      timeout: 120_000,
       message: 'waiting for plane-starter to land back at the hub',
     })
     .toBe(true);
-  // Top the tank back up so later specs start with a full tank.
-  expect((await page.request.post('/api/planes/plane-starter/refuel')).status()).toBe(200);
+  expect((await page.request.post('/api/test/set-fuel', { data: { planeId: 'plane-starter', fuel: entry.maxFuel } })).status()).toBe(200);
 });
 
 test('Ignore removes an open job from the list permanently (ISS-047 part B)', async ({ page }) => {