feat: v0.16.0 — ISS-005 weight-proportional fuel burn + refuel just enough for the loaded package

Part A: r(F) = k(We + rho*F) L/km, k calibrated so a full tank burns exactly
the old constant; closed forms in lib/sim/movement.ts (fuelAtWeighted,
requiredFuelFor, burnRateConstant, FUEL_DENSITY_KG_PER_L). Catalog gains
emptyWeightKg (ATR72 OEW 9300 kg), exposed in the snapshot. All three burn
call sites (engine landing, state live fuel, fly validation) moved to the
weighted model; old constant-rate fuelAt removed.

Part B: POST /api/planes/{planeId}/refuel takes an optional body
{mode:'full'|'forFlight', packageId} — no body keeps today's fill-to-full
behavior exactly (fuel lands bit-exact on maxFuel); forFlight adds just
enough for the loaded package's destination leg (409 not-loaded/expired/
doesn't-fit, 400 bad body). UI: per-cargo-row 'Refuel' button
(refuel-for-{pkg.id}), market button renamed 'Refuel to full'.

OpenAPI: RefuelRequest schema + optional requestBody + 400 on refuel, fly's
409 description updated, CatalogEntry.emptyWeightKg. Tests: new weighted-burn
suite, forFlight action/route cases (incl. ~7670 km UNNT<->LPPD doesn't-fit),
openapi guards; landing-fuel assertions in engine.test.ts + e2e/actions.spec.ts
use the closed form; the e2e 'return leg unfuelable' scenario reworked — a full
tank now covers the EDDF<->LEZL round trip, so the 409 moves to the second
outbound. New e2e: row Refuel deducts exactly L*price / raises fuel by exactly
L via the endpoint's own response snapshot.

e2e/right-pane.spec.ts

@@ -38,6 +38,7 @@ interface CatalogEntry {
   price: number;
   maxFuel: number;
   burnPerKm: number;
+  emptyWeightKg: number; // v0.16.0 weighted burn input
   speedKmh: number;
   capacity: number;
 }
@@ -114,6 +115,30 @@ async function nearestToHub(page: Page): Promise<{ icao: string; lat: number; lo
   return nearest;
 }
 
+// Farthest airport from EDDF — the longest possible leg (v0.16.0 refuel-for-flight test).
+async function farthestToHub(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 } }>;
+  };
+  const hub = fc.features.find((f) => f.properties.icao === HUB)!.properties;
+  let farthest = fc.features.filter((f) => f.properties.icao !== HUB)[0].properties;
+  for (const f of fc.features) {
+    if (f.properties.icao === HUB) continue;
+    if (haversineKm(hub.lat, hub.lon, f.properties.lat, f.properties.lon) > haversineKm(hub.lat, hub.lon, farthest.lat, farthest.lon)) {
+      farthest = f.properties;
+    }
+  }
+  return { icao: farthest.icao, lat: farthest.lat, lon: farthest.lon, hubLat: hub.lat, hubLon: hub.lon };
+}
+
+// Mirrors lib/sim/movement.ts (v0.16.0): fuel required to cover distanceKm arriving empty —
+// closed form of the weight-proportional burn model, k calibrated so a full tank burns burnPerKm.
+const FUEL_DENSITY_KG_PER_L = 0.8; // must match FUEL_DENSITY_KG_PER_L in lib/sim/movement.ts
+function requiredFuelFor(burnPerKm: number, emptyWeightKg: number, maxFuel: number, distanceKm: number): number {
+  const k = burnPerKm / (emptyWeightKg + FUEL_DENSITY_KG_PER_L * maxFuel);
+  return (emptyWeightKg / FUEL_DENSITY_KG_PER_L) * (Math.exp(k * FUEL_DENSITY_KG_PER_L * distanceKm) - 1);
+}
+
 // Test hook (FLIGHT_TEST_HOOKS=1): create an open package on a known route.
 async function createPackage(page: Page, fromIcao: string, toIcao: string, deadlineOffsetMs?: number): Promise<PackageState> {
   const created = await page.request.post('/api/test/create-package', {
@@ -307,3 +332,73 @@ test('market buy/sell/refuel render with previews from the catalog in /api/state
     expect(after.planes.find((p) => p.id === 'plane-starter')!.fuel).toBe(starter.maxFuel);
   }
 });
+
+test('on-board row Refuel tops up just enough for the package leg; market button says "Refuel to full"', async ({ page }) => {
+  test.setTimeout(300_000); // self-heal + one long 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);
+
+  // Longest leg from the hub — long enough that "just enough" for it exceeds what's left on arrival.
+  const farthest = await farthestToHub(page);
+  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);
+
+  // 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);
+  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)` })
+    .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 "just enough" from the snapshot constants (mirrors requiredFuelFor in lib/sim/movement.ts).
+  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 liters = Math.max(0, requiredFuelFor(entry.burnPerKm, entry.emptyWeightKg, entry.maxFuel, km) - fuelBefore);
+  expect(liters).toBeGreaterThan(0); // the long leg genuinely needs more than what's left
+  const expectedCost = Math.round(liters * pre.fuelPricePerL * 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);
+
+  // Market row: 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
+  // exactly the leg requirement, so this also proves "just enough" is enough.
+  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,
+      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);
+});