v0.72.0: fix admin login — re-seed scrypt digest computed by verifyPassword() call

v0.70.0 — Default map view: whole world at [0,0] (#147)

.gitea/workflows/ci.yml

@@ -189,10 +189,56 @@ jobs:
           # in-network app host out of any proxy path.
           NO_PROXY: app,localhost,127.0.0.1,.kkhost.pl
           no_proxy: app,localhost,127.0.0.1,.kkhost.pl
+          # Machine-readable e2e results for the job-summary step below (Playwright's built-in
+          # json reporter; without this env var it would dump to stdout). test-results/ is git-ignored.
+          PLAYWRIGHT_JSON_OUTPUT_FILE: test-results/e2e.json
         # Connectivity diagnostics now run post-deploy in e2e/ci-diagnostics.ts (globalSetup).
         # --reporter=list prints each test as it completes (name + ✓/× + duration) for progress
-        # visibility in the job log; failure error context/snapshots are unchanged.
+        # visibility in the job log; failure error context/snapshots are unchanged. The json
-        run: npx playwright test --reporter=list
+        # reporter adds a machine-readable report (PLAYWRIGHT_JSON_OUTPUT_FILE above) — no
+        # execution behavior changes, reporters only observe.
+        run: npx playwright test --reporter=list,json
+
+      # Appends e2e results to the job-summary panel — mirrors how unit tests get there
+      # (vitest's built-in github-actions reporter auto-appends $GITHUB_STEP_SUMMARY in CI).
+      # if: always() so a FAILED suite still gets summarized; non-fatal by design — a missing
+      # or malformed report must never mask the real e2e exit code. The script is single-quoted
+      # for bash, so it contains no apostrophes.
+      - name: E2E job summary
+        if: always()
+        run: |
+          node -e '
+            const fs = require("fs");
+            let report;
+            try {
+              report = JSON.parse(fs.readFileSync("test-results/e2e.json", "utf8"));
+            } catch {
+              process.exit(0); // e2e never ran (earlier step failed) or no report — nothing to summarize
+            }
+            let passed = 0, skipped = 0;
+            const failed = [];
+            const walk = (suite) => {
+              for (const spec of suite.specs ?? []) {
+                if (!spec.ok) failed.push(`${suite.title} › ${spec.title}`);
+                else if ((spec.tests ?? []).length && spec.tests.every((t) => t.expectedStatus === "skipped")) skipped++;
+                else passed++;
+              }
+              for (const sub of suite.suites ?? []) walk(sub);
+            };
+            for (const s of report.suites ?? []) walk(s);
+            const lines = [
+              "", "## E2E results", "",
+              `- Passed: ${passed}`,
+              `- Failed: ${failed.length}`,
+              `- Skipped: ${skipped}`,
+            ];
+            if (failed.length) {
+              lines.push("", "### Failed specs");
+              for (const f of failed) lines.push(`- \`${f}\``);
+            }
+            const summaryFile = process.env.GITHUB_STEP_SUMMARY;
+            if (summaryFile) fs.appendFileSync(summaryFile, lines.join("\n") + "\n");
+          ' || true
 
       # The daemon is shared with production — never leave our stack or network behind.
       # -v drops the named DB volume so every run seeds fresh (no schema drift between PRs).
@@ -201,3 +247,13 @@ jobs:
         run: |
           docker compose -f docker-compose.ci.yml -p flight-ci down --remove-orphans -v || true
           docker network remove flight-ci-e2e 2>/dev/null || true
+
+      # The shared runner dind still accumulates between runs what the steps above can't reach:
+      # dangling images/layers from the per-run flight-ops-ci rebuilds, BuildKit cache, and job
+      # containers leaked by interrupted runs. Prune them here (after stack + network cleanup).
+      # Deliberately NO --volumes: the daemon is shared with production and named volumes may hold
+      # other workflows' persistent data — this project's own flight-ci_flight-db volume is already
+      # dropped by the steps above. Non-fatal so a prune failure can never mask or break the run.
+      - name: Prune runner dind leftovers
+        if: always()
+        run: docker system prune -af || echo "::warning::dind prune failed — see logs"

CHANGELOG.md

@@ -1,5 +1,142 @@
 # Changelog
 
+## v0.72.0 — 2026-09-24 11:44
+- **Admin login fixed.** The seeded admin's scrypt digest in `lib/db/client.ts` was computed with different parameters than the verifier (`verifyPassword()` passes the salt as a plain string to `scryptSync(pw, saltHex, 32)`), so real logins failed with 401 "invalid credentials" since v0.71.0. The seed now carries a digest produced by exactly that call (the plaintext still exists nowhere in code, tests or comments). Because the seed is `INSERT … WHERE NOT EXISTS`, pre-existing databases keep their old row — so every `open()` also runs an idempotent rotation (`UPDATE users SET password_hash = ? WHERE id = 'admin-kamilkrzywda' AND password_hash != ?`): a no-op once healed, it repairs legacy rows at boot and is durable on the next persist. Unit tests cover the fresh seed with the new digest plus the rotate-on-open path (legacy file heals to the current digest; second open is a no-op).
+
+## v0.71.0 — 2026-09-24 09:18
+- **Admin panel.** A new "Admin" button on the right of the top bar opens a reusable modal (`components/Modal.tsx` — fixed overlay at z-index 60, above the z-50 toast stack; centered `role="dialog"` panel; closes on Escape and backdrop click) hosting `components/AdminPanel.tsx`. No new URL routes: everything lives behind that one button + modal.
+- **Users + sessions tables.** New `users` (id PK, unique username, scrypt `salt$hex` password_hash, admin flag, created_at) and `sessions` (UUID id, user_id, 7-day expires_at) tables in the raw DDL (`lib/db/client.ts`) and typed Drizzle entries (`lib/db/schema.ts`). An **idempotent seeded admin** is inserted on every `open()` — user id `admin-kamilkrzywda`, username `kamilkrzywda`, admin=1, hash-only (the plaintext exists nowhere in code, tests or comments) — guarded by `WHERE NOT EXISTS` so pre-existing production DBs gain exactly one row and never a duplicate. The users table is also the foundation for multiplayer auth (#105/#107).
+- **Auth API.** `POST /api/login {username,password}` verifies with node:crypto `scryptSync` + `timingSafeEqual`; an unknown username still runs one full scrypt against a fixed dummy digest so timing stays uniform. Success mints a 7-day session (lazy cleanup of expired rows) and returns `{sessionId, user:{username,admin}}`. `POST /api/logout` deletes the session named by the new `X-Flight-Session` header (idempotent); `GET /api/me` resolves it to the current user or 401. The client stores the sessionId in localStorage (`flight.session`) and sends the header on every authenticated request.
+- **Generic whole-database CRUD behind the admin flag.** `lib/auth.ts`'s `requireAdmin` guard (no/expired session → 401, non-admin → 403) runs before any input is touched on: `GET /api/admin/tables` (user tables, sqlite_% excluded) and `GET|PUT|POST|DELETE /api/admin/tables/{name}/rows` — rows carry their rowid as `__rowid` so the PK-less tables (account, sim_state) are editable like any other; PUT updates only changed cells, POST inserts, DELETE removes by rowid. SQL safety: table names quoted only after sqlite_master validation, column names validated against PRAGMA table_info, values ALWAYS bound as parameters — no user input is ever concatenated into SQL.
+- **UI.** The Admin modal shows a login form (wrong credentials show an error line), a "not an admin" notice for authenticated non-admins, or the grid: table list → per-table editable rows (each cell an input; per-row Save/Delete, "+ Add row", Refresh) with logout in the header area. Deliberately plain — it's a dev tool surface, not a product feature.
+- **Test hook.** `POST /api/test/admin-session` (FLIGHT_TEST_HOOKS=1 gate like its siblings) mints a session for the seeded admin server-side and returns `{sessionId}` — so the e2e suite can exercise the authenticated panel WITHOUT the real admin password ever appearing in test code.
+- **OpenAPI.** Five new paths documented (`/api/login`, `/api/logout`, `/api/me`, `/api/admin/tables`, `/api/admin/tables/{name}/rows` with all four verbs) plus their request/response schemas; endpoint count twelve → seventeen everywhere it is asserted (unit + e2e).
+- **Tests.** Unit: the idempotent admin seed (fresh DB, reopen, and a legacy pre-v0.71.0 file), login success/wrong-password/unknown-username/malformed bodies with an in-test scrypt hash for a self-created user (the real admin's plaintext is never referenced), logout idempotency, /api/me with missing/unknown/expired/live sessions, the guard ladder (401 no header, 401 expired, 403 non-admin) and the full CRUD validation matrix (rows incl. `__rowid` for account, PUT-verified-by-refetch, POST+DELETE round-trip, unknown table 404, unknown column/bad limit/missing rowid 400). E2E (`e2e/admin.spec.ts`, CI-only): open modal → login form → wrong creds error → hook-minted session via localStorage → table list incl. packages/users → edit a cell + Save verified by an independent re-fetch → add + delete a users row → logout back to the login form.
+
+## v0.70.0 — 2026-09-23 22:07
+- **Default map view is now the whole world.** The initial camera in `components/Map.tsx` moves from the Europe overview `[10,52]` z4 to null island `[0,0]` (renamed constant `WORLD_CENTER`) at zoom 2 — at z2 the world is 2048 px wide and the Africa+Europe bounding box (lat −35..+71, lon −18..+52) spans ~800 px vertically in Web Mercator, so both continents are fully visible on a typical desktop map pane. `MIN_ZOOM` is lowered 3 → 0: when fully zoomed out the whole earth (512 px world) fits any viewport; `MAX_ZOOM = 11` and the flat-2D view are unchanged.
+- **E2E.** The new default view shows both Africa + Europe with overlapping markers — LFRS's nearest neighbour (LFRB Brest, 254 km) is only ~13–19 px away at z2, so every marker-click spec now frames its target first: `e2e/map.spec.ts` gains a shared `frameLfrs` helper (`jumpTo` z5 + wait until the marker renders), used by all three of its click tests; `e2e/map-interactions.spec.ts` and `e2e/relocation.spec.ts` frame LFRS at z5 before their popup clicks. The plane-marker test in `e2e/map-interactions.spec.ts` fits EDDF+LEMD into the viewport first — `queryRenderedFeatures` is viewport-scoped and EDDF (50°N) sits right at the edge of the new default view. `e2e/hover.spec.ts`: the antimeridian test's `setMinZoom(0)` workaround is deleted — minZoom is natively 0 now, so `fitToAirports` can reach the z≈1 that EDDF→NFTF needs without lifting any floor. New assertion in `e2e/map.spec.ts` pins the initial camera to [0,0] z2; the wheel-clamp spec's MIN_ZOOM mirror is updated 3 → 0 (its zoom-out side now clamps at 0).
+
+## v0.69.0 — 2026-09-23 21:54
+- **Job ignore removed end-to-end.** The "Ignore" button on open jobs (v0.29.0, ISS-047 part B) is gone with everything behind it: the `POST /api/packages/{id}/ignore` route, the `ignorePackage` action, and `'ignored'` from the package status enum (schema, snapshot type, OpenAPI — now twelve endpoints). Packages can only be loaded, delivered, expired, or abandoned.
+- **Legacy 'ignored' rows self-heal.** Production databases already contain rows with `status='ignored'`; nothing ever cleaned them up (`expireOpenPackages` only selected `'open'`). The sweep now selects `IN ('open','ignored')` and flips any row past `createdRealMs + JOB_LIFETIME_MS` to `'expired'`, so every legacy row heals on the first tick after its lifetime lapses (in practice: the first tick after deploy) and no new ones can ever be created. Reads before that first tick are safe: Drizzle does no runtime validation, nothing renders a non-open/loaded/expired package, and `GET /api/state` ticks first anyway.
+- **Tests.** Unit: the `ignorePackage` suite is deleted; terminal-status fixtures drop their redundant `'ignored'` rows (delivered/abandoned already cover "terminal never flips"); the frozen-top-up drain now flips to `'expired'` mirroring `expireOpenPackages`; the taken-slot cooldown ladder keeps two stamped slots, both `'loaded'`. E2E: the Ignore UI test is deleted; `sim.spec.ts`'s soft-lock regression drains via the existing `/api/test/expire-package` hook (loading can't drain a pool — the starter's payload fits only the lightest band) and `expiry.spec.ts` cleans up its created packages through the same hook. OpenAPI endpoint count thirteen → twelve everywhere it is asserted.
+
+## v0.68.0 — 2026-09-23 20:32
+- **Special remote airports re-curated per #144.** The old remote pass kept EVERY non-large fixed-wing row with no large airport within 1000 km, so regions without big cities (central Australia, Canada edges) got filled with dozens of tiny strips. `scripts/build-world-airports.mjs` now greedily thins the same candidate pool to one special per ~1000 km region: candidates are sorted by priority (scheduled service first, then type rank medium < small < seaplane, then numeric id) and a candidate is accepted only if it is at least `REMOTE_RADIUS_KM` from EVERY already-accepted special — no special airport within 1000 km of another. This subsumes the old 40 km remote clustering (deleted). Regenerated `data/airports_world.csv`: 1483 → 1161 rows (1119 large unchanged, specials 364 → 42; min pairwise special distance 1001.6 km).
+- **Tests.** New committed-dataset invariant in `lib/airports.test.ts` (same style as the existing remote-rule test): every pair of non-large rows is at least `REMOTE_RADIUS_KM` apart (pairwise haversine, O(n²) — n≈42). The existing "no large airport within 1000 km" invariant stays and still holds. No runtime code changes in `lib/airports.ts`.
+
+## v0.67.0 — 2026-09-23 18:03
+- **Prune runner dind leftovers after e2e.** The CI runner's full-dind daemon is shared with production and other workflows, so between runs it accumulates what the existing cleanup steps can't reach: dangling images/layers from the per-run `flight-ops-ci` rebuilds, BuildKit cache (persists by design), and job containers leaked by interrupted runs. A new non-fatal "Prune runner dind leftovers" step (`if: always()`, placed after the existing "Cleanup e2e stack + network") runs `docker system prune -af || echo "::warning::dind prune failed — see logs"` so a prune failure can never mask or break the run's real result. Deliberately NO `--volumes`: named volumes on the shared daemon may hold other workflows' persistent data — this project's own `flight-ci_flight-db` volume is already dropped by the existing cleanup steps. No app/TS changes; CI validates the workflow itself.
+
+## v0.66.0 — 2026-09-23 17:06
+- **E2E results in the Gitea job summary (#141).** The run page's "Job summaries" panel showed vitest results (vitest's built-in `github-actions` reporter auto-appends `$GITHUB_STEP_SUMMARY` when `GITHUB_ACTIONS=true`) but nothing about the Playwright suite, so a failed e2e run required digging into raw logs to see which specs broke. The CI E2E step now also runs Playwright's built-in `json` reporter (`--reporter=list,json`, output pinned to git-ignored `test-results/e2e.json` via `PLAYWRIGHT_JSON_OUTPUT_FILE` — no new dependencies, no config/TS changes), and a new non-fatal "E2E job summary" step (`if: always()`) parses that report with an inline node script and appends spec-level passed/failed/skipped counts plus the file + title of every failed spec to `$GITHUB_STEP_SUMMARY` — mirroring exactly how vitest gets there. The append is guarded (`|| true`, missing/malformed report = silent no-op) so it can never fail or mask the e2e step's real exit code; test behavior, timeouts, workers and retries are untouched.
+
+## v0.65.0 — 2026-09-23 12:58
+- **Per-airport job pools with real-time refresh.** The market was a global bag of jobs (top-up to `MARKET_TARGET_OPEN_PACKAGES = 10` + coverage spawn at uncovered grounded airports), so the board showed work you could never take and hid nothing. Now open jobs are generated PER AIRPORT where a plane can actually pick them up — the pool is the set of grounded planes' `locationIcao`, flying planes' `destIcao` and queued-leg ICAOs — queued legs count even while their plane is in the shop (the work will be waiting at its next stop); a fleet fully repairing with empty queues has no pool, and orphaned pools simply expire out. Each pool airport holds exactly `POOL_TARGET_PER_AIRPORT = 10` open jobs in a fixed weight composition (`POOL_BANDS`: 2×[500,4000) + 6×[4000,18000) + 1×[18000,48000] + 1×(48000,80000] kg), so the board always mixes jobs you can take now with heavier ones that are what you buy better planes for. `spawnPoolPackages` in `lib/sim/engine.ts` replaces both old spawners and runs on every tick (including frozen ones) like v0.64.0's top-up; seeded and spawned packages come from the same new `generatePoolPackage` helper in `lib/game/seed.ts`, so they are indistinguishable — `buildSeed` now seeds a full pool at the starter's home hub, and `PACKAGE_COUNT_MIN/MAX` + `MARKET_TARGET_OPEN_PACKAGES` are retired.
+- **Open jobs live on the wall clock.** New `created_real_ms INTEGER NOT NULL DEFAULT 0` column (guarded ALTER backfilled with `Date.now()` for existing rows): an open job expires `JOB_LIFETIME_MS = 1 h` after creation regardless of time scale or fleet state — checked every tick OUTSIDE the advance gate, so a paused world still refreshes its board. Loaded jobs keep their sim-clock deadline logic unchanged (delivery check, expiry floor, abandon penalty all untouched). Taken slots (loaded OR ignored) stamp `slot_free_at_real_ms` and hold their pool slot for a refill cooldown — `REFILL_DELAY_MS = 15 min`, or `SMALL_REFILL_DELAY_MS = 1 min` for the <4 t band — so the board visibly refreshes instead of instantly refilling; expired/delivered/abandoned never block. ponytail: one shared per-airport cooldown (the max stamp) rather than a per-band table, add when per-band refill timing matters.
+- **Visibility + UI.** `/api/state` and SSE now filter open packages to pool origins (`poolAirports` in `lib/game/state.ts`; all non-open statuses pass through unchanged), so the right pane only ever shows jobs you can take — no disabled Load buttons for foreign-origin work. `PackageState` gains `expiresRealMs` (open → `createdRealMs + JOB_LIFETIME_MS`, else null; OpenAPI updated) and the open-job row renders a wall-clock countdown via the existing pure `formatDeadlineRelative` formatter (no new timer — the ~1 s poll re-renders anyway); loaded jobs keep their sim-deadline display.
+- **Test hooks.** `/api/test/expire-package` rewritten for the wall clock: `{packageId}` ages an OPEN job's `createdRealMs` past its lifetime (`HOOK_AGE_MS = JOB_LIFETIME_MS + 60_000`) and runs a tick, so it comes back already expired (200; unknown/non-open ids 404); no body creates one already-aged hub job (201). CI env: `docker-compose.ci.yml` sets `FLIGHT_JOB_REFILL_MS=5000` + `FLIGHT_JOB_SMALL_REFILL_MS=2000` under the existing `FLIGHT_TEST_HOOKS=1` gate — the lifetime stays 1 h everywhere on purpose, so `state.spec.ts`'s mid-suite container restart can't race a whole board expiring.
+- **Tests.** Unit: `lib/sim/engine.test.ts` rewritten around the new functions — `expireLoadedPackages (sim clock)` and `expireOpenPackages (v0.65.0 wall clock)` suites (both with inclusive-boundary edges), the frozen-top-up test now asserts exactly 10 open jobs all at EDDF, and a six-test `spawnPoolPackages` suite pins band composition, determinism under an injected RNG + wall clock, pool membership for flying/queued airports (departure airport excluded while its plane is airborne), the taken-slot cooldown ladder, and the full tickOnce pipeline. `lib/game/seed.test.ts`: buildSeed now asserts the exact hub-pool composition (10 jobs, band counts, weights in-band, `createdRealMs` = seed moment) plus a "board always offers jobs beyond the starter" pin; the replay test mirrors `generatePoolPackage`; five full-object equality tests pin `createdRealMs` to avoid millisecond-boundary flakes. E2E: `e2e/sim.spec.ts`'s expiry tests are wall-clock now (hook ages + ticks, then polls the pool back to target — no scale or clock activation); `e2e/right-pane.spec.ts` replaces the LEMD Load-disabled test with an absence assertion (a non-pool-origin open job never reaches `/api/state`); `e2e/hover.spec.ts`'s antimeridian pair moves NZAA→NFTF to EDDF→NFTF (same ±180 eastward crossing, sampled maxJump 359.98) because the hook must create jobs at a pool airport; `e2e/expiry.spec.ts` pins the new hook contract (aged job expired by response time, unknown id 404, already-expired 404).
+
+## 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'`.
+
+## v0.62.0 — 2026-09-23 07:36
+- **Fixed 24x world clock (#135).** Finalized the closed issue #117 spec: the world clock runs at the fixed `WORLD_TIME_SCALE = 24` while any plane is flying or in repair, and stays FROZEN when the whole fleet is grounded — replacing v0.56.0's idle slowdown (`IDLE_WORLD_TIME_SCALE = WORLD_TIME_SCALE / 24`, ISS-128). **Production rate is now exactly 24x regardless of legacy stored values:** `tickOnce` in `lib/sim/engine.ts` computes `advanceMs = advance ? min(elapsed, MAX_TICK_ELAPSED_MS) × scale : 0` where `scale = FLIGHT_TEST_HOOKS === '1' ? sim.timeScale : WORLD_TIME_SCALE` — pre-v0.52.0 saves hold `timeScale: 1000` (the old UI ladder), which is why the live instance still ran at ×1000; only deployments with the env var set honor the stored override written by `POST /api/test/set-timescale` (range [1, 100_000], kept for tests). A frozen tick skips expiry/delivery/repair/spawn entirely and only updates `lastRealTickMs`, so resuming activity never fast-forwards the frozen span. The client mirror (`advanceSimClock` in `lib/useSimClock.ts`) holds its anchor value while grounded, so polls re-anchor without any jump. Removed: `IDLE_WORLD_TIME_SCALE` from `lib/worldClock.ts`, and — **separate finding** — `FLIGHT_TEST_HOOKS: "1"` from the production `docker-compose.yml`: it enabled the `/api/test/*` hooks in prod AND (pre-gate) made the live instance honor its stale stored 1000; e2e runs only in CI against `docker-compose.ci.yml`, which sets the var itself. Unchanged on purpose: the ~1 s background tick (started at boot), the test hook endpoint, and the inert legacy columns `paused`/`lastSelectedTimeScale` (nothing reads them; no migration — per #117 saves reset when multiplayer ships). The OpenAPI description of `/api/state` ("while no plane is flying or in repair the clock stays frozen") now matches the code.
+- **Tests.** Unit: `lib/sim/engine.test.ts` — both rate branches pinned: with `FLIGHT_TEST_HOOKS=1` stubbed (the file's default, like CI) stored overrides are honored; a new production test unsets the var and proves a legacy stored `timeScale: 1000` still advances at exactly ×24. Grounded-fleet tests pin a FROZEN clock (no idle creep, resume-without-catch-up after takeoff, raised timeScale ignored while grounded); describe renamed to "grounded fleet freezes the world clock (#135)" and pins `WORLD_TIME_SCALE = 24`. `lib/useSimClock.test.ts` — the grounded case asserts staying exactly at the anchor value. E2E: `e2e/sim.spec.ts`'s idle test becomes an exact freeze (delta === 0 after ~2.5 s of idleness); `e2e/state.spec.ts`'s restart test tightens from bounded delta to EXACT clock equality across `docker compose restart`; `e2e/right-pane.spec.ts` verifies the frozen clock, then asserts the abandon-penalty preview matches the server exactly (zero drift under a frozen clock — replaces the DRIFT_MS slope tolerance); `e2e/events.spec.ts` relaxes strict clock advance between SSE frames to non-decreasing (a grounded fleet pushes identical-clockMs frames; advance itself is pinned in sim.spec.ts). The activateWorld/deactivateWorld wrappers are unchanged — a repairing plane still means full scale.
+
+## v0.61.0 — 2026-09-23 07:12
+- **Special remote airports (ISS-097).** The world dataset was curated to `large_airport` only, so genuinely empty regions — Antarctica, the high Arctic, Alaska, northern Canada and far islands — had no markers at all. New pure function `isRemote(airports, icao)` in `lib/airports.ts` (reusing the existing `haversineKm` from `lib/geo.ts`): an airport is remote when no other member of the given list lies within `REMOTE_RADIUS_KM = 1000`. The curation in `scripts/build-world-airports.mjs` now runs over ALL fixed-wing rows: every large_airport (unchanged clustering) plus every non-large row that is remote against the kept set; same-station twins (two strips <40 km apart at one base) collapse via the same greedy 40 km clustering. `data/airports_world.csv` grows from 1119 → **1483 rows** (+364 remote airports), including Rothera (EGAR), Halley (EGAH) and Showa skiway (AT25) in Antarctica; Grise Fiord (CYGZ), Alert (CYLT), Ny-Ålesund (ENAS — Svalbard's only marker within 1000 km of a large airport) and Wrangel Island (UHMZ) in the Arctic; Bethel (PABR) and other Alaska strips; Canadian-Arctic smalls; and far islands such as Easter (SCIP), Canton (PCIS), Henderson/Pago Pago (PMDY) and Ascension (FHAW). The only change to a pre-existing row is an upstream `home_link` refresh on CYLW. New airports become contract origins/destinations and map markers unchanged — the most isolated airport in the new set (Easter Island) has its nearest neighbour 2599 km away, well under the 9000 km job cap, so every origin stays flyable; `filterWorldAirports` already accepts small/medium/seaplane types, so no runtime change was needed.
+- **Tests.** Unit +4 in `lib/airports.test.ts`: a synthetic radius boundary (equator pair at ~945 km vs ~1052 km), real coordinates (Frankfurt↔Amsterdam is not remote; McMurdo vs Christchurch is), an unknown ICAO returning false, and the committed-dataset curation invariant — every non-large row has no large airport within 1000 km and at least one non-large row exists.
+
+## v0.59.0 — 2026-09-23 05:48
+- **SSE frames no longer carry package history (ISS-133).** Measured on the live instance first: each `/api/events` frame was compact JSON at ~597 KB, pushed once per real second regardless of time scale (the background tick is a fixed 1 s interval; ×1000 just advances the clock further per frame) — and 99.8 % of it was `packages`: 1,521 rows because terminal packages are never deleted from the DB (expired 564, delivered 528, ignored 386, abandoned 31), while only 12 were `open`. No component ever reads a package with a terminal status — the market list renders `open`, and on-board cargo is `loaded`/`expired` (`LeftPane`, `cargoWeightFor`) — so the history was pure re-sent weight. New `sseFrame(snapshot)` in `lib/game/state.ts` projects a snapshot down to the client-rendered statuses (`SSE_PACKAGE_STATUSES = open|loaded|expired`); both SSE paths use it — the broadcast in `lib/sim/engine.ts` and the initial frame in `app/api/events/route.ts`, so a connect never costs one full-history frame. Live payload drops ~597 KB → ~10 KB per frame (≈ 60×), bounded forever by fleet/market size instead of growing with play time. `/api/state` and action responses keep the FULL package set unchanged, so every e2e oracle that asserts `delivered`/`abandoned` transitions via state lookups still works; the polling fallback stays a strict superset of what SSE pushes. Deliberately NOT done: hash-skip broadcasts (the snapshot's `clockMs` advances on every tick even while idle — `advanceMs = min(elapsed, 2000 ms) × scale ≥ 1 s` — so no two frames are ever equal), throttling (already exactly 1 Hz), and a diff/patch engine.
+- **Tests.** Unit +3 in new `lib/game/state.test.ts`: the projection keeps exactly open/loaded/expired (order preserved, terminal rows dropped), passes account/simState/planes through untouched without mutating its input, and pins the status set itself. E2E: `e2e/events.spec.ts` now records every package status seen in any frame plus the largest frame — asserts no terminal status ever appears and frames stay under 200 KB (a full-history regression at ~597 KB fails loudly).
+
+## v0.58.0 — 2026-09-22 21:27
+- **Plane markers no longer teleport across the antimeridian (ISS-124).** The follow-up to ISS-120's known limitation: a plane mid-crossing still used the snapshot's wrapped lat/lon (`positionAt` wraps every longitude into [−180, 180]), so its marker jumped +179.x → −179.x between polls — a visible 360° teleport on the map while its route line stayed continuous. `planesGeoJson` in `lib/mapData.ts` now takes the airport index (`airportsByIcao`, same parameter shape as `routesGeoJson`) and re-expresses each FLYING plane's longitude against its departure airport — the same anchor `greatCircleArc` keeps for its first sample — via a new module-private `unwrapLon(lon, prev)` (the ±360 shift until |Δlon| ≤ 180 that `unwrapLons`'s loop body already used; `unwrapLons` now calls it). The unwrap applies only when BOTH leg endpoints exist in the index, mirroring `routesGeoJson`'s guard exactly: a marker is unwrapped if and only if its line is drawn. Grounded planes, repairing planes and flying planes with a missing endpoint keep their raw wrapped position (unchanged behavior); non-crossing legs are byte-identical (no |Δlon| > 180 → the shift never fires). `components/Map.tsx` passes `airportsIndexRef.current ?? new Map()` at both call sites (`applyDynamic` and the source bootstrap in `ensureLayers`) — planes draw immediately at their wrapped position until the airport index loads, then unwrap.
+- **Tests.** Unit +6 in `lib/mapData.test.ts` (new "antimeridian marker unwrap" block on the real NZAA/NFTF pair): eastward crossing unwraps a mid-leg −179.5 to +180.5 against the origin's +174.8, westward (reversed pair) unwraps below −180, and — the key invariant — every sample of `greatCircleArc(NZAA→NFTF)` fed back as a WRAPPED snapshot position comes out exactly on that arc's own sample, so marker and line agree frame to frame; grounded planes keep their raw coordinate, a flying plane with a missing endpoint stays wrapped (no line drawn either), and non-crossing legs are untouched. E2E +1 in `e2e/map-interactions.spec.ts`: the starter is relocated to Auckland via a fewest-legs chain over `/api/airports` (each hop ≤ 3400 km — within the ATR72's guaranteed range even in worst-case headwind; the tank is topped for free with the `set-fuel` hook before every dispatch so auto-refuel costs nothing), then a hook-created NZAA → NFTF package is loaded and flown at scale 1000 while the marker's longitude is sampled from the planes source every ~500 ms (real time) until the server reports landing — no two consecutive samples may differ by ≥ 180° (the teleport), some sample must sit on the east world copy (lon > 180, proving the crossing was actually traversed unwrapped rather than skipped), and the sampled span must exceed 4°. The plane chains back home afterwards so the other specs start from the canonical state.
+- **E2E fix (CI run 176).** The new antimeridian test failed deterministically in CI — not a marker bug, but a query trap: MapLibre's `querySourceFeatures` only returns features in LOADED tiles, and GeoJSON sources load per viewport tile; the default camera sits over Europe while NZAA/NFTF are in the Pacific, so the plane feature never appeared in queries and the "flying" poll timed out (the same pattern passes for EDDF→LEMD because that leg is inside the default view). The test now fits the camera over both endpoints first via `fitToAirports` (copied from `e2e/hover.spec.ts`, including its ISS-120 unwrap so a ±180-straddling pair bounds the Pacific, not the Atlantic) before polling and sampling. Pollution guard: relocation + crossing now run in a `try/finally` whose cleanup ALWAYS runs — it waits for any in-flight leg to land (scale 1000), then chains the plane back to EDDF from wherever it is, so a failed poll can no longer leave the starter FLYING and 409-cascade into the eleven later specs' fly-home helpers (the run-176 cascade). The dispatch POST's status is now checked explicitly with a clear message instead of a bare `expect(...).toBe(200)`. Unit +1 in `lib/mapData.test.ts` pins the exact feature properties the e2e `starterMarker` matches on (`properties.id === 'plane-starter'`, `properties.flying === true`).
+- **E2E fix (CI run 177).** The antimeridian test still failed — again not a marker bug: by dispatch time the test's page had been alive ~3 min through the relocation chain, and under dind load the browser's state feed can go stale (the SSE fallback in `lib/useGameState.ts` only re-arms polling on stream error or a one-shot 5 s silence check at connect), leaving the planes source frozen on an old FLYING frame from a relocation hop — which fooled the "wait for flying" poll and made every sampled longitude a stale pre-crossing value (continuous, all ≤ 180, never > 180). The test now reloads the page after relocation (server state persists; on the fresh page only the crossing leg can ever produce a flying frame), and the sampling loop gains a freshness gate: a sample is recorded only if its marker position is within ~700 km of where the SERVER snapshot says the plane is (~5 s of flight at ×1000 — haversine is ±360°-periodic in Δlon, so wrapped server lon vs unwrapped marker lon compare directly), so a frozen frame can no longer pass continuity vacuously; `starterMarker` now also returns latitude for that check. Pre-existing flake fixed in the same run: `e2e/queue.spec.ts`'s chain-refuel lower bound loosened from `1.4 × required2` to `1.3 × required2` — under dind load the post-departure snapshot can land ~0.1 × required2 into leg 2's burn (observed miss: 0.07 %); a wrong top-up level still lands far below the bound, and the exact level remains pinned by the upper bound plus the rep-discounted cash assertion.
+- **Root cause of the stale-feed freeze fixed in `lib/useGameState.ts` (CI run 178).** The reload + freshness gate above were insurance; run 178 proved the feed can freeze even on a FRESH page — and the reason is now fixed at the source, not worked around. The SSE silence check was one-shot: `setTimeout(startPolling, 5 s)` armed once at connect, cleared by the FIRST event and never re-armed. After that, only a stream ERROR could restart polling — but a half-open connection that simply stops delivering data (observed under dind load; `/api/state` on separate connections kept answering fine throughout) fires no `onerror`, so state froze until reload. The timer is now re-armed on EVERY message: any 5 s gap in the event flow — whenever it happens, not just before the first event — starts the polling fallback (immediate catch-up fetch + interval), which stops again when fresh events resume. Healthy streams pay one set/clearTimeout per event; stalled ones degrade to the pre-v0.57.0 poll loop instead of freezing. The e2e keeps both insurance layers: the reload still guarantees a clean SSE connect at dispatch, and the freshness gate still fails loudly if any future stall outlasts it (a frozen source can no longer pass continuity vacuously).
+- **Tests.** Unit +1 in `lib/mapData.test.ts` ("NZAA→NFTF crossing leg — full pipeline on stored dataset coords"): runs the exact production pipeline on the STORED CSV coordinates (`loadAirportsGeoJson` → `positionAt` slerp sampled at 51 steps → `planesGeoJson`) and pins what a live browser source must show — marker lons monotonically increasing from +174.8 to +184.9 (the unwrapped NFTF), every consecutive pair < 180° apart, max > 180 (eastward crossing onto the world copy). This is the ground truth the e2e's `lon > 180` assertion encodes: the dataset crosses EASTWARD (NZAA +174.786 → NFTF −175.149, Δ ≈ +10°), so a correct pipeline MUST produce lons above +180 — and any e2e failure of that assertion is now provably a stale browser source, not the math.
+
+## v0.57.0 — 2026-09-22 19:19
+- **Push updated state to clients over SSE (ISS-129).** Clients no longer rely on pure polling for live updates: new `GET /api/events` streams full game-state snapshots as Server-Sent Events — the current snapshot immediately on connect, then one after every sim tick (~1 s), so the UI updates push-driven even while idle. New module `lib/sse.ts` is a tiny in-process fan-out registry (`subscribe(fn)` → unsubscribe, `broadcast(text)` with per-subscriber try/catch) — the three process-wide singletons (this subscriber set, the sql.js DB promise (`getGameDb`), and the tick lock (`withLock`)) live on `globalThis`: Next.js can load a module more than once per process (instrumentation.ts and route handlers get separate module instances), so plain module-level state would give each layer its own registry/DB/lock, and background-tick pushes would never reach route-handler subscribers. The broadcast hook lives in `tickNow()` in `lib/sim/engine.ts`: after each locked tick on the singleton path it serializes via the SAME `getStateSnapshot()` that `GET /api/state` returns (no duplicated serialization) and pushes to all subscribers; failures are logged, never fatal. Action mutations reach other clients within one background tick (~1 s); the acting client still gets its immediate post-action snapshot from the POST response as before. The SSE route (`app/api/events/route.ts`) sends `Content-Type: text/event-stream`, `Cache-Control: no-cache`, `Connection: keep-alive` and `X-Accel-Buffering: no` (prod sits behind Traefik), plus a `: ping` heartbeat comment every 15 s so idle proxies don't drop the connection; snapshot-first-then-subscribe ordering guarantees events are strictly ordered by sim clock, and stream cancel unsubscribes + clears the heartbeat; broadcast pushes are wrapped in `data: <json>\n\n` SSE frames at the route (matching the initial snapshot). Client (`lib/useGameState.ts`): one `EventSource('/api/events')` per page — onmessage parses the full snapshot into the shared state (same shape as today); polling stays as an automatic fallback: if no event arrives within 5 s of connect, or on a stream error, the old poll loop starts (immediate catch-up fetch + interval), and it stops again when fresh events flow. EventSource's native reconnect is relied on — no custom reconnect framework. `/api/state` behavior is unchanged (still ticks-then-snapshots; polling remains fully functional).
+- **API.** OpenAPI spec gains `GET /api/events` (200 → `text/event-stream`) in `lib/openapi.ts`, so the machine-readable spec at `/api/openapi` stays accurate.
+- **Tests.** Unit: new `lib/sse.test.ts` — subscribe/broadcast/unsubscribe semantics, a throwing subscriber doesn't break others, idempotent unsubscribe; new `app/api/events/route.test.ts` (throwaway-DB pattern from the state route test) — SSE headers + first chunk parses as a snapshot with `simState.clockMs`. E2E: new `e2e/events.spec.ts` (+1) — node-side fetch of `/api/events` against the app under test asserts content-type `text/event-stream`, the first event parses as a valid snapshot (`simState.clockMs`), and within ~5 s at least one MORE event arrives with an advanced clock (background tick pushes while idle since v0.56.0 — no scale hook); stream closed in `finally`. The exact-endpoint-list assertions in `lib/openapi.test.ts` and `e2e/api.spec.ts` move twelve → thirteen endpoints (`/api/events` added).
+
+## v0.56.0 — 2026-09-22 18:28
+- **Idle fleet slows the world to real time instead of freezing it (ISS-128).** A fully grounded fleet no longer freezes the sim clock — `tickOnce` in `lib/sim/engine.ts` now advances by `min(elapsed, MAX_TICK_ELAPSED_MS) × IDLE_WORLD_TIME_SCALE` when nothing is flying or in repair, where new constant `IDLE_WORLD_TIME_SCALE = WORLD_TIME_SCALE / 24` (= exactly 1, i.e. real time) lives next to `WORLD_TIME_SCALE` in `lib/worldClock.ts`. Packages keep spawning/expiring and the market stays fresh while idle; an active fleet keeps its full scale including any FLIGHT_TEST_HOOKS override (grounded + hook scale 1000 → advances at ×1, not ×1000), and `lastRealTickMs` still always tracks real time so resuming activity never fast-forwards the idle duration. The client mirror (`advanceSimClock` in `lib/useSimClock.ts`) extrapolates at the same idle rate instead of freezing, so polls re-anchor without a visible jump.
+- **Tests.** Unit: `lib/sim/engine.test.ts` — the grounded-fleet tests now pin real-time advance clamped to one idle-rate tick (no freeze, no fast-forward), resume-without-catch-up after takeoff, and that a raised timeScale is ignored while grounded; new describe "idle slowdown" pins `IDLE_WORLD_TIME_SCALE = WORLD_TIME_SCALE / 24 = 1`. `lib/useSimClock.test.ts` — the frozen-while-idle test now asserts real-time advance at the idle rate. E2E: `e2e/sim.spec.ts`'s freeze test becomes a bounded real-time delta (advances > 0, ≥ half the wall span clamped to one tick, ≤ wall span + one clamp, clearly below ×24); `e2e/state.spec.ts`'s restart test replaces byte-identical clock equality with derived bounds — never backwards (not re-seeded) and ≤ `MAX_TICK_ELAPSED_MS` of clamped downtime + the live wall span; `e2e/right-pane.spec.ts`'s penalty preview no longer races a frozen clock — it verifies the idle rate, then allows the formula's slope over one UI poll interval (~1 s at ×1) instead of an exact string match. The `activateWorld`/repair wrappers in actions/panes/sim specs are unchanged (a repairing plane still means full scale); only their "freezes" comments were updated.
+
+## v0.55.0 — 2026-09-22 15:38
+- **Favicon (ISS-122).** The app shipped with no favicon at all (`app/layout.tsx` set only title/description; no `app/icon.svg`, no `public/favicon.ico`). New hand-written single-file `app/icon.svg` — a bold white top-down airplane silhouette (fuselage + swept wings + tail, one straight-line path) on a pastel blue (#93c5fd) rounded square, 64×64 viewBox. Next App Router's file convention auto-serves it at `/icon.svg` and injects `<link rel="icon">` into the head; no layout/metadata changes needed.
+- **Tests.** E2E +1 in `e2e/panes.spec.ts`: page load asserts exactly one `head link[rel~="icon"]` pointing at `/icon.svg`, and a direct `GET /icon.svg` returns 200 with content-type `image/svg+xml`. No unit test — static asset.
+- **E2E hardening (CI run #167).** Two e2e-only fixes: the favicon assertion now tolerates the content-hash query string Next App Router production builds append to the auto-injected icon `<link href>` (`/icon.svg?icon.<hash>.svg` — matched with `/^\/icon\.svg/`, canonical `GET /icon.svg` check unchanged), and `e2e/hover.spec.ts`'s local `flyHomeViaApi` self-heal is replaced by the established `e2e/panes.spec.ts` pattern (set-health repair-gate reset + re-read state AFTER an in-flight leg lands) — the old version checked `locationIcao` against the stale pre-landing snapshot, so a retry after a mid-flight interruption left plane-starter grounded at the destination and its package load 409'd ("plane not at the origin").
+- **E2E hardening (CI run #168).** Retry-cascade fix in `e2e/actions.spec.ts`: its local `flyHomeViaApi` self-heal now also tops plane-starter's tank back to full via the free `POST /api/test/set-fuel` hook after repositioning home. A transient `/api/state` 500 (issue #127) killed attempt 1 mid-flight; the retry's self-heal then flew the starter home with a low tank, so the test's own dispatch auto-refueled AFTER its cash baseline was captured and the exact-cash "no reward for expired cargo" assertion failed by €1190.56 — a full tank makes every subsequent dispatch top-up cost exactly €0.
+- **E2E hardening (ISS-127).** e2e `getState` hardened against transient `/api/state` 500s — internal retry ×3/500 ms keeps poll callbacks total.
+
+## v0.54.0 — 2026-09-22 15:20
+- **Long priority jobs are now always finishable (ISS-119).** `generatePackage` in `lib/game/seed.ts` drew a flat 6–72 h expiry window (priority ×0.5 → 3–36 h) independent of leg distance, so some jobs' deadlines were shorter than the flight itself and could never be completed (legs go up to MAX_JOB_LEG_KM = 9000 km; the fastest catalog plane is ~920 km/h ≈ 10 h for a max leg). The drawn window is now clamped UP after special scaling: deadline ≥ now + `travelDurationMs(legKm, FASTEST_CATALOG_SPEED_KMH)` + `EXPIRY_BUFFER_MS` (flat 1 h), reusing the existing `travelDurationMs` from `lib/sim/movement.ts`. New constant `FASTEST_CATALOG_SPEED_KMH` in `lib/game/catalog.ts` — data-driven max of `PLANE_TYPES` speeds, so a job must be finishable with the best available aircraft (NOT the starter's 510 km/h, which would wreck long-job economics); adding a faster plane tightens the floor automatically. `EXPIRY_BUFFER_MS` lives next to the deadline tunables in seed.ts. The window is a single uniform draw, so clamping up covers both requirements: short legs (drawn × scale already above the floor) are byte-identical to before, and when the raw draw falls below the floor the deadline lands exactly on it — which stays ≤ the scaled ceiling for any pair of airports on Earth (max leg ~20000 km → floor ≈ 22.8 h < the 36 h priority ceiling), so no separate ceiling raise is needed. Forced `deadlineOffsetMs` skips the floor, same as it skips special scaling (the e2e expiry hook keeps working).
+- **Tests.** Unit +5 in `lib/game/seed.test.ts` (new "expiry floor" block): pins the constants (fastest = max of catalog speeds and > starter speed; buffer exactly 1 h); a seeded sweep over 200 unforced packages on the real dataset asserting deadline ≥ now + travel time at max speed + buffer for every one (specials roll naturally, ~15% priority); the farthest within-cap pair in the real dataset (~9000 km) forced with both `priority` and null across 50 seeds each — invariant holds everywhere AND at least one package per special lands exactly on the floor (deterministic for fixed seeds, proving the clamp engages rather than holding vacuously); short legs (EDDF→EHAM ≈ 370 km → floor ≈ 1.4 h < the priority minimum window) pinned byte-identical to a replay of the pre-v0.54.0 draw order (no economy regression); forced deadline offsets still skip the floor. E2E +1 in `e2e/expiry.spec.ts`: the EXISTING `POST /api/test/create-package` hook forces EDDB→KSMF (~9000 km, at MAX_JOB_LEG_KM) with `special: 'priority'`; 10 packages are created and every one asserted to expire ≥ travel time at max speed + buffer after creation (and ≤ the 36 h priority ceiling), then all ignored for cleanup — no new server hooks.
+
+## v0.53.0 — 2026-09-22 14:47
+- **Antimeridian routes no longer chord across the map (ISS-120).** Routes whose great circle crosses ±180° (e.g. Auckland → Fua'amotu, Tonga) rendered as a line spanning the whole map: `greatCircleArc` sampled `positionAt`, which wraps every sample's longitude into [−180, 180], so consecutive samples jumped +179.x → −179.x and MapLibre — which draws LineStrings as-is with no ±180 splitting — connected them across the globe. New module-private `unwrapLons` in `lib/mapData.ts` re-expresses each arc's sample sequence in continuous longitudes (first sample keeps its raw lon; every later one is shifted by ±360 relative to the previous UNWRAPPED value until |Δlon| ≤ 180), applied inside `greatCircleArc` so all four line builders (`routesGeoJson`, `queuedRoutesGeoJson`, `hoverRouteGeoJson`, `hoverTraceGeoJson`) are fixed at once. One line stays one LineString — no splitting; out-of-range values render on MapLibre's adjacent world copies (`renderWorldCopies` is default-on). `queuedRoutesGeoJson` gets a second global pass after concatenation: each leg's arc unwraps relative to its OWN start airport, so at a joint the sequence can jump ±360 (leg 1 ends at dest+360k, leg 2 restarts at the raw dest) and the re-unwrap keeps multi-leg chains continuous. Non-crossing routes are byte-identical (no |Δlon| > 180 anywhere → the pass is a no-op).
+- **Tests.** Unit +4 in `lib/mapData.test.ts` (new "antimeridian crossing" block, real dataset pairs NZAA/NFTF/NZCH): eastward and westward crossings stay continuous (every consecutive |Δlon| < 180), endpoints exact mod 360 with the first sample still the raw origin, sampled chord length ≈ haversine within 1%, a non-crossing route's lons stay in [−180, 180], and a grounded plane's two-leg queue chain crossing ±180 stays continuous across the joint (the regression `queuedRoutesGeoJson`'s global pass guards). E2E +1 in `e2e/hover.spec.ts`: hovering an antimeridian-crossing package (hook-created NZAA → NFTF) draws one continuous trace — no rendered segment may contain a ±180 longitude jump; `expectHoverRoute`'s endpoint check now compares longitudes on the circle (mod 360, identical for any pair within ±180 so existing routes are unaffected) and `fitToAirports` unwraps crossing pairs so their bounds follow the short arc across the date line instead of spanning the wrong side of the globe.
+- **Known limitation (follow-up).** Plane MARKERS still use the snapshot's wrapped lat/lon (`lib/game/state.ts` → `positionAt`), so a plane mid-crossing teleports 360° on its marker at the instant it passes ±180 while its route line stays continuous. Fixing needs airport coordinates inside `planesGeoJson` (signature change + `Map.tsx` call site) — deliberately out of scope for this fix.
+
+## v0.52.0 — 2026-09-22 10:45
+- **Fixed world clock, no player time controls (ISS-117).** The pause button and the 1×–1000× scale slider are gone from the left pane (`components/LeftPane.tsx`) — the world now always runs at a fixed `WORLD_TIME_SCALE = 24` (new client-safe `lib/worldClock.ts`, re-exported by the engine). The server advances time in a background tick: new `instrumentation.ts` starts `startBackgroundTick()` (1 s interval, singleton-guarded) under `NEXT_RUNTIME === 'nodejs'`, so the sim moves even with no open browser. **Idle-pause:** while no plane is flying or in repair the clock is frozen exactly — pure `shouldAdvanceTime(planes)` in `lib/sim/engine.ts` gates every tick (no catch-up jump on wake; `lastRealTickMs` still updates). Fresh worlds start at year 2000 (`STARTING_CLOCK_MS = Date.UTC(2000, 0, 1)` in `lib/game/seed.ts`; existing saves untouched — no migration). The client clock (`lib/useSimClock.ts`) extrapolates between polls at the fixed rate and freezes while idle, mirroring the server.
+- **API.** `POST /api/sim` deleted (route + OpenAPI entry; spec now lists twelve endpoints) and its controls removed from the engine (`applyTimeControls`, `clampTimeScale`, MIN/MAX_TIME_SCALE). The `/api/state` snapshot's `simState` is now `{ clockMs }` only — no `timeScale`/`paused`. New test-only hook `POST /api/test/set-timescale` behind the existing `FLIGHT_TEST_HOOKS=1` gate (sibling of `/api/test/set-health`, same 404-when-disabled convention): body `{ timeScale: finite number in [1, 100_000] }` else 400; ticks first under the sim lock and returns `{ clockMs, timeScale }`. The e2e suite's per-spec `setScale` helpers now call it (and verify from the response); every spec restores the world rate in `afterEach`.
+- **Tests.** Unit: engine tests re-anchored to `STARTING_CLOCK_MS` with a `makeWorldActive` helper (fresh DBs seed a grounded starter, so advancing-world tests put one in flight first) plus new idle-pause coverage (`shouldAdvanceTime` synthetic arrays; grounded fleet freezes the clock exactly; repairing keeps it advancing); actions/seed/db/openapi tests re-anchored to the year-2000 origin and fixed world rate; `lib/timeScale.ts`, its test, `components/left-pane.test.ts` and the old `/api/sim` route + test deleted. E2E: all specs rewritten off `POST /api/sim` — pause tests replaced by idle-pause assertions (e.g. `right-pane.spec.ts` verifies a double-read 1.5 s apart that a grounded fleet freezes the clock exactly, which also makes its penalty-preview math deterministic); `sim.spec.ts` activates the world via set-health + `/repair` for its advance/expiry tests and pins the new hook's validation; `panes.spec.ts` drops the slider-commit test (controls gone) and samples the smooth client clock at the fixed 24× rate, asserting the pause/slider testids are absent; `state.spec.ts` restart test self-heals to a fully grounded fleet first and now asserts the post-restart clock is byte-identical (frozen across the restart); `two-planes.spec.ts` loses its ISS-057 slow-on-landing assertions — the auto-chain observation leg now flies at world rate so polls can see it; `api.spec.ts` endpoint list drops `/api/sim` (thirteen → twelve).
+
+## v0.51.0 — 2026-09-22 08:21
+- **Max range display is now guaranteed flyable in all weather (ISS-099).** The spec card's "Max range" (`components/RightPane.tsx`) showed `maxRangeKm` — the weighted-model closed form with NO wind — while dispatch's fuel guard (`flyPlane`, and the engine's auto-chain) uses wind-adjusted burn (up to +20% headwind, v0.36.0), so a leg inside the displayed range could 409 "insufficient fuel" when the departure airport had a headwind. New `MAX_WIND_BURN_FACTOR` (= 1.2 — pinned in tests to be exactly `windBurnFactor`'s maximum) and `guaranteedRangeKm(burnPerKm, emptyWeightKg, maxFuel)` = `maxRangeKm` under worst-case headwind burn (`lib/sim/movement.ts`). The UI now shows the guaranteed range: any leg within it is flyable in all weather. ATR 72-600: 4436 → 3696 km; Boeing 777: 13045 → 10871 km — matching the `maxRangeKm ÷ 1.2` convention seed.ts already uses for its job-generation cap
+- **Tests.** Unit +15: new `guaranteedRangeKm` block in `lib/sim/movement.test.ts` (3 tests — MAX_WIND_BURN_FACTOR pinned to `windBurnFactor(30, 90, 90)`, ATR ≈ 3697 km ±5%, zero-fuel/invalid-weight guards) and a per-type consistency loop in `lib/game/catalog.test.ts` (12 tests — for ALL six catalog types: `requiredFuelFor(guaranteed range)` ≤ maxFuel under worst-case headwind, tightness at 1.05× > maxFuel, and the no-wind closed form still an exact inverse). E2E: `e2e/right-pane.spec.ts` market-tab test now imports and asserts `guaranteedRangeKm` directly (local mirror deleted)
+
+## v0.50.0 — 2026-09-22 08:00
+- **Queued/planned route line is now amber/gold instead of gray (ISS-098).** The dotted queue line in `components/Map.tsx` (a flying plane's not-yet-started legs, ISS-043) was drawn in muted slate `#64748b`. It is now an amber/gold `#d4a017`, readable on both light and dark tiles. The color was extracted from the inline literal to a new exported module-scope constant `QUEUE_ROUTE_LINE_COLOR` so it is testable; the dashed/dotted style (`line-dasharray [0.1, 1.5]`) and width (3) are unchanged
+- **Tests.** Unit +1: new `components/map.test.ts` pins `QUEUE_ROUTE_LINE_COLOR === '#d4a017'`. No new e2e spec — the existing queued-route rendering paths (`e2e/queue.spec.ts`, `e2e/relocation.spec.ts`) already exercise this layer, and a pure color swap needs no behavioral coverage
+
+## v0.49.0 — 2026-09-22 07:25
+- **Airport popup Relocate now works for flying/repairing planes (ISS-096).** The Relocate row in the map's airport popup (`components/Map.tsx`) previously listed only grounded planes and showed "No grounded planes to relocate." when none was available. It now lists ALL planes from the latest snapshot, and the click handler picks the endpoint by the SELECTED plane's current status: `available` → `POST /api/planes/{id}/fly` (immediate relocation, unchanged), `flying`/`repairing` → `POST /api/planes/{id}/queue` (the destination is appended to the plane's flight queue and chains on landing). Success text is "Relocation started." for fly and "Added to queue." for queue; the no-planes fallback guard is reworded to "No planes to relocate." No API changes — both endpoints existed since v0.25.0/v0.46.0
+- **Tests.** E2E +1 (`e2e/relocation.spec.ts`): dispatches the starter plane on a leg via the API so it is flying, slows the sim to 1x so the leg cannot land mid-test, opens the airport popup for a different airport, selects the flying plane from the (now full) list and clicks "Relocate here", then asserts via state that the plane's `queue` contains the clicked airport's ICAO while it is still flying its original destination
+
+## v0.48.0 — 2026-09-22 06:55
+- **Leg distance shown on contracts (ISS-095).** `PackageState` gains `distanceKm` (`lib/game/state.ts`) — the great-circle origin→dest distance, computed server-side in `getStateSnapshot()` from the airport GeoJSON already loaded for live-plane math (same `haversineKm` as flight movement; 0 if a coord is missing). Shown in two places via new `formatKm()` (`lib/format.ts`, integer km, no space before "km"): the on-board contract line (`EGCC → GMME 554km €23,826.00 …`) and the job-list row (`€37,408.00 215km Perishables 0.4t …`). OpenAPI spec updated in lockstep; nothing stored
+- **Tests.** Unit: `app/api/state/route.test.ts` asserts every package's `distanceKm` equals the haversine of its airports' coordinates (computed with the same lib/geo helper); `lib/openapi.test.ts` pinned key list gains `distanceKm`; new `formatKm` test in `lib/format.test.ts`. E2E: `right-pane.spec.ts` +2 assertions (job-row distance span matches /^\d+km$/, generic and hook-created package), `actions.spec.ts` +1 (on-board line)
+
+## v0.47.0 — 2026-09-21 23:01
+- **Job payoff retuned so weight dominates (ISS-090).** `REWARD_PER_KG` in `lib/game/seed.ts` rises from €0.5/kg to €2.0/kg — the linear form is unchanged, only the constant moves. Before, the weight term was small vs base+distance, so heavier jobs barely paid more (a 1000 km leg: €3,250 @500 kg → €5,000 @4,000 kg — per-kg rate fell from €4.59 to €1.01) and there was no sense in taking heavy jobs; after the retune the same leg pays €4,000 / €11,000, so weight clearly drives payoff. Safe for viability: fuel burn (`lib/sim/movement.ts`) is weight-independent, so this only raises income
+- **Tests.** `seed.test.ts`: stale test name "… 0.5 * weightKg …" made generic; new literal pins in the `rewardFor` formula test — `rewardFor(1000, 4000) === 11_000` and `rewardFor(1000, 500) === 4_000` — so future retunes are deliberate. All other reward assertions recompute through the exported constants and pass unchanged
+
+## v0.46.0 — 2026-09-21 22:32
+- **Queue consumption on dispatch (ISS-088).** `flyPlane` (`lib/game/actions.ts`) now consumes `queue[0]` when the requested destination IS the first queued leg, so a landing never chains a zero-distance self-hop (the "phantom hop" — a→a completing instantly before reaching the real next leg). Flying to a non-first queued leg stays an explicit override and leaves the queue untouched; the persisted queue is written back in the same update
+- **Engine auto-chain hardening.** `deliverPackages` (`lib/sim/engine.ts`) gains two guards: (1) defensive skip — if `queue[0]` equals the arrival airport (only reachable from legacy/corrupt rows now that dispatch consumes), it drops the leg without flying; (2) full-tank backstop — if the next queued leg does not fit even a full tank, the plane grounds as `'available'` with the queue kept intact instead of chaining an unflyable leg (mirrors `flyPlane`'s 409 without throwing mid-tick)
+- **Selling a queued plane is rejected.** `sellPlane` (`lib/game/actions.ts`) returns 409 `the plane has queued legs — cancel queued legs first` for a grounded plane with a non-empty queue, instead of silently discarding the queued legs
+- **Test hook: `/api/test/set-cash`.** New route under `app/api/test/` (sibling of `set-fuel`/`add-cash`) setting account cash to an ABSOLUTE value `{ amount }` — same `FLIGHT_TEST_HOOKS=1` gate, strict JSON validation, post-tick state snapshot. Deliberately NOT in the OpenAPI spec: test hooks are out-of-spec by convention and `lib/openapi.test.ts` pins exactly 13 public paths
+- **Tests.** Unit +5 (373 total): `flyPlane` consumes queue[0] on dispatch / skip-ahead keeps the queue intact; `sellPlane` 409s a grounded plane with queued legs leaving the row untouched; engine full-tank backstop grounds with the queue intact (FGSL ~4267 km from LEMD — beyond ATR range); engine defensive self-leg drop. E2E: `e2e/queue.spec.ts` +3 — three queued legs fly in FIFO order across landings (dispatch response snapshot proves queue[0] consumed), a mid-flight drained tank is topped up before the chained leg at exactly the rep-discounted cost (expectations computed with the same lib helpers as the engine, via `/api/test/set-fuel` drain + new `set-cash` hook), cancelling the only queued leg mid-flight leaves a plain landing with no auto-chain; `e2e/state.spec.ts` +1 — a staged two-leg queue survives `docker compose restart flight` byte-identical; `e2e/two-planes.spec.ts` reworked — the 240 s poll that absorbed the phantom hop is replaced by explicit assertions: the fly response snapshot shows only `[b]` queued, and every state observed while waiting for the chain must never show location a with dest a
+
+## v0.45.0 — 2026-09-21 21:12
+- **Broken planes cannot fly (ISS-089).** A plane at `health ≤ 0` is now grounded until repaired instead of flying on fumes: `flyPlane` (`lib/game/actions.ts`) rejects it with 409 `the plane is broken (health 0) — repair it first` BEFORE any auto-refuel math, so fuel and cash stay untouched; the engine's auto-chain (`deliverPackages`, `lib/sim/engine.ts`) skips chaining when a landing's wear breaks the plane — it stays grounded at the arrival airport with its queue kept intact for a later dispatch (same shape as an unaffordable top-up)
+- **Repair is gradual.** `repairPlane` no longer jumps health to 100 — it grounds the plane in `'repairing'` with the gate at `clock + REPAIR_DURATION_MS` and leaves health where it was. The engine's `finishRepairs` pass (`lib/sim/engine.ts`) now heals along a linear curve each tick: `health = min(100, max(startHealth, round(f × 100)))` with `f` the fraction of the repair duration elapsed — monotonic (never drops below the start value), and the flip to `'available'` at exactly 100 happens when the gate passes. The left-pane health bar doubles as the repair progress indicator; no UI change
+- **REMOVED the broken-plane ×1.5 burn mechanic.** `BROKEN_BURN_MULTIPLIER` + `conditionBurnMultiplier()` are deleted from `lib/game/catalog.ts` and every burn site reverts to plain wind-adjusted consumption: `flyPlane` dispatch requirement, engine landed fuel + auto-chain next-leg check (`lib/sim/engine.ts`), the live in-flight gauge (`livePlane`, `lib/game/state.ts`). The mechanic was unreachable anyway — broken planes can no longer depart
+- **Docs.** OpenAPI reworded to match: fly's 409 lists the broken case, queue/repair descriptions + the `PlaneState.health` field note the gradual heal and the cannot-fly rule; route comment in `app/api/planes/[planeId]/repair/route.ts` updated. No endpoints added or removed — count pins unchanged
+- **Tests.** Unit: new `flyPlane` broken-guard test (409 + fuel/cash untouched) and a worn-but-not-broken control; the ×1.5 broken-burn tests deleted (`lib/game/catalog.test.ts`, `lib/game/actions.test.ts`, `lib/sim/engine.test.ts`) in favor of an engine chain-stop test (a plane that lands broken stays grounded with its queue intact despite enough fuel) and a `finishRepairs` curve test (mid-repair climb to `round(f × 100)`, floor at the start value, exact 100 + `'available'` at the gate); `repairPlane` unit pins updated — health is NOT restored by the action itself. E2E: `e2e/maintenance.spec.ts` reworked per the issue — force broken → pill shows AND dispatch 409s with the tank untouched (the ×1.5 burn flight leg is gone) → click Repair → "in repair" pill with health still ~0 → shorten the gate via the hook → back to service at exactly 100; `e2e/right-pane.spec.ts` drops the dead condition factor from its auto-refuel math
+
+## v0.44.0 — 2026-09-21 17:10
+- **World airport dataset (ISS-079).** `data/airports_eu.csv` (242 EU rows) is replaced by `data/airports_world.csv` — the full OurAirports world dump curated to one marker per metro area: keep `large_airport` rows only, then greedy 40 km haversine clustering with one airport kept per cluster ("biggest" proxy: scheduled service → IATA code → Wikipedia page → file order; no pax data exists in the CSV). Result: **1174 large airports worldwide → 1119 kept, 55 dropped into 52 multi-airport clusters** (e.g. Newark ← JFK + LaGuardia, Dallas ← DFW, Warsaw Chopin merged with Modlin). New committed generator `scripts/build-world-airports.mjs` re-derives the CSV from the source mirror (aborts on download failure; asserts EDDF/UNNT/LPPD presence, unique ICACOs, sane row count)
+- **Loader.** `lib/airports.ts` reads the world file and drops the continent check (type filter kept as a guard); new load-time guard throws on duplicate ICAO — three consumers key features by ICAO with silent-overwrite semantics, so duplicates would corrupt state silently
+- **Generated jobs are distance-capped.** New `MAX_JOB_LEG_KM = 9000` in `lib/game/seed.ts`: every spawned leg is flyable by at least one catalog plane even in worst-case headwind (b777 full-tank range ~13045 km nominal, ~10871 km with the +20% wind factor — 9000 leaves margin). `generatePackage` rejection-samples unforced origin/dest pairs until they fit (bounded at 25 attempts, then a uniform within-cap fallback); forced endpoints consume no extra draws and stay uncapped (the UNNT→LPPD 409 backstop relies on that), so under-cap RNG streams are byte-identical to before. The engine's coverage spawn caps its random dest through the shared `pickDestWithinCap` helper — one draw in the same stream position as before
+- **UI/spec/docs.** Map header label → "N world airports" (e2e regex updated), OpenAPI `/api/airports` summary/description reworded to the curated world dataset, PLAN.md dataset mentions updated; initial camera stays EU-tuned (out of scope)
+- **E2E marker isolation re-verified.** LFRS (Nantes) keeps ≥39 px clearance from its nearest markers (LFRB Brest / LFBD Bordeaux) at the initial zoom [10,52] z4 with the world dataset — no test changes needed beyond the label regex
 ## v0.43.0 — 2026-09-21 15:57
 - **Wear rate reduced 10× per ISS-085** — `WEAR_PER_KM` in `lib/game/catalog.ts` drops from 0.005 to 0.0005, so plane maintenance status degrades 1/10th as fast (~13 mid-range hops → ~130 hops to break a full-health plane)
 

PLAN.md

@@ -6,7 +6,7 @@ No manual flying — planes auto-fly assigned routes; you manage the business fr
 ## Layout (single screen)
 - Left pane — Assets: fleet list (plane type, status, fuel, location), wallet, reputation
 - Right pane — Jobs & Market: contracts between airports (reward, deadline, cargo/passengers) with accept/dispatch actions; market actions (buy/sell planes, maintenance). No manual refueling — dispatch auto-tops-up the tank to 150% of the leg requirement (capped at capacity) when cash allows
-- Middle — Map: EU airports as markers, animated plane positions along routes, active contract routes highlighted; click airport → info (runways, local time, weather); click plane → status
+- Middle — Map: world airports as markers (one per metro area), animated plane positions along routes, active contract routes highlighted; click airport → info (runways, local time, weather); click plane → status
 
 ## Core loop
 Accept job → dispatch a plane → watch it fly the route on the map → earn money + reputation → buy better planes / take bigger jobs.
@@ -28,10 +28,9 @@ Accept job → dispatch a plane → watch it fly the route on the map → earn m
 - Shown on map / airport info; no gameplay effects yet
 
 ## MVP slice
-Starter plane + EU airports + contracts + buy/sell + map visualization + weather display.
+Starter plane + world airports + contracts + buy/sell + map visualization + weather display.
 
 ## Later
 - Weather effects: delays, fuel burn changes, closed airports
 - More aircraft types, upgrades (fuel efficiency, cargo capacity) — money sinks
-- Multi-region packs (non-EU airports)
 - Multiplayer (shared world, contract races)

app/api/admin/tables/[name]/rows/route.test.ts

@@ -0,0 +1,184 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+import { getGameDb } from '@/lib/db/client';
+import { createSession } from '@/lib/auth';
+import { DELETE, GET, POST, PUT } from './route';
+
+// v0.71.0 — generic DB CRUD route tests: rows fetch (incl. __rowid for PK-less tables),
+// parameterized update/insert/delete, and the validation ladder (404 unknown table, 400 bad input).
+
+let dir: string;
+let adminSession = '';
+
+beforeAll(async () => {
+  dir = await fs.mkdtemp(path.join(os.tmpdir(), 'flight-admin-rows-'));
+  process.env.FLIGHT_DB_PATH = path.join(dir, 'rows.db');
+});
+
+afterAll(async () => {
+  delete process.env.FLIGHT_DB_PATH;
+  await fs.rm(dir, { recursive: true, force: true });
+});
+
+// adminSession is minted in beforeAll, so the header helpers read it at call time.
+const authHeaders = () => ({ 'X-Flight-Session': adminSession });
+
+// The route handlers take Next.js's dynamic-segment context; unit tests supply it directly.
+const ctx = (name: string) => ({ params: Promise.resolve({ name }) });
+
+const getRows = (name: string, query = '') =>
+  GET(new Request(`http://localhost/api/admin/tables/${encodeURIComponent(name)}/rows${query}`, { headers: authHeaders() }), ctx(name));
+const putRow = (name: string, body: unknown) =>
+  PUT(
+    new Request(`http://localhost/api/admin/tables/${encodeURIComponent(name)}/rows`, {
+      method: 'PUT',
+      headers: { ...authHeaders(), 'content-type': 'application/json' },
+      body: JSON.stringify(body),
+    }),
+    ctx(name),
+  );
+const postRow = (name: string, body: unknown) =>
+  POST(
+    new Request(`http://localhost/api/admin/tables/${encodeURIComponent(name)}/rows`, {
+      method: 'POST',
+      headers: { ...authHeaders(), 'content-type': 'application/json' },
+      body: JSON.stringify(body),
+    }),
+    ctx(name),
+  );
+const deleteRow = (name: string, rowid: number | null) =>
+  DELETE(
+    new Request(
+      `http://localhost/api/admin/tables/${encodeURIComponent(name)}/rows${rowid === null ? '' : `?rowid=${rowid}`}`,
+      { method: 'DELETE', headers: authHeaders() },
+    ),
+    ctx(name),
+  );
+
+describe('admin rows CRUD', () => {
+  beforeAll(async () => {
+    adminSession = await createSession(await getGameDb(), 'admin-kamilkrzywda');
+  });
+
+  it('GET returns columns + rows with __rowid for the PK-less account table', async () => {
+    const res = await getRows('account');
+    expect(res.status).toBe(200);
+    const body = (await res.json()) as { columns: string[]; rows: Array<Record<string, unknown>> };
+    expect(body.columns[0]).toBe('__rowid');
+    for (const col of ['cash', 'reputation']) expect(body.columns).toContain(col);
+    expect(body.rows).toHaveLength(1); // the single seeded account row
+    expect(typeof body.rows[0].__rowid).toBe('number');
+    expect(typeof body.rows[0].cash).toBe('number');
+  });
+
+  it('PUT updates a cell and the change survives a re-fetch', async () => {
+    const before = await (await getRows('account')).json();
+    const originalCash = (before as { rows: Array<Record<string, unknown>> }).rows[0].cash;
+
+    const res = await putRow('account', { rowid: 1, values: { cash: 424_242 } });
+    expect(res.status).toBe(200);
+    expect(await res.json()).toEqual({ ok: true });
+
+    // Re-fetch through the same route — the persisted value is back.
+    const body = await (await getRows('account')).json();
+    expect((body as { rows: Array<Record<string, unknown>> }).rows[0].cash).toBe(424_242);
+
+    // Restore the original cash so later tests see a sane world.
+    const restore = await putRow('account', { rowid: 1, values: { cash: originalCash } });
+    expect(restore.status).toBe(200);
+  });
+
+  it('PUT rejects unknown columns and empty values with 400', async () => {
+    const badCol = await putRow('account', { rowid: 1, values: { no_such_column: 1 } });
+    expect(badCol.status).toBe(400);
+    expect(((await badCol.json()) as { error: string }).error).toMatch(/unknown column/i);
+
+    const empty = await putRow('account', { rowid: 1, values: {} });
+    expect(empty.status).toBe(400);
+
+    const noRowid = await putRow('account', { values: { cash: 1 } });
+    expect(noRowid.status).toBe(400);
+  });
+
+  it('POST inserts a row and DELETE removes it again (users table)', async () => {
+    const created = await postRow('users', {
+      values: { id: 'user-crud-test', username: 'crud-test-user', password_hash: 'aa$bb', created_at: Date.now() },
+    });
+    expect(created.status).toBe(200);
+    const body = (await created.json()) as { ok: boolean; rowid: number };
+    expect(body.ok).toBe(true);
+    expect(Number.isInteger(body.rowid)).toBe(true);
+
+    // Visible via GET…
+    let list = await (await getRows('users')).json();
+    const rows = (list as { rows: Array<Record<string, unknown>> }).rows;
+    expect(rows.some((r) => r.username === 'crud-test-user')).toBe(true);
+
+    // …and gone after DELETE.
+    const del = await deleteRow('users', body.rowid);
+    expect(del.status).toBe(200);
+    list = await (await getRows('users')).json();
+    expect((list as { rows: Array<Record<string, unknown>> }).rows.some((r) => r.username === 'crud-test-user')).toBe(false);
+
+    // DELETE is idempotent.
+    const again = await deleteRow('users', body.rowid);
+    expect(again.status).toBe(200);
+  });
+
+  it('POST rejects unknown columns and empty values with 400', async () => {
+    const badCol = await postRow('users', { values: { id: 'x', no_such_column: 1 } });
+    expect(badCol.status).toBe(400);
+    expect(((await badCol.json()) as { error: string }).error).toMatch(/unknown column/i);
+
+    const empty = await postRow('users', { values: {} });
+    expect(empty.status).toBe(400);
+  });
+
+  it('DELETE requires an integer rowid query parameter', async () => {
+    const missing = await deleteRow('users', null);
+    expect(missing.status).toBe(400);
+    const bad = await DELETE(
+      new Request('http://localhost/api/admin/tables/users/rows?rowid=abc', { method: 'DELETE', headers: authHeaders() }),
+      ctx('users'),
+    );
+    expect(bad.status).toBe(400);
+  });
+
+  it('returns 404 for an unknown table on every verb', async () => {
+    const g = await getRows('no_such_table');
+    expect(g.status).toBe(404);
+    const p = await putRow('no_such_table', { rowid: 1, values: { x: 1 } });
+    expect(p.status).toBe(404);
+    const i = await postRow('no_such_table', { values: { x: 1 } });
+    expect(i.status).toBe(404);
+    const d = await deleteRow('no_such_table', 1);
+    expect(d.status).toBe(404);
+  });
+
+  it('rejects a non-integer limit with 400 and caps at 1000', async () => {
+    const bad = await getRows('users', '?limit=abc');
+    expect(bad.status).toBe(400);
+    const capped = await getRows('users', '?limit=999999');
+    expect(capped.status).toBe(200);
+  });
+
+  it('keeps the guard in front of everything: no header → 401, non-admin → 403', async () => {
+    const noHeader = await GET(new Request('http://localhost/api/admin/tables/users/rows'), ctx('users'));
+    expect(noHeader.status).toBe(401);
+
+    const inst = await getGameDb();
+    inst.raw.run(
+      `INSERT INTO users (id, username, password_hash, admin, created_at)
+       SELECT 'user-rows-nonadmin', 'rows-nonadmin', 'aa$bb', 0, ? WHERE NOT EXISTS (SELECT 1 FROM users WHERE id = 'user-rows-nonadmin')`,
+      [Date.now()],
+    );
+    const nonAdminSession = await createSession(inst, 'user-rows-nonadmin');
+    const forbidden = await GET(
+      new Request('http://localhost/api/admin/tables/users/rows', { headers: { 'X-Flight-Session': nonAdminSession } }),
+      ctx('users'),
+    );
+    expect(forbidden.status).toBe(403);
+  });
+});

app/api/admin/tables/[name]/rows/route.ts

@@ -0,0 +1,219 @@
+import { persist } from '@/lib/db/client';
+import type { GameDb } from '@/lib/db/client';
+import { requireAdmin } from '@/lib/auth';
+
+// v0.71.0 — generic whole-database CRUD for the Admin modal (admin only, guarded BEFORE any
+// user input is touched). SQL safety: table names are quoted only after validation against
+// sqlite_master, column names only after validation against PRAGMA table_info, and VALUES ARE
+// ALWAYS BOUND AS PARAMETERS — no user input is ever concatenated into a SQL string.
+
+const DEFAULT_LIMIT = 500;
+const MAX_LIMIT = 1000;
+
+function quoteIdent(name: string): string {
+  return '"' + name.replace(/"/g, '""') + '"';
+}
+
+// The app's own tables (sqlite_% internals excluded) — the only names ever accepted.
+function tableNames(inst: GameDb): Set<string> {
+  const res = inst.raw.exec("SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'");
+  return new Set(res[0].values.map((r) => String(r[0])));
+}
+
+// Column names of a validated table (name already checked against sqlite_master).
+function columnsOf(inst: GameDb, name: string): string[] {
+  const res = inst.raw.exec(`PRAGMA table_info('${name.replace(/'/g, "''")}')`);
+  return res[0].values.map((r) => String(r[1]));
+}
+
+// Parameterized execute — the only way values reach SQL in this file.
+function run(inst: GameDb, sql: string, values: unknown[]): void {
+  inst.raw.run(sql, values as never[]);
+}
+
+async function readBody(req: Request): Promise<Record<string, unknown> | Response> {
+  let body: unknown;
+  try {
+    const text = await req.text();
+    body = text ? JSON.parse(text) : undefined;
+  } 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 (!ALLOWED_BODY_FIELDS.has(key)) {
+      return Response.json({ error: `unknown field "${key}"` }, { status: 400 });
+    }
+  }
+  return input;
+}
+
+// Per-method top-level body fields (strict, like the /api/test/* hooks).
+const ALLOWED_BODY_FIELDS = new Set(['rowid', 'values']);
+
+function valuesObject(input: Record<string, unknown>): Record<string, unknown> | Response {
+  const values = input.values;
+  if (typeof values !== 'object' || values === null || Array.isArray(values)) {
+    return Response.json({ error: 'values must be a JSON object of column → value' }, { status: 400 });
+  }
+  return values as Record<string, unknown>;
+}
+
+// Constraint violations (NOT NULL / UNIQUE) are the expected failure mode of a dev-tool edit;
+// anything else is a server error.
+function sqlError(err: unknown): Response {
+  const msg = err instanceof Error ? err.message : String(err);
+  if (/NOT NULL|UNIQUE|constraint failed/i.test(msg)) {
+    return Response.json({ error: `database constraint: ${msg}` }, { status: 409 });
+  }
+  console.error('admin rows route failed', err);
+  return Response.json({ error: 'database error' }, { status: 500 });
+}
+
+// GET /api/admin/tables/{name}/rows?limit=500 — column headers + up to `limit` rows (default
+// 500, cap 1000). rowid is exposed as __rowid so the PK-less tables (account, sim_state) are
+// editable like any other. Unknown table → 404; bad limit → 400.
+export async function GET(req: Request, ctx: { params: Promise<{ name: string }> }) {
+  const guard = await requireAdmin(req);
+  if (!guard.ok) return guard.response;
+
+  const { name } = await ctx.params;
+  if (!tableNames(guard.inst).has(name)) {
+    return Response.json({ error: 'unknown table' }, { status: 404 });
+  }
+  let limit = DEFAULT_LIMIT;
+  const limitParam = new URL(req.url).searchParams.get('limit');
+  if (limitParam !== null) {
+    limit = Number(limitParam);
+    if (!Number.isInteger(limit) || limit < 1) {
+      return Response.json({ error: 'limit must be a positive integer' }, { status: 400 });
+    }
+    limit = Math.min(limit, MAX_LIMIT);
+  }
+
+  const cols = columnsOf(guard.inst, name);
+  const stmt = guard.inst.raw.prepare(`SELECT rowid AS __rowid, * FROM ${quoteIdent(name)} LIMIT ?`);
+  try {
+    stmt.bind([limit]);
+    const rows: Array<Record<string, unknown>> = [];
+    while (stmt.step()) rows.push(stmt.getAsObject() as Record<string, unknown>);
+    return Response.json({ columns: ['__rowid', ...cols], rows });
+  } catch (err) {
+    return sqlError(err);
+  } finally {
+    stmt.free();
+  }
+}
+
+// PUT /api/admin/tables/{name}/rows — body { rowid, values: { col: value } }. Updates only the
+// given columns of that row. Unknown table → 404; unknown column or non-integer rowid or empty
+// values → 400.
+export async function PUT(req: Request, ctx: { params: Promise<{ name: string }> }) {
+  const guard = await requireAdmin(req);
+  if (!guard.ok) return guard.response;
+
+  const input = await readBody(req);
+  if (input instanceof Response) return input;
+  const rowid = input.rowid;
+  if (!Number.isInteger(rowid)) {
+    return Response.json({ error: 'rowid is required and must be an integer' }, { status: 400 });
+  }
+  const values = await valuesObject(input);
+  if (values instanceof Response) return values;
+
+  const { name } = await ctx.params;
+  if (!tableNames(guard.inst).has(name)) {
+    return Response.json({ error: 'unknown table' }, { status: 404 });
+  }
+  const cols = columnsOf(guard.inst, name);
+  for (const col of Object.keys(values)) {
+    if (!cols.includes(col)) {
+      return Response.json({ error: `unknown column "${col}"` }, { status: 400 });
+    }
+  }
+  if (Object.keys(values).length === 0) {
+    return Response.json({ error: 'values must contain at least one column' }, { status: 400 });
+  }
+
+  const setClause = Object.keys(values).map((c) => `${quoteIdent(c)} = ?`).join(', ');
+  try {
+    run(guard.inst, `UPDATE ${quoteIdent(name)} SET ${setClause} WHERE rowid = ?`, [
+      ...Object.values(values),
+      rowid,
+    ]);
+    await persist(guard.inst);
+    return Response.json({ ok: true });
+  } catch (err) {
+    return sqlError(err);
+  }
+}
+
+// POST /api/admin/tables/{name}/rows — body { values: { col: value } }. Inserts a new row with
+// exactly the given columns (others take their defaults or NULL). Returns the new rowid.
+export async function POST(req: Request, ctx: { params: Promise<{ name: string }> }) {
+  const guard = await requireAdmin(req);
+  if (!guard.ok) return guard.response;
+
+  const input = await readBody(req);
+  if (input instanceof Response) return input;
+  const values = await valuesObject(input);
+  if (values instanceof Response) return values;
+  if (Object.keys(values).length === 0) {
+    return Response.json({ error: 'values must contain at least one column' }, { status: 400 });
+  }
+
+  const { name } = await ctx.params;
+  if (!tableNames(guard.inst).has(name)) {
+    return Response.json({ error: 'unknown table' }, { status: 404 });
+  }
+  const cols = columnsOf(guard.inst, name);
+  for (const col of Object.keys(values)) {
+    if (!cols.includes(col)) {
+      return Response.json({ error: `unknown column "${col}"` }, { status: 400 });
+    }
+  }
+
+  const keys = Object.keys(values);
+  try {
+    run(
+      guard.inst,
+      `INSERT INTO ${quoteIdent(name)} (${keys.map(quoteIdent).join(', ')}) VALUES (${keys.map(() => '?').join(', ')})`,
+      Object.values(values),
+    );
+    // Read the new rowid BEFORE persist(): sql.js's export() (inside persist) resets
+    // last_insert_rowid to 0 on this connection.
+    const res = guard.inst.raw.exec('SELECT last_insert_rowid()');
+    await persist(guard.inst);
+    return Response.json({ ok: true, rowid: Number(res[0].values[0][0]) });
+  } catch (err) {
+    return sqlError(err);
+  }
+}
+
+// DELETE /api/admin/tables/{name}/rows?rowid=N — deletes that one row. Unknown table → 404;
+// missing/non-integer rowid → 400. Deleting a non-existent rowid is still 200 (idempotent).
+export async function DELETE(req: Request, ctx: { params: Promise<{ name: string }> }) {
+  const guard = await requireAdmin(req);
+  if (!guard.ok) return guard.response;
+
+  const { name } = await ctx.params;
+  if (!tableNames(guard.inst).has(name)) {
+    return Response.json({ error: 'unknown table' }, { status: 404 });
+  }
+  const rowidParam = new URL(req.url).searchParams.get('rowid');
+  const rowid = Number(rowidParam);
+  if (rowidParam === null || !Number.isInteger(rowid)) {
+    return Response.json({ error: 'rowid query parameter is required and must be an integer' }, { status: 400 });
+  }
+
+  try {
+    run(guard.inst, `DELETE FROM ${quoteIdent(name)} WHERE rowid = ?`, [rowid]);
+    await persist(guard.inst);
+    return Response.json({ ok: true });
+  } catch (err) {
+    return sqlError(err);
+  }
+}

app/api/admin/tables/route.test.ts

@@ -0,0 +1,80 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+import { getGameDb } from '@/lib/db/client';
+import { createSession } from '@/lib/auth';
+import { GET } from './route';
+
+// v0.71.0 — admin guard + table list tests: no/expired session → 401, non-admin → 403,
+// admin passes and sees every user table (sqlite_% excluded).
+
+let dir: string;
+
+beforeAll(async () => {
+  dir = await fs.mkdtemp(path.join(os.tmpdir(), 'flight-admin-tables-'));
+  process.env.FLIGHT_DB_PATH = path.join(dir, 'tables.db');
+});
+
+afterAll(async () => {
+  delete process.env.FLIGHT_DB_PATH;
+  await fs.rm(dir, { recursive: true, force: true });
+});
+
+const get = (sessionId?: string) =>
+  GET(
+    new Request('http://localhost/api/admin/tables', {
+      headers: sessionId ? { 'X-Flight-Session': sessionId } : undefined,
+    }),
+  );
+
+async function makeUser(username: string, admin: number): Promise<string> {
+  const inst = await getGameDb();
+  const id = `user-${username}`;
+  inst.raw.run(
+    `INSERT INTO users (id, username, password_hash, admin, created_at)
+     SELECT ?, ?, 'aa$bb', ?, ? WHERE NOT EXISTS (SELECT 1 FROM users WHERE id = ?)`,
+    [id, username, admin, Date.now(), id],
+  );
+  return id;
+}
+
+describe('GET /api/admin/tables', () => {
+  it('returns 401 without a session header', async () => {
+    const res = await get();
+    expect(res.status).toBe(401);
+  });
+
+  it('returns 401 for an expired session', async () => {
+    const inst = await getGameDb();
+    inst.raw.run('INSERT INTO sessions (id, user_id, expires_at) VALUES (?, ?, ?)', [
+      'expired-admin-session',
+      'admin-kamilkrzywda',
+      Date.now() - 1000,
+    ]);
+    const res = await get('expired-admin-session');
+    expect(res.status).toBe(401);
+  });
+
+  it('returns 403 for a valid non-admin session', async () => {
+    const userId = await makeUser('tables-nonadmin', 0);
+    const sessionId = await createSession(await getGameDb(), userId);
+    const res = await get(sessionId);
+    expect(res.status).toBe(403);
+    expect(((await res.json()) as { error: string }).error).toMatch(/admin/i);
+  });
+
+  it('lists every user table for an admin, excluding sqlite_% internals', async () => {
+    const sessionId = await createSession(await getGameDb(), 'admin-kamilkrzywda');
+    const res = await get(sessionId);
+    expect(res.status).toBe(200);
+    const names = ((await res.json()) as Array<{ name: string }>).map((t) => t.name);
+
+    for (const expected of ['account', 'packages', 'planes', 'sessions', 'sim_state', 'users']) {
+      expect(names, `missing ${expected}`).toContain(expected);
+    }
+    expect(names.some((n) => n.startsWith('sqlite_'))).toBe(false);
+    // Name-ordered.
+    expect([...names].sort()).toEqual(names);
+  });
+});

app/api/admin/tables/route.ts

@@ -0,0 +1,14 @@
+import { requireAdmin } from '@/lib/auth';
+
+// v0.71.0 — GET /api/admin/tables (admin only). Lists every user table as [{ name }] in name
+// order, excluding SQLite internals (sqlite_%). Feeds the Admin modal's table picker.
+
+export async function GET(req: Request) {
+  const guard = await requireAdmin(req);
+  if (!guard.ok) return guard.response;
+
+  const res = guard.inst.raw.exec(
+    "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' ORDER BY name",
+  );
+  return Response.json(res[0].values.map((r) => ({ name: String(r[0]) })));
+}

app/api/events/route.test.ts

@@ -0,0 +1,41 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+import { GET } from './route';
+
+let dir: string;
+
+beforeAll(async () => {
+  // Same pattern as app/api/state/route.test.ts: point the DB singleton at a throwaway file so
+  // this test never touches ./db/flight.db. getGameDb() reads the env var on first call, and
+  // vitest gives each test file its own module registry (fresh singleton).
+  dir = await fs.mkdtemp(path.join(os.tmpdir(), 'flight-events-'));
+  process.env.FLIGHT_DB_PATH = path.join(dir, 'events.db');
+});
+
+afterAll(async () => {
+  delete process.env.FLIGHT_DB_PATH;
+  await fs.rm(dir, { recursive: true, force: true });
+});
+
+describe('GET /api/events', () => {
+  it('streams SSE with the current snapshot as the first event', async () => {
+    const res = await GET();
+    expect(res.status).toBe(200);
+    expect(res.headers.get('content-type')).toContain('text/event-stream');
+    expect(res.headers.get('cache-control')).toBe('no-cache');
+    expect(res.headers.get('x-accel-buffering')).toBe('no');
+
+    const reader = (res.body as ReadableStream<Uint8Array>).getReader();
+    try {
+      const { value } = await reader.read(); // first chunk: the initial snapshot event
+      const text = new TextDecoder().decode(value);
+      expect(text.startsWith('data: ')).toBe(true);
+      const snap = JSON.parse(text.slice('data: '.length)) as Record<string, unknown>;
+      expect(typeof (snap.simState as { clockMs: number }).clockMs).toBe('number');
+    } finally {
+      await reader.cancel(); // → stream cancel → unsubscribe from the registry
+    }
+  });
+});

app/api/events/route.ts

@@ -0,0 +1,68 @@
+import { getStateSnapshot, sseFrame } from '@/lib/game/state';
+import { subscribe } from '@/lib/sse';
+
+// ISS-129 (v0.57.0): Server-Sent Events feed of state snapshots — the current snapshot on connect,
+// then one after every sim tick (broadcast from lib/sim/engine.ts). One-way push; player actions
+// stay REST POSTs. Heartbeats keep idle proxies from dropping the connection. ISS-133 (v0.59.0):
+// frames carry the sseFrame projection (terminal package history dropped) — same shape as the
+// pushed frames, so a connect never costs one full-history frame.
+
+const encoder = new TextEncoder();
+const HEARTBEAT_MS = 15_000;
+
+export async function GET() {
+  let heartbeat: ReturnType<typeof setInterval> | null = null;
+  let unsubscribe: (() => void) | null = null;
+  const cleanup = () => {
+    if (heartbeat !== null) clearInterval(heartbeat);
+    if (unsubscribe !== null) unsubscribe();
+  };
+
+  const stream = new ReadableStream<Uint8Array>({
+    start(controller) {
+      // Snapshot FIRST, then subscribe — a broadcast can never land before the initial event, so
+      // events are strictly ordered by sim clock. A tick in the gap just means the client waits ≤1 s
+      // for the next push instead of seeing an out-of-order frame.
+      getStateSnapshot()
+        .then((snapshot) => {
+          unsubscribe = subscribe((text) => {
+            try {
+              // broadcast carries the bare snapshot JSON — wrap it in an SSE frame here (the route owns
+              // wire framing, matching the initial snapshot + heartbeat above; lib/sse stays generic).
+              controller.enqueue(encoder.encode(`data: ${text}\n\n`));
+            } catch {
+              // stream already closed — cleanup runs on cancel
+            }
+          });
+          heartbeat = setInterval(() => {
+            try {
+              controller.enqueue(encoder.encode(': ping\n\n'));
+            } catch {
+              // same as above
+            }
+          }, HEARTBEAT_MS);
+          controller.enqueue(encoder.encode(`data: ${JSON.stringify(sseFrame(snapshot))}\n\n`));
+        })
+        .catch(() => {
+          cleanup();
+          try {
+            controller.close();
+          } catch {
+            // already closed
+          }
+        });
+    },
+    cancel() {
+      cleanup(); // client went away — drop the subscription + heartbeat
+    },
+  });
+
+  return new Response(stream, {
+    headers: {
+      'Content-Type': 'text/event-stream',
+      'Cache-Control': 'no-cache',
+      Connection: 'keep-alive',
+      'X-Accel-Buffering': 'no', // prod sits behind Traefik — don't buffer the stream
+    },
+  });
+}

app/api/login/route.test.ts

@@ -0,0 +1,93 @@
+import { randomUUID, scryptSync } from 'node:crypto';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+import { getGameDb } from '@/lib/db/client';
+import { SESSION_TTL_MS } from '@/lib/auth';
+import { POST } from './route';
+
+// v0.71.0 — login route tests. The test user is created HERE with a hash computed in-test via
+// scryptSync; the seeded admin's plaintext password must never appear in any test code, so it
+// is deliberately not exercised here (the e2e suite gets an admin session via /api/test/admin-session).
+
+let dir: string;
+const TEST_USER = 'unit-test-user';
+const TEST_PASSWORD = 'right-horse-wrong-street-42';
+const SALT_HEX = randomUUID().replace(/-/g, '').slice(0, 32); // 16-byte hex salt
+const HASH = `${SALT_HEX}$${scryptSync(TEST_PASSWORD, SALT_HEX, 32).toString('hex')}`;
+
+beforeAll(async () => {
+  dir = await fs.mkdtemp(path.join(os.tmpdir(), 'flight-login-api-'));
+  process.env.FLIGHT_DB_PATH = path.join(dir, 'login.db');
+});
+
+afterAll(async () => {
+  delete process.env.FLIGHT_DB_PATH;
+  await fs.rm(dir, { recursive: true, force: true });
+});
+
+const post = (body: unknown) => POST(new Request('http://localhost/api/login', { method: 'POST', body: JSON.stringify(body) }));
+
+async function createTestUser(): Promise<void> {
+  const inst = await getGameDb();
+  // Idempotent — two tests in this file both want the user.
+  inst.raw.run(
+    `INSERT INTO users (id, username, password_hash, admin, created_at)
+     SELECT 'user-unit-test', ?, ?, 0, ? WHERE NOT EXISTS (SELECT 1 FROM users WHERE username = ?)`,
+    [TEST_USER, HASH, Date.now(), TEST_USER],
+  );
+}
+
+describe('POST /api/login', () => {
+  it('rejects malformed bodies with 400', async () => {
+    for (const body of [{}, { username: 'x' }, { password: 'y' }, { username: '', password: 'p' }, { bogus: 1 }]) {
+      const res = await post(body);
+      expect(res.status).toBe(400);
+      expect(((await res.json()) as { error: string }).error).toBeTruthy();
+    }
+  });
+
+  it('returns 401 for an unknown username (and still runs a scrypt)', async () => {
+    const res = await post({ username: 'no-such-user', password: TEST_PASSWORD });
+    expect(res.status).toBe(401);
+    expect(((await res.json()) as { error: string }).error).toMatch(/invalid credentials/i);
+  });
+
+  it('returns 401 for a wrong password and mints no session', async () => {
+    await createTestUser();
+    const before = (await getGameDb()).raw.exec('SELECT COUNT(*) FROM sessions')[0].values[0][0];
+
+    const res = await post({ username: TEST_USER, password: 'definitely-wrong' });
+    expect(res.status).toBe(401);
+
+    const after = Number((await getGameDb()).raw.exec('SELECT COUNT(*) FROM sessions')[0].values[0][0]);
+    expect(after).toBe(Number(before));
+  });
+
+  it('mints a ~7-day session on success and returns the user', async () => {
+    await createTestUser();
+    const t0 = Date.now();
+
+    const res = await post({ username: TEST_USER, password: TEST_PASSWORD });
+    expect(res.status).toBe(200);
+    const body = (await res.json()) as { sessionId: string; user: { username: string; admin: boolean } };
+    expect(body.user).toEqual({ username: TEST_USER, admin: false });
+    expect(body.sessionId).toMatch(/^[0-9a-f-]{36}$/);
+
+    const row = (await getGameDb()).raw.exec('SELECT user_id, expires_at FROM sessions WHERE id = ?', [body.sessionId])[0].values[0];
+    expect(String(row[0])).toBe('user-unit-test');
+    const ttl = Number(row[1]) - t0;
+    expect(ttl).toBeGreaterThan(SESSION_TTL_MS - 5_000); // ~7 days, minus test drift
+    expect(ttl).toBeLessThan(SESSION_TTL_MS + 5_000);
+  });
+
+  it('login works for the seeded admin row too (hash verified without its plaintext)', async () => {
+    // The seeded admin's hash is a fixed string in client.ts; we can only prove the route
+    // ACCEPTS exactly that stored digest by checking verification against a known pair — which
+    // would require the plaintext. So instead: assert the seeded row is what login looks up, by
+    // confirming an unknown-password attempt for 'kamilkrzywda' yields 401 (row found, hash mismatch).
+    const res = await post({ username: 'kamilkrzywda', password: 'wrong-on-purpose' });
+    expect(res.status).toBe(401);
+  });
+});

app/api/login/route.ts

@@ -0,0 +1,52 @@
+import { getGameDb } from '@/lib/db/client';
+import { createSession, verifyPassword, DUMMY_HASH_FOR_UNKNOWN_USER } from '@/lib/auth';
+
+// v0.71.0 — POST /api/login
+//   body { username: string, password: string } (both required non-empty; unknown fields 400).
+//   Success → 200 { sessionId, user: { username, admin } }; the session row lives 7 days and is
+//   sent back as X-Flight-Session on later requests. Failure → 401 { error }. An unknown
+//   username still runs one full scrypt against a fixed dummy digest so timing stays uniform.
+
+export async function POST(req: Request) {
+  let body: unknown;
+  try {
+    const text = await req.text();
+    body = text ? JSON.parse(text) : undefined;
+  } 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' && key !== 'password') {
+      return Response.json({ error: `unknown field "${key}"` }, { status: 400 });
+    }
+  }
+  const username = input.username;
+  const password = input.password;
+  if (typeof username !== 'string' || username.length === 0) {
+    return Response.json({ error: 'username is required and must be a non-empty string' }, { status: 400 });
+  }
+  if (typeof password !== 'string' || password.length === 0) {
+    return Response.json({ error: 'password is required and must be a non-empty string' }, { status: 400 });
+  }
+
+  const inst = await getGameDb();
+  const res = inst.raw.exec('SELECT id, password_hash, admin FROM users WHERE username = ?', [username]);
+  const row = res[0]?.values?.[0];
+  if (!row) {
+    verifyPassword(password, DUMMY_HASH_FOR_UNKNOWN_USER); // uniform timing — result discarded
+    return Response.json({ error: 'invalid credentials' }, { status: 401 });
+  }
+  if (!verifyPassword(password, String(row[1]))) {
+    return Response.json({ error: 'invalid credentials' }, { status: 401 });
+  }
+
+  const sessionId = await createSession(inst, String(row[0]));
+  return Response.json({
+    sessionId,
+    user: { username, admin: Number(row[2]) === 1 },
+  });
+}

app/api/logout/route.test.ts

@@ -0,0 +1,60 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+import { getGameDb } from '@/lib/db/client';
+import { createSession } from '@/lib/auth';
+import { POST } from './route';
+
+// v0.71.0 — logout route tests: deletes the session named by X-Flight-Session, idempotently.
+
+let dir: string;
+
+beforeAll(async () => {
+  dir = await fs.mkdtemp(path.join(os.tmpdir(), 'flight-logout-api-'));
+  process.env.FLIGHT_DB_PATH = path.join(dir, 'logout.db');
+});
+
+afterAll(async () => {
+  delete process.env.FLIGHT_DB_PATH;
+  await fs.rm(dir, { recursive: true, force: true });
+});
+
+const post = (sessionId?: string) =>
+  POST(
+    new Request('http://localhost/api/logout', {
+      method: 'POST',
+      headers: sessionId ? { 'X-Flight-Session': sessionId } : undefined,
+    }),
+  );
+
+async function mintSession(): Promise<string> {
+  const inst = await getGameDb();
+  return createSession(inst, 'admin-kamilkrzywda'); // any user id works — logout only deletes the session row
+}
+
+describe('POST /api/logout', () => {
+  it('returns 401 without a session header', async () => {
+    const res = await post();
+    expect(res.status).toBe(401);
+  });
+
+  it('deletes the named session and is idempotent on repeat calls', async () => {
+    const sessionId = await mintSession();
+    const count = (await getGameDb()).raw.exec('SELECT COUNT(*) FROM sessions WHERE id = ?', [sessionId])[0].values[0][0];
+    expect(Number(count)).toBe(1);
+
+    const first = await post(sessionId);
+    expect(first.status).toBe(200);
+    expect(await first.json()).toEqual({ ok: true });
+
+    // The row is gone…
+    const after = (await getGameDb()).raw.exec('SELECT COUNT(*) FROM sessions WHERE id = ?', [sessionId])[0].values[0][0];
+    expect(Number(after)).toBe(0);
+
+    // …and a second logout of the same (now unknown) session is still 200.
+    const second = await post(sessionId);
+    expect(second.status).toBe(200);
+    expect(await second.json()).toEqual({ ok: true });
+  });
+});

app/api/logout/route.ts

@@ -0,0 +1,16 @@
+import { getGameDb, persist } from '@/lib/db/client';
+import { SESSION_HEADER } from '@/lib/auth';
+
+// v0.71.0 — POST /api/logout (no body). Deletes the session named by the X-Flight-Session
+// header; idempotent — deleting an unknown or already-deleted session is still 200. A missing
+// header has nothing to delete and gets 401 like every other unauthenticated request here.
+
+export async function POST(req: Request) {
+  const sessionId = req.headers.get(SESSION_HEADER);
+  if (!sessionId) return Response.json({ error: 'authentication required' }, { status: 401 });
+
+  const inst = await getGameDb();
+  inst.raw.run('DELETE FROM sessions WHERE id = ?', [sessionId]);
+  await persist(inst);
+  return Response.json({ ok: true });
+}

app/api/me/route.test.ts

@@ -0,0 +1,72 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+import { getGameDb } from '@/lib/db/client';
+import { createSession } from '@/lib/auth';
+import { GET } from './route';
+
+// v0.71.0 — /api/me tests: resolves X-Flight-Session to its user, 401 otherwise.
+
+let dir: string;
+
+beforeAll(async () => {
+  dir = await fs.mkdtemp(path.join(os.tmpdir(), 'flight-me-api-'));
+  process.env.FLIGHT_DB_PATH = path.join(dir, 'me.db');
+});
+
+afterAll(async () => {
+  delete process.env.FLIGHT_DB_PATH;
+  await fs.rm(dir, { recursive: true, force: true });
+});
+
+const get = (sessionId?: string) =>
+  GET(
+    new Request('http://localhost/api/me', {
+      headers: sessionId ? { 'X-Flight-Session': sessionId } : undefined,
+    }),
+  );
+
+describe('GET /api/me', () => {
+  it('returns 401 without a session header', async () => {
+    const res = await get();
+    expect(res.status).toBe(401);
+  });
+
+  it('returns 401 for an unknown session id', async () => {
+    const res = await get('00000000-0000-4000-8000-000000000000');
+    expect(res.status).toBe(401);
+  });
+
+  it('returns 401 for an expired session', async () => {
+    const inst = await getGameDb();
+    // A session whose expiry is already in the past.
+    inst.raw.run('INSERT INTO sessions (id, user_id, expires_at) VALUES (?, ?, ?)', [
+      'expired-session-id',
+      'admin-kamilkrzywda',
+      Date.now() - 1000,
+    ]);
+    const res = await get('expired-session-id');
+    expect(res.status).toBe(401);
+  });
+
+  it('returns the user for a live session (admin flag included)', async () => {
+    const sessionId = await createSession(await getGameDb(), 'admin-kamilkrzywda');
+    const res = await get(sessionId);
+    expect(res.status).toBe(200);
+    expect(await res.json()).toEqual({ username: 'kamilkrzywda', admin: true });
+  });
+
+  it('reports non-admin users as such', async () => {
+    const inst = await getGameDb();
+    inst.raw.run(
+      `INSERT INTO users (id, username, password_hash, admin, created_at)
+       SELECT 'user-me-test', 'me-test-user', 'aa$bb', 0, ? WHERE NOT EXISTS (SELECT 1 FROM users WHERE id = 'user-me-test')`,
+      [Date.now()],
+    );
+    const sessionId = await createSession(inst, 'user-me-test');
+    const res = await get(sessionId);
+    expect(res.status).toBe(200);
+    expect(await res.json()).toEqual({ username: 'me-test-user', admin: false });
+  });
+});

app/api/me/route.ts

@@ -0,0 +1,11 @@
+import { currentUser } from '@/lib/auth';
+
+// v0.71.0 — GET /api/me (no body). Returns the user behind a valid X-Flight-Session header as
+// { username, admin }, or 401 when the header is missing/unknown/expired. The client uses it to
+// decide what the Admin modal shows on open.
+
+export async function GET(req: Request) {
+  const user = await currentUser(req);
+  if (!user) return Response.json({ error: 'authentication required' }, { status: 401 });
+  return Response.json({ username: user.username, admin: user.admin });
+}

app/api/packages/[id]/abandon/route.test.ts

@@ -57,7 +57,7 @@ describe('POST /api/packages/:id/abandon', () => {
     const { db } = await getGameDb();
     await db.insert(schema.packages).values({
       id: 'p-open', originIcao: 'EDDF', destIcao: 'LEMD', reward: 1, cargoType: 'Mail', cargoCount: 1,
-      deadlineSimTime: Date.now() + 3_600_000, status: 'open', planeId: null, createdSimTime: Date.now(),
+      deadlineSimTime: Date.now() + 3_600_000, status: 'open', planeId: null, createdSimTime: Date.now(), createdRealMs: Date.now(), // v0.65.0 — stay open past the pre-action tick
     });
 
     const res = await post('p-open');
@@ -94,7 +94,7 @@ describe('POST /api/packages/:id/abandon', () => {
     // Response convention (v0.8.0): the FULL snapshot, same shape as GET /api/state.
     const body = (await res.json()) as {
       account: { cash: number };
-      simState: { clockMs: number; timeScale: number; paused: boolean };
+      simState: { clockMs: number }; // ISS-117
       packages: Array<{ id: string; status: string; planeId: string | null }>;
     };
     expect(Object.keys(body).sort()).toEqual([

app/api/packages/[id]/ignore/route.ts

@@ -1,10 +0,0 @@
-import { ignorePackage, performAction } from '@/lib/game/actions';
-
-// POST /api/packages/:id/ignore (v0.29.0, ISS-047 part B) — no body. Dismisses an OPEN job so it
-// leaves the market permanently; the top-up logic spawns a replacement on the next tick. No penalty,
-// nothing else changes. 404 unknown id; 409 unless open. On success returns the full state snapshot.
-
-export async function POST(_req: Request, ctx: { params: Promise<{ id: string }> }) {
-  const { id } = await ctx.params;
-  return performAction((inst) => ignorePackage(inst, id));
-}

app/api/packages/[id]/load/route.test.ts

@@ -45,7 +45,7 @@ describe('POST /api/packages/:id/load', () => {
     const { db } = await getGameDb();
     await db.insert(schema.packages).values({
       id: 'p-ghost-plane', originIcao: 'EDDF', destIcao: 'LEMD', reward: 1, cargoType: 'Mail', cargoCount: 1,
-      deadlineSimTime: Date.now() + 3_600_000, status: 'open', planeId: null, createdSimTime: Date.now(),
+      deadlineSimTime: Date.now() + 3_600_000, status: 'open', planeId: null, createdSimTime: Date.now(), createdRealMs: Date.now(), // v0.65.0 — fresh wall-clock stamp or the pre-action tick expires it
     });
 
     const res = await post('p-ghost-plane', { planeId: 'ghost' });
@@ -57,7 +57,7 @@ describe('POST /api/packages/:id/load', () => {
     // The seeded starter sits at EDDF — a package from LEMD cannot be loaded there.
     await db.insert(schema.packages).values({
       id: 'p-elsewhere', originIcao: 'LEMD', destIcao: 'EDDF', reward: 1, cargoType: 'Mail', cargoCount: 1,
-      deadlineSimTime: Date.now() + 3_600_000, status: 'open', planeId: null, createdSimTime: Date.now(),
+      deadlineSimTime: Date.now() + 3_600_000, status: 'open', planeId: null, createdSimTime: Date.now(), createdRealMs: Date.now(), // v0.65.0 — fresh wall-clock stamp or the pre-action tick expires it
     });
 
     const res = await post('p-elsewhere', { planeId: 'plane-starter' });
@@ -82,7 +82,7 @@ describe('POST /api/packages/:id/load', () => {
     // A known open package originating where the starter actually sits (EDDF).
     await db.insert(schema.packages).values({
       id: 'p-home', originIcao: 'EDDF', destIcao: 'LEMD', reward: 1_000, cargoType: 'Mail', cargoCount: 4,
-      deadlineSimTime: Date.now() + 24 * 3_600_000, status: 'open', planeId: null, createdSimTime: Date.now(),
+      deadlineSimTime: Date.now() + 24 * 3_600_000, status: 'open', planeId: null, createdSimTime: Date.now(), createdRealMs: Date.now(), // v0.65.0 — fresh wall-clock stamp or the pre-action tick expires it
     });
 
     const res = await post('p-home', { planeId: 'plane-starter' });
@@ -92,7 +92,7 @@ describe('POST /api/packages/:id/load', () => {
     // Response convention (v0.8.0): the FULL snapshot, same shape as GET /api/state.
     const body = (await res.json()) as {
       account: { cash: number };
-      simState: { clockMs: number; timeScale: number; paused: boolean };
+      simState: { clockMs: number }; // ISS-117
       planes: Array<Record<string, unknown>>;
       packages: Array<{ id: string; status: string; planeId: string | null }>;
     };

app/api/planes/[planeId]/fly/route.test.ts

@@ -84,7 +84,7 @@ describe('POST /api/planes/:planeId/fly', () => {
     // Response convention (v0.8.0): the FULL snapshot, same shape as GET /api/state.
     const body = (await res.json()) as {
       account: { cash: number };
-      simState: { clockMs: number; timeScale: number; paused: boolean };
+      simState: { clockMs: number }; // ISS-117
       planes: Array<{ id: string; status: string; destIcao: string | null; departureSimTime: number | null; locationIcao: string }>;
     };
     expect(Object.keys(body).sort()).toEqual([

app/api/planes/[planeId]/repair/route.ts

@@ -1,10 +1,10 @@
 import { performAction, repairPlane } from '@/lib/game/actions';
 
-// POST /api/planes/:planeId/repair (v0.39.0, ISS-069) — no body. Restores a worn-out plane to
+// POST /api/planes/:planeId/repair (v0.39.0, ISS-069) — no body. Grounds a worn-out plane in
-// full health for the flat REPAIR_COST: it is grounded in "repairing" status until 3 sim days
+// "repairing" status for the flat REPAIR_COST; its health climbs back to 100 over 3 sim days and
-// pass, when the engine's tick flips it back to "available". A full-health repair is a free
+// the engine's tick flips it to "available" exactly when full (v0.45.0, ISS-089). A full-health
-// no-op (cost 0). 404 unknown id; 409 plane not grounded or insufficient funds. On success
+// repair is a free no-op (cost 0). 404 unknown id; 409 plane not grounded or insufficient funds.
-// returns the full state snapshot.
+// On success returns the full state snapshot.
 
 export async function POST(_req: Request, ctx: { params: Promise<{ planeId: string }> }) {
   const { planeId } = await ctx.params;

app/api/sim/route.test.ts

@@ -1,116 +0,0 @@
-import fs from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-import { afterAll, beforeAll, describe, expect, it } from 'vitest';
-import { getGameDb } from '@/lib/db/client';
-import * as schema from '@/lib/db/schema';
-import { POST } from './route';
-
-let dir: string;
-
-beforeAll(async () => {
-  // Same pattern as app/api/state/route.test.ts: point the DB singleton at a
-  // throwaway file (fresh module registry per test file → fresh singleton).
-  dir = await fs.mkdtemp(path.join(os.tmpdir(), 'flight-sim-api-'));
-  process.env.FLIGHT_DB_PATH = path.join(dir, 'sim.db');
-});
-
-afterAll(async () => {
-  delete process.env.FLIGHT_DB_PATH;
-  await fs.rm(dir, { recursive: true, force: true });
-});
-
-const post = (body: unknown) => POST(new Request('http://localhost/api/sim', { method: 'POST', body: JSON.stringify(body) }));
-const postRaw = (text: string) => POST(new Request('http://localhost/api/sim', { method: 'POST', body: text }));
-
-describe('POST /api/sim', () => {
-  it('returns the current simState for an empty body (tick + no-op)', async () => {
-    const res = await post({});
-    expect(res.status).toBe(200);
-    const body = (await res.json()) as { clockMs: number; timeScale: number; paused: boolean };
-    expect(typeof body.clockMs).toBe('number');
-    expect(body.timeScale).toBe(1); // seeded default
-    expect(body.paused).toBe(false);
-  });
-
-  it('sets and clamps timeScale into [1, 1000]', async () => {
-    const hi = await post({ timeScale: 2000 });
-    expect(hi.status).toBe(200);
-    expect(((await hi.json()) as { timeScale: number }).timeScale).toBe(1000);
-
-    const lo = await post({ timeScale: 0.1 });
-    expect(lo.status).toBe(200);
-    expect(((await lo.json()) as { timeScale: number }).timeScale).toBe(1);
-
-    // The top of the ladder passes through unclamped (v0.14.0).
-    const max = await post({ timeScale: 1000 });
-    expect(max.status).toBe(200);
-    expect(((await max.json()) as { timeScale: number }).timeScale).toBe(1000);
-
-    // In-range values pass through unclamped — ladder and off-ladder alike.
-    const ladder = await post({ timeScale: 500 });
-    expect(ladder.status).toBe(200);
-    expect(((await ladder.json()) as { timeScale: number }).timeScale).toBe(500);
-
-    const mid = await post({ timeScale: 37 });
-    expect(mid.status).toBe(200);
-    expect(((await mid.json()) as { timeScale: number }).timeScale).toBe(37);
-
-    // Restore the default for later tests.
-    await post({ timeScale: 1 });
-  });
-
-  it('toggles paused and freezes the clock across ticks', async () => {
-    const pause = await post({ paused: true });
-    expect(pause.status).toBe(200);
-    expect(((await pause.json()) as { paused: boolean }).paused).toBe(true);
-
-    // Two reads while paused → identical clock (tick-on-read advances nothing).
-    const a = await post({});
-    const b = await post({});
-    expect(((await a.json()) as { clockMs: number }).clockMs).toBe(
-      ((await b.json()) as { clockMs: number }).clockMs,
-    );
-
-    const resume = await post({ paused: false });
-    expect(resume.status).toBe(200);
-    expect(((await resume.json()) as { paused: boolean }).paused).toBe(false);
-  });
-
-  it('applies both fields in one call', async () => {
-    const res = await post({ timeScale: 64, paused: true });
-    expect(res.status).toBe(200);
-    const body = (await res.json()) as { timeScale: number; paused: boolean };
-    expect(body.timeScale).toBe(64);
-    expect(body.paused).toBe(true);
-    await post({ timeScale: 1, paused: false }); // restore
-  });
-
-  it('records lastSelectedTimeScale when timeScale is posted; a paused-only post leaves it untouched (ISS-057)', async () => {
-    const inst = await getGameDb(); // same singleton the route's applyTimeControls writes through
-    const row = async () => (await inst.db.select().from(schema.simState))[0];
-
-    await post({ timeScale: 250 });
-    expect((await row()).lastSelectedTimeScale).toBe(250); // manual intent recorded…
-
-    await post({ paused: true });
-    expect((await row()).paused).toBe(true);
-    expect((await row()).lastSelectedTimeScale).toBe(250); // …and a {paused}-only post does not touch it
-
-    await post({ timeScale: 1, paused: false }); // restore
-    expect((await row()).lastSelectedTimeScale).toBe(1);
-  });
-
-  it('rejects invalid input with 400', async () => {
-    for (const body of [{ timeScale: 'fast' }, { timeScale: Infinity }, { paused: 'yes' }, { bogus: 1 }]) {
-      const res = await post(body);
-      expect(res.status).toBe(400);
-      expect(((await res.json()) as { error: string }).error).toBeTruthy();
-    }
-
-    for (const text of ['nope{', '[1,2]', '"str"', 'null']) {
-      const res = await postRaw(text);
-      expect(res.status).toBe(400);
-    }
-  });
-});

app/api/sim/route.ts

@@ -1,42 +0,0 @@
-import { applyTimeControls } from '@/lib/sim/engine';
-
-// POST /api/sim — set sim time controls (v0.7.0). Body: { timeScale?: 1–1000, paused?: boolean }.
-// Ticks the clock first (so the response reflects current game time), then applies
-// and persists the new controls. Returns the updated simState.
-
-export async function POST(req: Request) {
-  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 !== 'timeScale' && key !== 'paused') {
-      return Response.json({ error: `unknown field "${key}"` }, { status: 400 });
-    }
-  }
-  if (input.timeScale !== undefined && (typeof input.timeScale !== 'number' || !Number.isFinite(input.timeScale))) {
-    return Response.json({ error: 'timeScale must be a finite number (1–1000)' }, { status: 400 });
-  }
-  if (input.paused !== undefined && typeof input.paused !== 'boolean') {
-    return Response.json({ error: 'paused must be a boolean' }, { status: 400 });
-  }
-
-  try {
-    const sim = await applyTimeControls({
-      timeScale: input.timeScale as number | undefined,
-      paused: input.paused as boolean | undefined,
-    });
-    return Response.json({ clockMs: sim.clockMs, timeScale: sim.timeScale, paused: sim.paused });
-  } catch (err) {
-    console.error('failed to apply sim controls', err);
-    return Response.json({ error: 'failed to apply sim controls' }, { status: 500 });
-  }
-}

app/api/state/route.test.ts

@@ -2,6 +2,8 @@ import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+import { loadAirportsGeoJson } from '@/lib/airports';
+import { haversineKm } from '@/lib/geo';
 import { FUEL_PRICE_PER_L, PLANE_TYPES, SELL_FRACTION } from '@/lib/game/catalog';
 import { GET } from './route';
 
@@ -41,10 +43,8 @@ describe('GET /api/state', () => {
     expect(typeof account.cash).toBe('number');
     expect(typeof account.reputation).toBe('number');
 
-    const sim = body.simState as { clockMs: number; timeScale: number; paused: boolean };
+    const sim = body.simState as { clockMs: number }; // ISS-117: time controls are gone — clock only
     expect(typeof sim.clockMs).toBe('number');
-    expect(typeof sim.timeScale).toBe('number');
-    expect(sim.paused).toBe(false);
 
     const planes = body.planes as Array<Record<string, unknown>>;
     expect(planes.length).toBeGreaterThanOrEqual(1);
@@ -58,9 +58,20 @@ describe('GET /api/state', () => {
 
     const packages = body.packages as Array<Record<string, unknown>>;
     expect(packages.length).toBeGreaterThan(0);
-    for (const key of ['id', 'originIcao', 'destIcao', 'reward', 'cargoType', 'weightKg', 'deadlineSimTime', 'status']) {
+    for (const key of ['id', 'originIcao', 'destIcao', 'reward', 'cargoType', 'weightKg', 'distanceKm', 'deadlineSimTime', 'status']) {
       expect(packages[0], `package.${key}`).toHaveProperty(key);
     }
+
+    // v0.48.0 (ISS-095): distanceKm is computed server-side — it must equal the haversine of the
+    // fixture airports' coordinates for every package in the snapshot.
+    const fc = await loadAirportsGeoJson();
+    const coords = new Map(fc.features.map((f) => [f.properties.icao, f.properties]));
+    for (const pkg of packages) {
+      const from = coords.get(String(pkg.originIcao));
+      const to = coords.get(String(pkg.destIcao));
+      if (!from || !to) continue; // missing coord → 0 fallback (cannot happen with the committed dataset)
+      expect(pkg.distanceKm, `package ${String(pkg.id)} distance`).toBeCloseTo(haversineKm(from.lat, from.lon, to.lat, to.lon), 6);
+    }
   });
 
   it('is stable across repeated calls (same seeded DB)', async () => {

app/api/test/admin-session/route.ts

@@ -0,0 +1,23 @@
+import { getGameDb } from '@/lib/db/client';
+import { createSession } from '@/lib/auth';
+
+// TEST-ONLY hook (v0.71.0) — mints a live session for the SEEDED admin user server-side and
+// returns its id, so the e2e suite can exercise the authenticated Admin panel WITHOUT the real
+// admin password ever appearing in test code (the spec forbids it). No body. Disabled unless
+// FLIGHT_TEST_HOOKS=1 (set in docker-compose.ci.yml for the CI stack only); every other
+// deployment 404s here, like its /api/test/* siblings.
+
+export async function POST() {
+  if (process.env.FLIGHT_TEST_HOOKS !== '1') {
+    return Response.json({ error: 'test hooks disabled' }, { status: 404 });
+  }
+
+  const inst = await getGameDb();
+  const res = inst.raw.exec("SELECT id FROM users WHERE username = 'kamilkrzywda'");
+  const userId = res[0]?.values?.[0]?.[0];
+  if (typeof userId !== 'string') {
+    return Response.json({ error: 'seeded admin user missing' }, { status: 500 });
+  }
+  const sessionId = await createSession(inst, userId);
+  return Response.json({ sessionId });
+}

app/api/test/expire-package/route.ts

@@ -3,21 +3,22 @@ import { eq } from 'drizzle-orm';
 import { getGameDb, persist } from '@/lib/db/client';
 import * as schema from '@/lib/db/schema';
 import { loadAirportsGeoJson } from '@/lib/airports';
-import { generatePackage, mulberry32 } from '@/lib/game/seed';
+import { generatePackage, HUB_ICAO, JOB_LIFETIME_MS, mulberry32 } from '@/lib/game/seed';
 import { tickNow } from '@/lib/sim/engine';
 
-// TEST-ONLY hook (v0.7.0, adapted to packages in v0.12.0) — lets the e2e suite
+// TEST-ONLY hook (v0.7.0, adapted to packages in v0.12.0; reworked for wall-clock expiry in v0.65.0) —
-// observe package expiry without waiting hours of game time. Disabled unless
+// lets the e2e suite observe open-job expiry without waiting an hour of real time. Disabled unless
-// FLIGHT_TEST_HOOKS=1, which is set in docker-compose.yml for the e2e instance
+// FLIGHT_TEST_HOOKS=1, which is set in docker-compose.yml for the e2e instance only; every other
-// only; every other deployment 404s here.
+// deployment 404s here.
 //
 // POST /api/test/expire-package
 //   body { packageId?: string }
-//   - with packageId: moves that OPEN package's deadline to now + HOOK_DEADLINE_MS
+//   - with packageId: ages that OPEN package's createdRealMs to HOOK_AGE_MS in the past so the next
-//     (game time) so the next fast tick expires it; 404 if unknown/not open.
+//     tick (run immediately via tickNow) flips it to 'expired'; 404 if unknown/not open.
-//   - without: creates a fresh open package with the same short deadline.
+//   - without: creates a fresh open package at the home hub, already aged past its lifetime — visible
+//     while open (the hub is always in the pool), expired by the time the caller polls /api/state.
 
-const HOOK_DEADLINE_MS = 10_000; // game ms past the current clock (≈ 0.01 s real at the fastest 1000×)
+const HOOK_AGE_MS = JOB_LIFETIME_MS + 60_000; // comfortably past the job lifetime
 
 export async function POST(req: Request) {
   if (process.env.FLIGHT_TEST_HOOKS !== '1') {
@@ -41,8 +42,6 @@ export async function POST(req: Request) {
 
   try {
     const inst = await getGameDb();
-    const sim = await tickNow(); // clock is current before we set the deadline
-    const deadlineSimTime = Math.round(sim.clockMs + HOOK_DEADLINE_MS);
 
     if (typeof packageId === 'string') {
       const rows = await inst.db.select().from(schema.packages).where(eq(schema.packages.id, packageId));
@@ -50,8 +49,11 @@ export async function POST(req: Request) {
       if (!row || row.status !== 'open') {
         return Response.json({ error: 'package not found or not open' }, { status: 404 });
       }
-      await inst.db.update(schema.packages).set({ deadlineSimTime }).where(eq(schema.packages.id, packageId));
+      await inst.db.update(schema.packages).set({ createdRealMs: Date.now() - HOOK_AGE_MS }).where(eq(schema.packages.id, packageId));
       await persist(inst);
+      // AFTER the mutation on purpose: tickNow runs a full tickOnce, so expireOpenPackages flips the
+      // aged row to 'expired' within this same call — callers can poll /api/state immediately.
+      await tickNow();
       const updated = (await inst.db.select().from(schema.packages).where(eq(schema.packages.id, packageId)))[0];
       return Response.json(updated ?? row);
     }
@@ -64,11 +66,18 @@ export async function POST(req: Request) {
       lon: f.properties.lon,
     }));
     const rng = mulberry32(randomInt(0, 2 ** 31));
-    // special: null — the hook never rolls a special status (v0.37.0).
+    // nowMs anchors createdSimTime/deadlineSimTime to the GAME clock (ISS-117) — only createdRealMs
-    const created = generatePackage({ id: randomUUID(), airports, rng, nowMs: sim.clockMs, deadlineOffsetMs: HOOK_DEADLINE_MS, special: null });
+    // is real time. special: null — the hook never rolls a special status (v0.37.0). Origin forced to
+    // the home hub so the job is visible while open; already aged past its lifetime, it expires on
+    // the tick below.
+    const sim = (await inst.db.select().from(schema.simState))[0];
+    if (!sim) throw new Error('sim_state row missing');
+    const created = generatePackage({ id: randomUUID(), airports, rng, nowMs: sim.clockMs, originIcao: HUB_ICAO, special: null, createdRealMs: Date.now() - HOOK_AGE_MS });
     await inst.db.insert(schema.packages).values(created);
     await persist(inst);
-    return Response.json(created, { status: 201 });
+    await tickNow();
+    const updated = (await inst.db.select().from(schema.packages).where(eq(schema.packages.id, created.id)))[0];
+    return Response.json(updated ?? created, { status: 201 });
   } catch (err) {
     console.error('test hook failed', err);
     return Response.json({ error: 'test hook failed' }, { status: 500 });

app/api/test/set-cash/route.ts

@@ -0,0 +1,54 @@
+import { getGameDb, persist } from '@/lib/db/client';
+import * as schema from '@/lib/db/schema';
+import { getStateSnapshot } from '@/lib/game/state';
+import { tickNow } from '@/lib/sim/engine';
+
+// TEST-ONLY hook (v0.46.0, ISS-088) — sets the account's cash to an ABSOLUTE value so the e2e suite
+// can stage exact balances (e.g. drain it below a refuel cost to test grounding, then restore it).
+// Disabled unless FLIGHT_TEST_HOOKS=1 (set in docker-compose.yml for the e2e instance only); every
+// other deployment 404s here. Sibling of /api/test/add-cash — same gate, same conventions; add-cash
+// stays for relative grants, this one is exact.
+//
+// POST /api/test/set-cash
+//   body { amount: number } — required; a finite number in [0, ∞) (400 otherwise). Sets
+//   account.cash to exactly that value and returns the full state snapshot after ticking.
+
+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 !== 'amount') {
+      return Response.json({ error: `unknown field "${key}"` }, { status: 400 });
+    }
+  }
+  const amount = input.amount;
+  if (typeof amount !== 'number' || !Number.isFinite(amount) || amount < 0) {
+    return Response.json({ error: 'amount is required and must be a finite number >= 0' }, { status: 400 });
+  }
+
+  try {
+    const inst = await getGameDb();
+    await tickNow(); // clock is current before the snapshot we return (same as siblings)
+    const account = (await inst.db.select().from(schema.account))[0];
+    if (!account) throw new Error('account row missing');
+    await inst.db.update(schema.account).set({ cash: Math.round(amount * 100) / 100 });
+    await persist(inst);
+    return Response.json(await getStateSnapshot());
+  } catch (err) {
+    console.error('test hook failed', err);
+    return Response.json({ error: 'test hook failed' }, { status: 500 });
+  }
+}

app/api/test/set-timescale/route.ts

@@ -0,0 +1,47 @@
+import { setTestTimeScale } from '@/lib/sim/engine';
+
+// TEST-ONLY hook (v0.52.0, ISS-117) — lets the e2e suite override the effective time scale now
+// that there are no player-facing controls; without it every spec would run at the fixed world
+// rate and a cross-Europe leg would take hours of real time. Disabled unless FLIGHT_TEST_HOOKS=1
+// (set in docker-compose.yml for the e2e instance only); every other deployment 404s here.
+// Sibling of /api/test/set-health — same gate, same conventions.
+//
+// POST /api/test/set-timescale
+//   body { timeScale: number } — a finite number in [1, 100_000] (400 otherwise).
+//   Ticks first so the write lands on current game state, under the sim lock.
+//   Returns { clockMs, timeScale } — the new effective scale for test assertions.
+
+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 !== 'timeScale') {
+      return Response.json({ error: `unknown field "${key}"` }, { status: 400 });
+    }
+  }
+  const timeScale = input.timeScale;
+  if (typeof timeScale !== 'number' || !Number.isFinite(timeScale) || timeScale < 1 || timeScale > 100_000) {
+    return Response.json({ error: 'timeScale must be a finite number in [1, 100000]' }, { status: 400 });
+  }
+
+  try {
+    const row = await setTestTimeScale(timeScale);
+    return Response.json({ clockMs: row.clockMs, timeScale: row.timeScale });
+  } catch (err) {
+    console.error('test hook failed', err);
+    return Response.json({ error: 'test hook failed' }, { status: 500 });
+  }
+}

app/globals.css

@@ -588,3 +588,142 @@ body {
   font-weight: 600;
   color: #f1f5f9;
 }
+
+/* v0.71.0 — Admin modal: overlay sits above the z-50 toast stack; panel matches the dark slate theme. */
+.modal-overlay {
+  position: fixed;
+  inset: 0;
+  z-index: 60; /* above toasts (z-50) and everything else on screen */
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  background: rgba(2, 6, 23, 0.7);
+}
+
+.modal-panel {
+  width: min(920px, calc(100vw - 32px));
+  max-height: calc(100vh - 48px);
+  display: flex;
+  flex-direction: column;
+  background: rgba(15, 23, 42, 0.97);
+  color: #e2e8f0;
+  border: 1px solid rgba(148, 163, 184, 0.4);
+  border-radius: 8px;
+  box-shadow: 0 12px 40px rgba(2, 6, 23, 0.6);
+}
+
+.modal-header {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 8px;
+  padding: 10px 14px;
+  border-bottom: 1px solid rgba(148, 163, 184, 0.25);
+}
+
+.modal-header h2 {
+  margin: 0;
+  font-size: 15px;
+  font-weight: 600;
+}
+
+/* v0.71.0 — Admin panel content (login form + generic DB grid). */
+.admin-panel {
+  padding: 14px;
+  overflow-y: auto;
+  display: flex;
+  flex-direction: column;
+  gap: 10px;
+}
+
+.admin-login {
+  max-width: 320px;
+  margin: 0 auto;
+  width: 100%;
+}
+
+.admin-panel label {
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+  font-size: 12px;
+  color: #cbd5e1;
+}
+
+.admin-panel input[type='text'],
+.admin-panel input:not([type]),
+.admin-login input {
+  font-size: 13px;
+  padding: 5px 8px;
+  border-radius: 4px;
+  border: 1px solid rgba(148, 163, 184, 0.4);
+  background: #1e293b;
+  color: #e2e8f0;
+}
+
+.admin-message {
+  margin: 0;
+  font-size: 13px;
+  color: #cbd5e1;
+}
+
+.admin-error {
+  font-size: 12px;
+  color: #fca5a5;
+}
+
+.admin-toolbar {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  flex-wrap: wrap;
+}
+
+.admin-table-list {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 6px;
+}
+
+.admin-rows-wrap {
+  overflow-x: auto;
+  border: 1px solid rgba(148, 163, 184, 0.25);
+  border-radius: 6px;
+}
+
+.admin-rows {
+  width: 100%;
+  border-collapse: collapse;
+  font-size: 12px;
+}
+
+.admin-rows th,
+.admin-rows td {
+  padding: 4px 6px;
+  text-align: left;
+  white-space: nowrap;
+  border-bottom: 1px solid rgba(148, 163, 184, 0.2);
+}
+
+.admin-rows th {
+  color: #94a3b8;
+  font-weight: 600;
+}
+
+.admin-cell {
+  width: 110px;
+  font-size: 12px;
+  padding: 2px 5px;
+  border-radius: 3px;
+  border: 1px solid rgba(148, 163, 184, 0.3);
+  background: #1e293b;
+  color: #e2e8f0;
+}
+
+.admin-cell:disabled {
+  opacity: 0.55;
+}
+
+.admin-row-actions {
+  white-space: nowrap;
+}

app/icon.svg

@@ -0,0 +1,4 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64">
+  <rect width="64" height="64" rx="14" fill="#93c5fd"/>
+  <path d="M32 5 L36 20 L59 33 L36 38 L35 47 L48 56 L35 52 L32 59 L29 52 L16 56 L29 47 L28 38 L5 33 L28 20 Z" fill="#fff"/>
+</svg>

app/page.tsx

@@ -16,7 +16,7 @@ export default function Home() {
   // Single polling source for the whole shell (v0.9.0): one /api/state loop, snapshot passed
   // down as props so later panes can share it without extra poll loops. applySnapshot (v0.10.0)
   // lets a pane push an action endpoint's full response snapshot in immediately.
-  const { state, loading, error, refresh, applySnapshot } = useGameState(1000);
+  const { state, loading, error, applySnapshot } = useGameState(1000);
 
   // ISS-002 (v0.15.0): the side panels' hover target — shared here so hovering a row in
   // either pane highlights the matching plane/route/airports on the map.
@@ -45,7 +45,7 @@ export default function Home() {
     <div className="app-shell">
       {/* ISS-021 (v0.20.0) — applySnapshot also reaches the left pane: its On board section's
           fly/abandon actions push their response snapshot into the shared state */}
-      <LeftPane state={state} loading={loading} error={error} onRefresh={refresh} applySnapshot={applySnapshot} onHover={setHovered} onError={onError} />
+      <LeftPane state={state} loading={loading} error={error} applySnapshot={applySnapshot} onHover={setHovered} onError={onError} />
       {/* v0.11.0 — the same polled snapshot drives the map's plane markers + route lines;
           ISS-010 (v0.18.0) — applySnapshot lets the airport popup's Relocate row push its
           action response into the shared state, exactly like RightPane does */}

components/AdminPanel.tsx

@@ -0,0 +1,414 @@
+'use client';
+
+import { useCallback, useEffect, useState } from 'react';
+
+// v0.71.0 — content of the Admin modal (opened by the top-bar "Admin" button). Three views:
+// login form (no valid session), a "not an admin" notice, or the generic whole-database CRUD
+// grid behind /api/admin/*. This is a dev tool surface — plain and functional on purpose.
+
+const SESSION_STORAGE_KEY = 'flight.session';
+
+interface Me {
+  username: string;
+  admin: boolean;
+}
+
+interface RowsData {
+  columns: string[];
+  rows: Array<Record<string, unknown>>;
+}
+
+function readSession(): string | null {
+  try {
+    return window.localStorage.getItem(SESSION_STORAGE_KEY);
+  } catch {
+    return null;
+  }
+}
+
+export default function AdminPanel() {
+  const [session, setSession] = useState<string | null>(null);
+  const [me, setMe] = useState<Me | null>(null); // null while checking /api/me on mount
+  const [checking, setChecking] = useState(true);
+
+  // Login form state.
+  const [username, setUsername] = useState('');
+  const [password, setPassword] = useState('');
+  const [loginError, setLoginError] = useState<string | null>(null);
+
+  // Admin grid state.
+  const [tables, setTables] = useState<string[]>([]);
+  const [table, setTable] = useState<string | null>(null);
+  const [rowsData, setRowsData] = useState<RowsData | null>(null);
+  const [edits, setEdits] = useState<Record<string, string>>({}); // key `${rowIdx}:${col}`
+  const [newRow, setNewRow] = useState(false);
+  const [busy, setBusy] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+
+  const authHeaders = useCallback(
+    (s: string) => ({ 'X-Flight-Session': s }),
+    [],
+  );
+
+  // On mount: a stored session decides between the grid and the login form.
+  useEffect(() => {
+    let cancelled = false;
+    const stored = readSession();
+    if (!stored) {
+      setChecking(false);
+      return;
+    }
+    fetch('/api/me', { headers: authHeaders(stored) })
+      .then(async (res) => {
+        if (!res.ok || cancelled) {
+          window.localStorage.removeItem(SESSION_STORAGE_KEY);
+          setSession(null);
+          return;
+        }
+        const body = (await res.json()) as Me;
+        setSession(stored);
+        setMe(body);
+      })
+      .catch(() => {
+        if (!cancelled) {
+          window.localStorage.removeItem(SESSION_STORAGE_KEY);
+          setSession(null);
+        }
+      })
+      .finally(() => {
+        if (!cancelled) setChecking(false);
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, [authHeaders]);
+
+  const loadTables = useCallback(async (s: string) => {
+    const res = await fetch('/api/admin/tables', { headers: authHeaders(s) });
+    if (!res.ok) throw new Error((await res.json().catch(() => null))?.error ?? `HTTP ${res.status}`);
+    setTables(((await res.json()) as Array<{ name: string }>).map((t) => t.name));
+  }, [authHeaders]);
+
+  const loadRows = useCallback(
+    async (s: string, name: string) => {
+      const res = await fetch(`/api/admin/tables/${encodeURIComponent(name)}/rows?limit=500`, { headers: authHeaders(s) });
+      if (!res.ok) throw new Error((await res.json().catch(() => null))?.error ?? `HTTP ${res.status}`);
+      setRowsData(await res.json());
+    },
+    [authHeaders],
+  );
+
+  // Enter the grid once /api/me confirms an admin.
+  useEffect(() => {
+    if (!session || !me?.admin) return;
+    let cancelled = false;
+    (async () => {
+      try {
+        await loadTables(session);
+        if (!cancelled) setBusy(false);
+      } catch (err) {
+        if (!cancelled) setError(err instanceof Error ? err.message : String(err));
+      } finally {
+        if (!cancelled) setBusy(false);
+      }
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [session, me, loadTables]);
+
+  const openTable = async (name: string) => {
+    if (!session) return;
+    setBusy(true);
+    setError(null);
+    try {
+      await loadRows(session, name);
+      setTable(name);
+      setEdits({});
+      setNewRow(false);
+    } catch (err) {
+      setError(err instanceof Error ? err.message : String(err));
+    } finally {
+      setBusy(false);
+    }
+  };
+
+  const refresh = async () => {
+    if (!session || !table) return;
+    setBusy(true);
+    setError(null);
+    try {
+      await loadRows(session, table);
+      setEdits({});
+      setNewRow(false);
+    } catch (err) {
+      setError(err instanceof Error ? err.message : String(err));
+    } finally {
+      setBusy(false);
+    }
+  };
+
+  const login = async () => {
+    if (!username || !password) return;
+    setLoginError(null);
+    const res = await fetch('/api/login', {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ username, password }),
+    });
+    if (!res.ok) {
+      setLoginError((await res.json().catch(() => null))?.error ?? `HTTP ${res.status}`);
+      return;
+    }
+    const body = (await res.json()) as { sessionId: string; user: Me };
+    window.localStorage.setItem(SESSION_STORAGE_KEY, body.sessionId);
+    setSession(body.sessionId);
+    setMe(body.user);
+    setUsername('');
+    setPassword('');
+  };
+
+  const logout = async () => {
+    if (session) await fetch('/api/logout', { method: 'POST', headers: authHeaders(session) }).catch(() => undefined);
+    window.localStorage.removeItem(SESSION_STORAGE_KEY);
+    setSession(null);
+    setMe(null);
+    setTable(null);
+    setRowsData(null);
+    setTables([]);
+    setError(null);
+  };
+
+  if (checking) return <div className="admin-panel">loading…</div>;
+
+  // No valid session → login form.
+  if (!session || !me) {
+    return (
+      <form
+        className="admin-panel admin-login"
+        onSubmit={(e) => {
+          e.preventDefault();
+          void login();
+        }}
+      >
+        <label>
+          Username
+          <input data-testid="admin-username" value={username} onChange={(e) => setUsername(e.target.value)} autoComplete="username" />
+        </label>
+        <label>
+          Password
+          <input
+            data-testid="admin-password"
+            type="password"
+            value={password}
+            onChange={(e) => setPassword(e.target.value)}
+            autoComplete="current-password"
+          />
+        </label>
+        {loginError && (
+          <div data-testid="admin-error" className="admin-error">
+            {loginError}
+          </div>
+        )}
+        <button type="submit" data-testid="admin-login-submit" className="pane-btn">
+          Log in
+        </button>
+      </form>
+    );
+  }
+
+  // Authenticated but not an admin.
+  if (!me.admin) {
+    return (
+      <div className="admin-panel">
+        <p data-testid="admin-not-admin" className="admin-message">
+          Logged in as <strong>{me.username}</strong> — this account is not an admin.
+        </p>
+        <button type="button" data-testid="admin-logout" className="pane-btn" onClick={() => void logout()}>
+          Log out
+        </button>
+      </div>
+    );
+  }
+
+  const columns = rowsData?.columns ?? [];
+  // Displayed grid: server rows plus one trailing empty row when "+ Add row" is active.
+  const rowCount = (rowsData?.rows.length ?? 0) + (newRow ? 1 : 0);
+  const cellValue = (rowIdx: number, col: string): string => {
+    if (col === '__rowid') return String(rowsData?.rows[rowIdx]?.[col] ?? '');
+    const key = `${rowIdx}:${col}`;
+    if (key in edits) return edits[key];
+    const raw = rowsData?.rows[rowIdx]?.[col];
+    return raw === null || raw === undefined ? '' : String(raw);
+  };
+
+  const saveRow = async (rowIdx: number) => {
+    if (!session || !table || !rowsData) return;
+    setBusy(true);
+    setError(null);
+    try {
+      if (newRow && rowIdx === rowsData.rows.length) {
+        // New row → POST the non-empty cells.
+        const values: Record<string, string> = {};
+        for (const col of columns) {
+          if (col === '__rowid') continue;
+          const v = cellValue(rowIdx, col);
+          if (v !== '') values[col] = v;
+        }
+        const res = await fetch(`/api/admin/tables/${encodeURIComponent(table)}/rows`, {
+          method: 'POST',
+          headers: { 'content-type': 'application/json', ...authHeaders(session) },
+          body: JSON.stringify({ values }),
+        });
+        if (!res.ok) throw new Error((await res.json().catch(() => null))?.error ?? `HTTP ${res.status}`);
+      } else {
+        // Existing row → PUT only the changed cells (cleared cell = NULL).
+        const values: Record<string, string | null> = {};
+        for (const col of columns) {
+          if (col === '__rowid') continue;
+          const original = rowsData.rows[rowIdx]?.[col];
+          const origStr = original === null || original === undefined ? '' : String(original);
+          const v = cellValue(rowIdx, col);
+          if (v !== origStr) values[col] = v === '' ? null : v;
+        }
+        if (Object.keys(values).length === 0) return; // nothing changed
+        const res = await fetch(`/api/admin/tables/${encodeURIComponent(table)}/rows`, {
+          method: 'PUT',
+          headers: { 'content-type': 'application/json', ...authHeaders(session) },
+          body: JSON.stringify({ rowid: rowsData.rows[rowIdx]?.__rowid, values }),
+        });
+        if (!res.ok) throw new Error((await res.json().catch(() => null))?.error ?? `HTTP ${res.status}`);
+      }
+      await loadRows(session, table); // re-fetch so the grid shows server state (persistence check)
+      setEdits({});
+      setNewRow(false);
+    } catch (err) {
+      setError(err instanceof Error ? err.message : String(err));
+    } finally {
+      setBusy(false);
+    }
+  };
+
+  const deleteRow = async (rowIdx: number) => {
+    if (!session || !table || !rowsData?.rows[rowIdx]) return;
+    setBusy(true);
+    setError(null);
+    try {
+      const rowid = rowsData.rows[rowIdx]?.__rowid;
+      const res = await fetch(
+        `/api/admin/tables/${encodeURIComponent(table)}/rows?rowid=${encodeURIComponent(String(rowid))}`,
+        { method: 'DELETE', headers: authHeaders(session) },
+      );
+      if (!res.ok) throw new Error((await res.json().catch(() => null))?.error ?? `HTTP ${res.status}`);
+      await loadRows(session, table);
+      setEdits({});
+    } catch (err) {
+      setError(err instanceof Error ? err.message : String(err));
+    } finally {
+      setBusy(false);
+    }
+  };
+
+  return (
+    <div className="admin-panel">
+      <div className="admin-toolbar">
+        <span data-testid="admin-user" className="admin-message">
+          {me.username} (admin)
+        </span>
+        <button type="button" data-testid="admin-logout" className="pane-btn" onClick={() => void logout()}>
+          Log out
+        </button>
+      </div>
+
+      {!table && (
+        <>
+          <p className="admin-message">Pick a table:</p>
+          <div data-testid="admin-tables" className="admin-table-list">
+            {tables.map((t) => (
+              <button key={t} type="button" data-testid={`admin-table-${t}`} className="pane-btn" onClick={() => void openTable(t)}>
+                {t}
+              </button>
+            ))}
+          </div>
+        </>
+      )}
+
+      {table && rowsData && (
+        <>
+          <div className="admin-toolbar">
+            <strong data-testid="admin-current-table">{table}</strong>
+            <button type="button" data-testid="admin-back" className="pane-btn" onClick={() => setTable(null)}>
+              ← tables
+            </button>
+            <button type="button" data-testid="admin-refresh" className="pane-btn" disabled={busy} onClick={() => void refresh()}>
+              Refresh
+            </button>
+            <button
+              type="button"
+              data-testid="admin-add-row"
+              className="pane-btn"
+              disabled={busy || newRow}
+              onClick={() => setNewRow(true)}
+            >
+              + Add row
+            </button>
+          </div>
+
+          <div className="admin-rows-wrap">
+            <table data-testid="admin-rows" className="admin-rows">
+              <thead>
+                <tr>
+                  {columns.map((c) => (
+                    <th key={c}>{c}</th>
+                  ))}
+                  <th />
+                </tr>
+              </thead>
+              <tbody>
+                {Array.from({ length: rowCount }, (_, i) => (
+                  <tr key={i}>
+                    {columns.map((c) => (
+                      <td key={c}>
+                        <input
+                          data-testid={`admin-cell-${i}-${c}`}
+                          className="admin-cell"
+                          value={cellValue(i, c)}
+                          disabled={busy || c === '__rowid'}
+                          onChange={(e) => setEdits((prev) => ({ ...prev, [`${i}:${c}`]: e.target.value }))}
+                        />
+                      </td>
+                    ))}
+                    <td className="admin-row-actions">
+                      <button type="button" data-testid={`admin-save-${i}`} className="pane-btn" disabled={busy} onClick={() => void saveRow(i)}>
+                        Save
+                      </button>{' '}
+                      {!(newRow && i === rowsData.rows.length) && (
+                        <>
+                          <button
+                            type="button"
+                            data-testid={`admin-delete-${i}`}
+                            className="pane-btn"
+                            disabled={busy}
+                            onClick={() => void deleteRow(i)}
+                          >
+                            Delete
+                          </button>{' '}
+                        </>
+                      )}
+                    </td>
+                  </tr>
+                ))}
+              </tbody>
+            </table>
+          </div>
+        </>
+      )}
+
+      {error && (
+        <div data-testid="admin-error" className="admin-error">
+          {error}
+        </div>
+      )}
+    </div>
+  );
+}

components/LeftPane.tsx

@@ -1,12 +1,11 @@
 'use client';
 
-import { useCallback, useEffect, useRef, useState, type ChangeEvent } from 'react';
+import { useEffect, useRef, useState } from 'react';
 import type { GeoJsonFeatureCollection } from '@/lib/airports';
 import type { PlaneState, StateSnapshot } from '@/lib/game/state';
 import { PLANE_TYPES } from '@/lib/game/catalog';
 import { abandonPenalty } from '@/lib/game/penalty';
-import { formatCash, formatDeadlineRelative, formatFuel, formatSimClock, formatSpecialLabel } from '@/lib/format';
+import { formatCash, formatDeadlineRelative, formatFuel, formatKm, formatSimClock, formatSpecialLabel } from '@/lib/format';
-import { TIME_SCALES, scaleToSlider, sliderToScale } from '@/lib/timeScale';
 import { useGameAction } from '@/lib/useGameAction';
 import { useSimClock } from '@/lib/useSimClock';
 import { cargoWeightFor } from './RightPane';
@@ -16,8 +15,6 @@ interface LeftPaneProps {
   state: StateSnapshot | null;
   loading: boolean;
   error: string | null;
-  // The shell's single-poll refresh — called after a sim-control POST so the pane updates immediately.
-  onRefresh: () => void;
   // ISS-021 (v0.20.0): push the full snapshot returned by an action endpoint into the shared shell
   // state — needed now that the per-plane cargo rows' fly/abandon actions live in this pane.
   applySnapshot: (snapshot: StateSnapshot) => void;
@@ -27,12 +24,6 @@ interface LeftPaneProps {
   onError?: (message: string) => void;
 }
 
-// Discrete ladder slider (v0.9.2, values reworked in v0.14.0): position t ∈ [0,1] → nearest
-// step of the ladder 1×/2×/5×/10×/25×/50×/100×/250×/500×/1000× — each of the 10 positions
-// roughly doubles the speed.
-const SCALE_SLIDER_STEP = 1 / (TIME_SCALES.length - 1); // one ladder step per keyboard-arrow step
-const SCALE_COMMIT_DEBOUNCE_MS = 250;
-
 // Flying planes show their current leg from the snapshot's dest fields (v0.12.0).
 function planeLocation(p: PlaneState): string {
   if (p.status === 'flying' && p.destName) return `${p.locationName} → ${p.destName}`;
@@ -47,51 +38,7 @@ function loadoutFor(state: StateSnapshot, p: PlaneState): string {
   return `${(used / 1000).toFixed(1)}t / ${(maxPayloadKg / 1000).toFixed(1)}t`;
 }
 
-// ISS-001 — an optimistic slider value is cleared exactly when a rendered snapshot CONFIRMS it
+export default function LeftPane({ state, loading, error, applySnapshot, onHover, onError }: LeftPaneProps) {
-// (server scale === pending), never earlier: clearing at commit time would snap the pointer back
-// to the stale scale for one poll cycle, then jump forward again on the confirming snapshot.
-export function pendingScaleConfirmed(pendingScale: number | null, serverTimeScale: number): boolean {
-  return pendingScale !== null && serverTimeScale === pendingScale;
-}
-
-// ISS-008 fix (v0.17.0, CI runs #44/#47): bounded retry for POST /api/sim — a commit dropped by
-// the runner's flaky uplink used to leave the UI optimistic while the server kept the old scale.
-// Up to maxAttempts tries with delayMs between them; stops early once superseded() flips (a newer
-// intent arrived and the caller's loop sends it instead). post is idempotent set-semantics, so
-// re-sending a body whose response was lost cannot double-apply. Pure core — unit-tested in node.
-export const SIM_POST_MAX_ATTEMPTS = 3;
-export const SIM_POST_RETRY_DELAY_MS = 500;
-
-export type SimPostRetryResult =
-  | { ok: true }
-  | { ok: false; reason: 'exhausted'; error: unknown }
-  | { ok: false; reason: 'superseded' };
-
-export async function retrySimPost(
-  post: () => Promise<void>,
-  superseded: () => boolean,
-  sleep: (ms: number) => Promise<void> = (ms) => new Promise((r) => setTimeout(r, ms)),
-  maxAttempts: number = SIM_POST_MAX_ATTEMPTS,
-  delayMs: number = SIM_POST_RETRY_DELAY_MS,
-): Promise<SimPostRetryResult> {
-  let lastError: unknown;
-  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-    if (superseded()) return { ok: false, reason: 'superseded' }; // a newer intent takes over — don't even send this body
-    try {
-      await post();
-      return { ok: true };
-    } catch (err) {
-      lastError = err;
-      if (superseded()) return { ok: false, reason: 'superseded' }; // a newer intent arrived during the attempt — don't wait out the backoff
-      if (attempt < maxAttempts) await sleep(delayMs);
-    }
-  }
-  return { ok: false, reason: 'exhausted', error: lastError };
-}
-
-export default function LeftPane({ state, loading, error, onRefresh, applySnapshot, onHover, onError }: LeftPaneProps) {
-  const [busy, setBusy] = useState(false);
-
   // ISS-021 (v0.20.0): shared action runner for the per-plane cargo/queue actions (moved here from RightPane).
   const { runAction, busy: actionsBusy, actionError } = useGameAction(state, applySnapshot, onError);
 
@@ -123,73 +70,6 @@ export default function LeftPane({ state, loading, error, onRefresh, applySnapsh
     void airportsPromiseRef.current.then(setAirportOptions).catch(() => {});
   }, []);
 
-  // POST /api/sim (retried up to SIM_POST_MAX_ATTEMPTS× on failure — CI runs #44/#47), then
-  // refetch the full snapshot immediately so the pane reflects the new controls without waiting
-  // for the next poll tick. After the final attempt fails keep the stale UI and surface an error
-  // toast (the running poll retries on its own). A commit that lands while another POST is in
-  // flight — including mid-retry — is held in a single slot (last intent wins) and supersedes
-  // the in-flight body, so every user intent reaches the server (the [1,1000] clamp stays as
-  // backstop). The gate is a REF, not React state: closures never see a stale "busy" value,
-  // which used to let a flush re-queue instead of send and silently drop a commit.
-  const queuedRef = useRef<{ timeScale?: number; paused?: boolean } | null>(null);
-  const busyRef = useRef(false);
-
-  type SimControlsOutcome = 'sent' | 'queued' | 'failed';
-
-  // 'sent': this body reached the server (a confirming snapshot follows via onRefresh).
-  // 'queued': an in-flight call holds it — its flush will send it.
-  // 'failed': the POST for this body never succeeded; callers drop optimistic values only then.
-  const applySimControls = useCallback(
-    async (body: { timeScale?: number; paused?: boolean }): Promise<SimControlsOutcome> => {
-      if (busyRef.current) {
-        queuedRef.current = body; // last intent wins — the in-flight call's flush sends it
-        return 'queued';
-      }
-      busyRef.current = true;
-      setBusy(true);
-      let sentOwn = false;
-      try {
-        let current: { timeScale?: number; paused?: boolean } | null = body;
-        while (current !== null) {
-          const target = current; // stable across this retry round
-          const result = await retrySimPost(
-            async () => {
-              const res = await fetch('/api/sim', {
-                method: 'POST',
-                headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify(target),
-                cache: 'no-store',
-              });
-              if (!res.ok) throw new Error(`POST /api/sim → HTTP ${res.status}`);
-            },
-            () => queuedRef.current !== null, // a newer intent supersedes the in-flight body mid-retry
-          );
-          if (result.ok) {
-            onRefresh();
-            if (target === body) sentOwn = true; // object identity — queued bodies are fresh literals
-          } else if (result.reason === 'exhausted') {
-            throw result.error; // only after the final attempt fails → error toast below
-          }
-          current = queuedRef.current; // pick up anything that arrived while we were in flight
-          queuedRef.current = null;
-        }
-      } catch (err) {
-        console.error('failed to apply sim controls', err);
-        // ISS-008: surface the failure as an error toast too — previously console-only.
-        onError?.(`Failed to update time controls (${err instanceof Error ? err.message : String(err)})`);
-        queuedRef.current = null; // don't replay a stale intent after a failed round-trip
-      } finally {
-        busyRef.current = false;
-        setBusy(false);
-      }
-      return sentOwn ? 'sent' : 'failed';
-    },
-    [onRefresh, onError],
-  );
-
-  const paused = state?.simState.paused ?? false;
-  const timeScale = state?.simState.timeScale ?? 1;
-
   // Snapshot clock — feeds the deadline/penalty previews in the per-plane cargo rows.
   const clockMs = state?.simState.clockMs ?? 0;
 
@@ -208,69 +88,6 @@ export default function LeftPane({ state, loading, error, onRefresh, applySnapsh
     relocatePlane?.status === 'flying' && relocateDest !== null &&
     (relocatePlane.destIcao === relocateDest.icao || relocatePlane.queue.includes(relocateDest.icao));
 
-  // Slider commit (v0.9.1): the displayed value follows the drag optimistically via
-  // pendingScale; POST /api/sim fires after a 250 ms debounce, or immediately when the
-  // user releases the slider (browsers fire a native 'change' on release). The server's
-  // [1,1000] clamp stays as the backstop.
-  const [pendingScale, setPendingScaleState] = useState<number | null>(null);
-  const pendingRef = useRef<number | null>(null);
-  const commitTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
-
-  const setPending = useCallback((s: number | null) => {
-    pendingRef.current = s;
-    setPendingScaleState(s);
-  }, []);
-
-  const commitNow = useCallback(() => {
-    if (commitTimerRef.current !== null) {
-      clearTimeout(commitTimerRef.current);
-      commitTimerRef.current = null;
-    }
-    const s = pendingRef.current;
-    if (s === null) return;
-    // ISS-001: keep the chosen value on screen until a snapshot CONFIRMS it — clearing at
-    // commit time would snap the slider back to the stale scale for one poll cycle, then jump
-    // forward again when the confirming snapshot lands. 'queued' also keeps it (the in-flight
-    // call flushes it); only a genuine failure drops it so the display falls back to truth.
-    void applySimControls({ timeScale: s }).then((outcome) => {
-      if (outcome === 'failed') setPending(null);
-    });
-  }, [applySimControls, setPending]);
-
-  // Confirmation: once a rendered snapshot carries the pending scale AND no commit is in
-  // flight, the optimistic value has been superseded by server truth — clear it (display is
-  // unchanged either way). The busy guard matters: while a commit POST is still out, an OLD
-  // snapshot that happens to match the pending value is coincidence, not confirmation (e.g. a
-  // quick drag back to the previous scale must not be swallowed before its own commit fires).
-  useEffect(() => {
-    if (!busy && state && pendingScaleConfirmed(pendingScale, state.simState.timeScale)) setPending(null);
-  }, [state, pendingScale, busy, setPending]);
-
-  const onSliderInput = useCallback(
-    (e: ChangeEvent<HTMLInputElement>) => {
-      setPending(sliderToScale(Number(e.target.value)));
-      if (commitTimerRef.current !== null) clearTimeout(commitTimerRef.current);
-      commitTimerRef.current = setTimeout(commitNow, SCALE_COMMIT_DEBOUNCE_MS);
-    },
-    [commitNow, setPending],
-  );
-
-  const sliderRef = useRef<HTMLInputElement>(null);
-  useEffect(() => {
-    const el = sliderRef.current;
-    if (!el) return;
-    el.addEventListener('change', commitNow); // flush on pointer-up / keyboard release
-    return () => el.removeEventListener('change', commitNow);
-  }, [commitNow]);
-
-  // Drop any pending debounce timer on unmount.
-  useEffect(
-    () => () => {
-      if (commitTimerRef.current !== null) clearTimeout(commitTimerRef.current);
-    },
-    [],
-  );
-
   // ISS-008: browser-notification opt-in. Starts null (SSR-safe — the real permission is read
   // in an effect after hydration, so server and client render identically) and follows the
   // result of Notification.requestPermission(). 'unsupported' = no Notification API at all.
@@ -290,13 +107,11 @@ export default function LeftPane({ state, loading, error, onRefresh, applySnapsh
           ? 'Notifications unavailable'
           : 'Enable notifications';
 
-  const displayedScale = pendingScale ?? timeScale;
+  // ISS-007: the clock ticks client-side between polls at the fixed world rate, re-syncing to
-
+  // server truth on every snapshot (and freezing while nothing is happening). Only the sim-clock
-  // ISS-007: the clock ticks client-side between polls, re-syncing to server truth on every
+  // paragraph uses this — deadline and penalty previews stay snapshot-based (deterministic against
-  // snapshot. Fed with EFFECTIVE controls so a scale drag / pause click takes effect immediately,
+  // the server clock).
-  // not when the confirming snapshot lands. Only the sim-clock paragraph uses this — deadline and
+  const simClockMs = useSimClock(state);
-  // penalty previews stay snapshot-based (deterministic against the server clock).
-  const simClockMs = useSimClock(state, { timeScale: displayedScale, paused });
 
   return (
     <aside data-testid="left-pane" className="pane left-pane">
@@ -441,6 +256,8 @@ export default function LeftPane({ state, loading, error, onRefresh, applySnapsh
                               <span data-testid={`onboard-route-${pkg.id}`} className="contract-route">
                                 {pkg.originIcao} → {pkg.destIcao}
                               </span>
+                              {/* v0.48.0 (ISS-095): leg distance after the route, e.g. "EGCC → GMME 554km". */}
+                              <span data-testid={`onboard-distance-${pkg.id}`}>{formatKm(pkg.distanceKm)}</span>
                               {/* v0.37.0 (ISS-073): special-status badge — rendered only when the package has one. */}
                               {pkg.special && (
                                 <span data-testid={`package-special-${pkg.id}`} className="special-badge">
@@ -561,32 +378,9 @@ export default function LeftPane({ state, loading, error, onRefresh, applySnapsh
 
           <section className="pane-section">
             <h3 className="pane-heading">Time</h3>
-            <p data-testid="sim-clock" className="sim-clock">
+            {/* ISS-117 (v0.52.0): no player-facing time controls — the world runs at a fixed rate;
-              {simClockMs !== null && formatSimClock(simClockMs)}
+                only the clock display remains here. */}
-              {paused ? ' (paused)' : ''}
+            <p data-testid="sim-clock" className="sim-clock">{simClockMs !== null && formatSimClock(simClockMs)}</p>
-            </p>
-            <div className="time-controls">
-              <button
-                type="button"
-                data-testid="pause-toggle"
-                disabled={busy}
-                onClick={() => void applySimControls({ paused: !paused })}
-              >
-                {paused ? 'Resume' : 'Pause'}
-              </button>
-              <input
-                ref={sliderRef}
-                type="range"
-                data-testid="time-scale-slider"
-                aria-label="Time scale"
-                min={0}
-                max={1}
-                step={SCALE_SLIDER_STEP}
-                value={scaleToSlider(displayedScale)}
-                onChange={onSliderInput}
-              />
-              <span data-testid="time-scale-value">{displayedScale}×</span>
-            </div>
             {/* ISS-008: explicit opt-in for browser notifications (fired when the window is hidden). */}
             <button
               type="button"

components/Map.tsx

@@ -11,12 +11,17 @@ import type { HoverTarget } from './hoverTypes';
 import { hoverRouteGeoJson, hoverTraceGeoJson, planesGeoJson, queuedRoutesGeoJson, routesGeoJson, type AirportCoord, type PlaneFeatureProps } from '../lib/mapData';
 import { weatherFor } from '../lib/weather';
 import { approxLocalTime } from '../lib/localTime';
+import Modal from './Modal';
+import AdminPanel from './AdminPanel';
 
-const EUROPE_CENTER: [number, number] = [10, 52];
+// v0.70.0 default view: null island [0,0] at zoom 2 — the world is 2048 px wide there and the
-const INITIAL_ZOOM = 4;
+// Africa+Europe bounding box (lat −35..+71, lon −18..+52) spans ~800 px vertically in Web Mercator,
+// so both continents are fully visible on a typical desktop map pane.
+const WORLD_CENTER: [number, number] = [0, 0];
+const INITIAL_ZOOM = 2;
 // Flat 2D view only. Max zoom ≈ ~100 km across a typical desktop viewport width at
 // European latitudes (~47 m/px at z11, 52°N); street-level zoom has no gameplay value.
-export const MIN_ZOOM = 3;
+export const MIN_ZOOM = 0; // v0.70.0: fully zoomed out the whole earth (512 px world) fits any viewport
 export const MAX_ZOOM = 11;
 
 const AIRPORTS_SOURCE_ID = 'airports';
@@ -32,6 +37,8 @@ const ROUTES_LEGS_LAYER_ID = 'routes-legs';
 // (dest → queue[0] → …) as their own source + layer, drawn under everything else dynamic.
 const QUEUE_ROUTES_SOURCE_ID = 'queue-routes';
 const QUEUE_ROUTES_LAYER_ID = 'queue-routes';
+// ISS-098 (v0.50.0): amber/gold — planned legs read as "queued", visible on light and dark tiles alike.
+export const QUEUE_ROUTE_LINE_COLOR = '#d4a017';
 // ISS-002 (v0.15.0): top-most hover-highlight layers, added after the base layers so they
 // render above them. Each starts filtered to match nothing; applyHoverRef drives the filters.
 const PLANES_HIGHLIGHT_LAYER_ID = 'planes-highlight';
@@ -84,6 +91,9 @@ export default function FlightMap({ state, hovered, applySnapshot }: MapProps) {
   const airportsIndexRef = useRef<Map<string, AirportCoord> | null>(null);
   const [airportCount, setAirportCount] = useState<number | null>(null);
   const [styleId, setStyleId] = useState<string>(DEFAULT_STYLE_ID);
+  // v0.71.0: the Admin modal (top-bar button) — unmounted while closed so it re-checks the
+  // stored session on every open.
+  const [adminOpen, setAdminOpen] = useState(false);
 
   // Push the latest planes/routes GeoJSON into whatever sources currently exist.
   // No-op until the map (and for routes: the airport index) is ready — the mount
@@ -94,7 +104,9 @@ export default function FlightMap({ state, hovered, applySnapshot }: MapProps) {
     const st = stateRef.current;
     if (!map || !st) return;
     const planesSource = map.getSource(PLANES_SOURCE_ID) as maplibregl.GeoJSONSource | undefined;
-    if (planesSource) void planesSource.setData(planesGeoJson(st)); // v6 API (setGeoData was removed)
+    // ISS-124 (v0.58.0): the airport index unwraps crossing markers — empty until it loads, so
+    // planes draw at their wrapped position in the meantime (same as pre-v0.58.0).
+    if (planesSource) void planesSource.setData(planesGeoJson(st, airportsIndexRef.current ?? new Map())); // v6 API (setGeoData was removed)
     const routesSource = map.getSource(ROUTES_SOURCE_ID) as maplibregl.GeoJSONSource | undefined;
     if (routesSource && airportsIndexRef.current) {
       void routesSource.setData(routesGeoJson(st, airportsIndexRef.current));
@@ -214,7 +226,7 @@ export default function FlightMap({ state, hovered, applySnapshot }: MapProps) {
       const map = new maplibregl.Map({
         container: containerRef.current,
         style: styleUrlFor(initialId, available), // local pack or remote OFM fallback
-        center: EUROPE_CENTER,
+        center: WORLD_CENTER,
         zoom: INITIAL_ZOOM,
         minZoom: MIN_ZOOM,
         maxZoom: MAX_ZOOM,
@@ -231,21 +243,22 @@ export default function FlightMap({ state, hovered, applySnapshot }: MapProps) {
         // deterministic generated weather — no gameplay effects per PLAN.md.
         const w = weatherFor(p.icao);
         const localTime = approxLocalTime(p.lon, Date.now());
-        // ISS-010 (v0.18.0): Relocate row — grounded planes from the latest snapshot can be
+        // ISS-010 (v0.18.0): Relocate row — every plane from the latest snapshot can be sent to
-        // repositioned to this airport via POST /api/planes/{id}/fly (pure repositioning).
+        // this airport: grounded ones fly immediately (POST /api/planes/{id}/fly), flying/repairing
+        // ones get the leg appended to their queue (POST /api/planes/{id}/queue, ISS-096 v0.49.0).
         const st = stateRef.current;
-        const groundedPlanes = st ? st.planes.filter((pl) => pl.status === 'available') : [];
+        const planes = st ? st.planes : [];
         const planeLabel = (model: string) => st?.catalog.find((c) => c.model === model)?.label ?? model;
         const relocateHtml =
-          groundedPlanes.length > 0
+          planes.length > 0
             ? `<select data-testid="airport-popup-plane" aria-label="Plane to relocate here">` +
               `<option value="">Select a plane\u2026</option>` +
-              groundedPlanes.map(
+              planes.map(
                 (pl) =>
                   `<option value="${escapeHtml(pl.id)}">${escapeHtml(planeLabel(pl.model))} \u2014 ${escapeHtml(pl.locationIcao)}</option>`,
               ).join('') +
               `</select><button type="button" data-testid="airport-popup-relocate" disabled>Relocate here</button>`
-            : `<span data-testid="airport-popup-no-planes">No grounded planes to relocate.</span>`;
+            : `<span data-testid="airport-popup-no-planes">No planes to relocate.</span>`;
         const popup = new maplibregl.Popup({ offset: 10 })
           .setLngLat(f.geometry.coordinates as [number, number])
           .setHTML(
@@ -263,7 +276,7 @@ export default function FlightMap({ state, hovered, applySnapshot }: MapProps) {
         const el = popup.getElement();
         const select = el?.querySelector<HTMLSelectElement>('[data-testid="airport-popup-plane"]');
         const button = el?.querySelector<HTMLButtonElement>('[data-testid="airport-popup-relocate"]');
-        // The status span is always in the popup HTML (even with no grounded planes), so it
+        // The status span is always in the popup HTML (even with no planes), so it
         // exists whenever the select/button do.
         const statusEl = el?.querySelector<HTMLElement>('[data-testid="airport-popup-relocate-status"]');
         if (select && button && statusEl) {
@@ -276,7 +289,11 @@ export default function FlightMap({ state, hovered, applySnapshot }: MapProps) {
             button.disabled = true;
             statusEl.textContent = 'Relocating\u2026';
             try {
-              const res = await fetch(`/api/planes/${planeId}/fly`, {
+              // ISS-096 (v0.49.0): endpoint follows the SELECTED plane's current status — grounded
+              // planes fly now, flying/repairing ones get the leg queued for after landing.
+              const planeStatus = stateRef.current?.planes.find((pl) => pl.id === planeId)?.status ?? 'available';
+              const action = planeStatus === 'available' ? 'fly' : 'queue';
+              const res = await fetch(`/api/planes/${planeId}/${action}`, {
                 method: 'POST',
                 headers: { 'Content-Type': 'application/json' },
                 body: JSON.stringify({ destIcao: p.icao }),
@@ -285,7 +302,7 @@ export default function FlightMap({ state, hovered, applySnapshot }: MapProps) {
               const data = (await res.json()) as StateSnapshot & { error?: string };
               if (!res.ok) throw new Error(data.error ?? `HTTP ${res.status}`);
               applySnapshotRef.current(data); // shared shell state updates immediately, like the panes' runAction
-              statusEl.textContent = 'Relocation started.';
+              statusEl.textContent = action === 'fly' ? 'Relocation started.' : 'Added to queue.';
             } catch (err) {
               statusEl.textContent = err instanceof Error ? err.message : String(err);
               button.disabled = false; // allow retry / picking another plane
@@ -351,7 +368,7 @@ export default function FlightMap({ state, hovered, applySnapshot }: MapProps) {
             source: AIRPORTS_SOURCE_ID,
             paint: {
               'circle-radius': 5, // ISS-010 (v0.18.0): bigger — the r=3 dots were hard to click
-              'circle-color': '#e11d48',
+              'circle-color': '#f43f5e', // ISS-118 (v0.60.0): rose-500 — old #e11d48 (rose-600) was tuned for light tiles; 1.7:1 on Fiord's dark slate land
               'circle-stroke-width': 1.5,
               'circle-stroke-color': '#ffffff',
             },
@@ -377,8 +394,8 @@ export default function FlightMap({ state, hovered, applySnapshot }: MapProps) {
           });
         }
         // ISS-043 (v0.26.0): dotted queue line — added after routes-legs but BEFORE the hover
-        // layers so a hovered trace still draws on top of it. Muted slate + fine dots reads as
+        // layers so a hovered trace still draws on top of it. Amber/gold + fine dots reads as
-        // "planned/future", distinct from the solid amber active leg and the [2,2] yellow hover dash.
+        // "planned/future", distinct from the solid bright-amber active leg and the [2,2] yellow hover dash.
         if (!map.getSource(QUEUE_ROUTES_SOURCE_ID)) {
           map.addSource(QUEUE_ROUTES_SOURCE_ID, {
             type: 'geojson',
@@ -391,14 +408,15 @@ export default function FlightMap({ state, hovered, applySnapshot }: MapProps) {
             type: 'line',
             source: QUEUE_ROUTES_SOURCE_ID,
             paint: {
-              'line-color': '#64748b', // muted slate — planned legs, not actively flying
+              'line-color': QUEUE_ROUTE_LINE_COLOR, // amber/gold — planned legs, not actively flying (ISS-098)
               'line-width': 3,
               'line-dasharray': [0.1, 1.5], // dotted — distinct from solid legs and the [2,2] hover dash
             },
           });
         }
         if (!map.getSource(PLANES_SOURCE_ID)) {
-          map.addSource(PLANES_SOURCE_ID, { type: 'geojson', data: planesGeoJson(stateRef.current) });
+          // ISS-124 (v0.58.0): same airport-index unwrap as applyDynamic above.
+          map.addSource(PLANES_SOURCE_ID, { type: 'geojson', data: planesGeoJson(stateRef.current, airportsIndexRef.current ?? new Map()) });
         }
         if (!map.getLayer(PLANES_GROUNDED_LAYER_ID)) {
           map.addLayer({
@@ -452,7 +470,7 @@ export default function FlightMap({ state, hovered, applySnapshot }: MapProps) {
             source: ROUTES_SOURCE_ID,
             filter: ['==', ['get', 'planeId'], ''],
             paint: {
-              'line-color': '#ef4444', // red — distinct from the amber routes-legs line
+              'line-color': '#f87171', // ISS-118 (v0.60.0): red-400 — old #ef4444 sat at 2.1:1 on Fiord's dark slate; brighter so the hover emphasis reads, still distinct from the amber routes-legs line
               'line-width': 6,
             },
           });
@@ -564,10 +582,17 @@ export default function FlightMap({ state, hovered, applySnapshot }: MapProps) {
           ))}
         </select>
         <span data-testid="airport-count">
-          {airportCount === null ? 'loading airports…' : `${airportCount} EU airports`}
+          {airportCount === null ? 'loading airports…' : `${airportCount} world airports`}
         </span>
+        {/* v0.71.0: admin panel entry point — right side of the top bar, opens a modal (no URL). */}
+        <button type="button" data-testid="admin-btn" className="pane-btn" onClick={() => setAdminOpen(true)}>
+          Admin
+        </button>
       </header>
       <div ref={containerRef} data-testid="map" className="map-container" />
+      <Modal open={adminOpen} onClose={() => setAdminOpen(false)} title="Admin">
+        <AdminPanel />
+      </Modal>
     </div>
   );
 }

components/Modal.tsx

@@ -0,0 +1,33 @@
+'use client';
+
+import { useEffect, type ReactNode } from 'react';
+
+// v0.71.0 — reusable modal dialog: fixed overlay (z-index 60, above the z-50 toast stack),
+// centered panel, closes on Escape and backdrop click (inner-panel clicks do not close it).
+// Foundation for future modal-based features; keep this generic.
+export default function Modal({ open, onClose, title, children }: { open: boolean; onClose: () => void; title: string; children: ReactNode }) {
+  useEffect(() => {
+    if (!open) return;
+    const onKey = (e: KeyboardEvent) => {
+      if (e.key === 'Escape') onClose();
+    };
+    window.addEventListener('keydown', onKey);
+    return () => window.removeEventListener('keydown', onKey);
+  }, [open, onClose]);
+
+  if (!open) return null;
+
+  return (
+    <div className="modal-overlay" onClick={onClose}>
+      <div className="modal-panel" role="dialog" aria-modal="true" aria-label={title} onClick={(e) => e.stopPropagation()}>
+        <header className="modal-header">
+          <h2>{title}</h2>
+          <button type="button" data-testid="modal-close" className="pane-btn" onClick={onClose} aria-label="Close dialog">
+            ×
+          </button>
+        </header>
+        {children}
+      </div>
+    </div>
+  );
+}

components/RightPane.tsx

@@ -3,8 +3,8 @@
 import { useState } from 'react';
 import type { PackageState, PlaneState, StateSnapshot } from '@/lib/game/state';
 import { MAX_PLANE_DISCOUNT, PLANE_DISCOUNT_PER_REP, PLANE_TYPES, repRate, SELL_FRACTION } from '@/lib/game/catalog';
-import { maxRangeKm } from '@/lib/sim/movement';
+import { guaranteedRangeKm } from '@/lib/sim/movement';
-import { formatCargo, formatCash, formatDeadlineRelative, formatSpecialLabel } from '@/lib/format';
+import { formatCargo, formatCash, formatDeadlineRelative, formatKm, formatSpecialLabel } from '@/lib/format';
 import { useGameAction } from '@/lib/useGameAction';
 import type { HoverTarget } from './hoverTypes';
 
@@ -221,23 +221,17 @@ export default function RightPane({ state, loading, applySnapshot, onHover, onEr
                         Load
                       </button>
                     )}
-                    {/* ISS-047 part B (v0.29.0): dismiss the job — it leaves the market permanently, no penalty. */}
-                    <button
-                      type="button"
-                      data-testid={`ignore-${pkg.id}`}
-                      className="pane-btn"
-                      disabled={busy}
-                      onClick={() => void runAction(`/api/packages/${pkg.id}/ignore`)}
-                    >
-                      Ignore
-                    </button>
                   </div>
                   <div className="contract-sub">
                     <span data-testid={`open-package-reward-${pkg.id}`}>{formatCash(pkg.reward)}</span>
+                    {/* v0.48.0 (ISS-095): leg distance after the reward, e.g. "€37,408.00 215km". */}
+                    <span data-testid={`open-package-distance-${pkg.id}`}>{formatKm(pkg.distanceKm)}</span>
                     {/* ISS-066 (v0.35.0): cargo shows as type + tonnage ("Mail 10.0t"), not "type × count". */}
                     <span data-testid={`open-package-cargo-${pkg.id}`}>{formatCargo(pkg.cargoType, pkg.weightKg)}</span>
+                    {/* v0.65.0: open jobs expire on the WALL clock — live countdown from expiresRealMs;
+                        re-renders every poll tick (~1 s) keep it current without a timer. */}
                     <span data-testid={`open-package-deadline-${pkg.id}`}>
-                      {formatDeadlineRelative(pkg.deadlineSimTime, clockMs)}
+                      {formatDeadlineRelative(pkg.expiresRealMs ?? pkg.deadlineSimTime, Date.now())}
                     </span>
                   </div>
                 </li>
@@ -320,7 +314,8 @@ export default function RightPane({ state, loading, applySnapshot, onHover, onEr
         {/* ISS-035 (v0.23.0): the Refuel-to-full row moved to the left pane's "Refuel" section, next to Relocate. */}
 
         {/* v0.28.0 (ISS-047): tech-spec panel per catalog type — progression order (price ascending).
-            All values come from the snapshot's catalog; max range is the weighted-model closed form. */}
+            All values come from the snapshot's catalog; max range is the GUARANTEED full-tank range —
+            worst-case headwind, so any leg within it is flyable in all weather (v0.51.0, ISS-099). */}
         {[...catalog].sort((a, b) => a.price - b.price).map((e) => (
           <div key={e.model} className="plane-type-card" data-testid={`plane-type-${e.model}`}>
             <h4 className="plane-type-name">{e.label}</h4>
@@ -351,7 +346,7 @@ export default function RightPane({ state, loading, applySnapshot, onHover, onEr
             <div className="stat-row">
               <span>Max range</span>
               <strong data-testid={`plane-type-range-${e.model}`}>
-                {Math.round(maxRangeKm(e.burnPerKm, e.emptyWeightKg, e.maxFuel))} km
+                {Math.round(guaranteedRangeKm(e.burnPerKm, e.emptyWeightKg, e.maxFuel))} km
               </strong>
             </div>
           </div>

components/left-pane.test.ts

@@ -1,91 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { pendingScaleConfirmed, retrySimPost, SIM_POST_MAX_ATTEMPTS, SIM_POST_RETRY_DELAY_MS } from './LeftPane';
-
-// ISS-001 — the optimistic slider value is cleared exactly when a rendered snapshot confirms
-// it (server scale === pending), never earlier. Clearing at commit time would snap the pointer
-// back to the stale scale for one poll cycle, then jump forward again on the confirming snapshot.
-
-describe('pendingScaleConfirmed', () => {
-  it('is false while there is no pending value', () => {
-    expect(pendingScaleConfirmed(null, 1)).toBe(false);
-    expect(pendingScaleConfirmed(null, 64)).toBe(false);
-  });
-
-  it('stays false while the server still reports the stale scale (the ISS-001 window)', () => {
-    // User committed 64×; the last rendered snapshot is still at 1× → must NOT clear yet.
-    expect(pendingScaleConfirmed(64, 1)).toBe(false);
-    expect(pendingScaleConfirmed(32, 8)).toBe(false);
-  });
-
-  it('becomes true exactly when a snapshot carries the pending scale', () => {
-    expect(pendingScaleConfirmed(64, 64)).toBe(true);
-    expect(pendingScaleConfirmed(1, 1)).toBe(true); // committing the current value confirms immediately
-  });
-});
-
-// ISS-008 fix (CI runs #44/#47): a dropped POST /api/sim must be retried before surfacing the
-// error — up to SIM_POST_MAX_ATTEMPTS tries with SIM_POST_RETRY_DELAY_MS between them, and a newer
-// intent supersedes the in-flight body instead of waiting out its retries.
-
-describe('retrySimPost', () => {
-  it('pins the retry budget: 3 attempts total, ~500 ms backoff', () => {
-    expect(SIM_POST_MAX_ATTEMPTS).toBe(3);
-    expect(SIM_POST_RETRY_DELAY_MS).toBe(500);
-  });
-
-  it('succeeds on the first attempt without sleeping or retrying', async () => {
-    const post = vi.fn(async () => {});
-    const sleep = vi.fn(async () => {});
-    await expect(retrySimPost(post, () => false, sleep)).resolves.toEqual({ ok: true });
-    expect(post).toHaveBeenCalledTimes(1);
-    expect(sleep).not.toHaveBeenCalled();
-  });
-
-  it('retries with the backoff delay and succeeds on a later attempt', async () => {
-    let calls = 0;
-    const post = vi.fn(async () => {
-      if (++calls < 3) throw new Error('dropped');
-    });
-    const sleep = vi.fn(async () => {});
-    await expect(retrySimPost(post, () => false, sleep)).resolves.toEqual({ ok: true });
-    expect(post).toHaveBeenCalledTimes(3);
-    expect(sleep).toHaveBeenCalledTimes(2); // one backoff between each pair of attempts
-    expect(sleep).toHaveBeenCalledWith(SIM_POST_RETRY_DELAY_MS);
-  });
-
-  it('gives up after the final attempt with the last error (no trailing sleep)', async () => {
-    const err = new Error('down');
-    const post = vi.fn(async () => {
-      throw err;
-    });
-    const sleep = vi.fn(async () => {});
-    const result = await retrySimPost(post, () => false, sleep);
-    expect(result.ok).toBe(false);
-    if (!result.ok) {
-      expect(result.reason).toBe('exhausted');
-      if (result.reason === 'exhausted') expect(result.error).toBe(err); // the LAST attempt's error
-    }
-    expect(post).toHaveBeenCalledTimes(SIM_POST_MAX_ATTEMPTS);
-    expect(sleep).toHaveBeenCalledTimes(SIM_POST_MAX_ATTEMPTS - 1);
-  });
-
-  it('stops retrying once a newer intent supersedes the in-flight body (no further attempts or sleeps)', async () => {
-    let calls = 0;
-    const post = vi.fn(async () => {
-      calls++; // flip "superseded" right after the first failure, like a queued commitNow would
-      throw new Error('dropped');
-    });
-    const sleep = vi.fn(async () => {});
-    await expect(retrySimPost(post, () => calls >= 1, sleep)).resolves.toEqual({ ok: false, reason: 'superseded' });
-    expect(post).toHaveBeenCalledTimes(1); // the caller's loop sends the newer body instead
-    expect(sleep).not.toHaveBeenCalled(); // supersede is checked before the backoff sleep
-  });
-
-  it('never even sends a body that is already superseded', async () => {
-    const post = vi.fn(async () => {});
-    const sleep = vi.fn(async () => {});
-    await expect(retrySimPost(post, () => true, sleep)).resolves.toEqual({ ok: false, reason: 'superseded' });
-    expect(post).not.toHaveBeenCalled();
-    expect(sleep).not.toHaveBeenCalled();
-  });
-});

components/map.test.ts

@@ -0,0 +1,11 @@
+import { describe, expect, it } from 'vitest';
+import { QUEUE_ROUTE_LINE_COLOR } from './Map';
+
+// ISS-098 (v0.50.0): the dotted queued/planned route line is amber/gold, not gray — pinned so a
+// future retune is deliberate. E2E already exercises the rendering path (queue.spec.ts, relocation.spec.ts).
+
+describe('queued route line color', () => {
+  it('pins the amber/gold queue-line color readable on light and dark tiles', () => {
+    expect(QUEUE_ROUTE_LINE_COLOR).toBe('#d4a017');
+  });
+});

components/right-pane.test.ts

@@ -42,10 +42,12 @@ function pkg(over: Partial<PackageState> & Pick<PackageState, 'id'>): PackageSta
     cargoCount: 4,
     weightKg: 1_000,
     special: null, // v0.37.0 (ISS-073) — no special status by default in fixtures
+    distanceKm: 1839, // v0.48.0 (ISS-095) — EDDF→LEMD great-circle distance
     deadlineSimTime: 1_000_000,
     status: 'open',
     planeId: null,
     createdSimTime: 0,
+    expiresRealMs: null, // v0.65.0 — wall-clock expiry; open fixtures override as needed
     ...over,
   };
 }
@@ -53,7 +55,7 @@ function pkg(over: Partial<PackageState> & Pick<PackageState, 'id'>): PackageSta
 function snap(planes: PlaneState[], packages: PackageState[] = []): StateSnapshot {
   return {
     account: { cash: 0, reputation: 0 },
-    simState: { clockMs: 0, timeScale: 1, paused: false },
+    simState: { clockMs: 0 },
     planes,
     packages,
     catalog: CATALOG,

data/airports_eu.csv

@@ -1,243 +0,0 @@
-id,ident,type,name,latitude_deg,longitude_deg,elevation_ft,continent,iso_country,iso_region,municipality,scheduled_service,icao_code,iata_code,gps_code,local_code,home_link,wikipedia_link,keywords
-117,BIAR,large_airport,Akureyri International Airport,65.656573,-18.072018,6,EU,IS,IS-6,Akureyri,yes,BIAR,AEY,BIAR,,https://www.innanlandsflugvellir.is/en/akureyri-airport/,https://en.wikipedia.org/wiki/Akureyri_Airport,
-123,BIKF,large_airport,Keflavik International Airport,63.985001,-22.6056,171,EU,IS,IS-2,Reykjavík,yes,BIKF,KEF,BIKF,,https://www.isavia.is/en/keflavik-airport,https://en.wikipedia.org/wiki/Keflav%C3%ADk_International_Airport,"Keflavik Naval Air Station, REK"
-4614,BKPR,large_airport,Priština Adem Jashari International Airport,42.5728,21.035801,1789,EU,XK,XK-01,Prishtina,yes,BKPR,PRN,BKPR,,http://www.airportpristina.com/,https://en.wikipedia.org/wiki/Pristina_International_Airport,"LYPR, Pristina, Slatina Air Base"
-2155,EBBR,large_airport,Brussels Airport,50.901402,4.48444,175,EU,BE,BE-VBR,Zaventem,yes,EBBR,BRU,EBBR,,http://www.brusselsairport.be/en/,https://en.wikipedia.org/wiki/Brussels_Airport,"Brussels National, Zaventem, EBMB"
-2163,EBOS,large_airport,Ostend-Bruges International Airport,51.1998,2.874673,13,EU,BE,BE-VWV,Oostende,yes,EBOS,OST,EBOS,,http://www.ost.aero/,https://en.wikipedia.org/wiki/Ostend-Bruges_International_Airport,Ostend-Bruges International Airport
-301881,EDDB,large_airport,Berlin Brandenburg Airport,52.361738,13.502341,157,EU,DE,DE-BR,Berlin,yes,EDDB,BER,EDDB,,https://ber.berlin-airport.de/,https://en.wikipedia.org/wiki/Berlin_Brandenburg_Airport,Willy Brandt
-2210,EDDC,large_airport,Dresden Airport,51.134123,13.767831,755,EU,DE,DE-SN,Dresden,yes,EDDC,DRS,EDDC,,http://www.dresden-airport.de/en/index.html,https://en.wikipedia.org/wiki/Dresden_Airport,ETDN
-2211,EDDE,large_airport,Erfurt-Weimar Airport,50.978281,10.960713,1036,EU,DE,DE-TH,Erfurt,yes,EDDE,ERF,EDDE,,http://www.airport-erfurt.de/,https://en.wikipedia.org/wiki/Erfurt_Airport,Flughafen Erfurt-Weimar
-2212,EDDF,large_airport,Frankfurt Main Airport,50.026706,8.55835,364,EU,DE,DE-HE,Frankfurt am Main,yes,EDDF,FRA,EDDF,,https://www.frankfurt-airport.de/,https://en.wikipedia.org/wiki/Frankfurt_Airport,"EDAF, Frankfurt am Main, Frankfurt Main, Rhein-Main Air Base, Zeppelinheim"
-2213,EDDG,large_airport,Münster Osnabrück Airport,52.133816,7.688482,160,EU,DE,DE-NW,Greven,yes,EDDG,FMO,EDDG,,https://www.fmo.de/,https://en.wikipedia.org/wiki/M%C3%BCnster_Osnabr%C3%BCck_International_Airport,
-2214,EDDH,large_airport,Hamburg Helmut Schmidt Airport,53.630402,9.98823,53,EU,DE,DE-HH,Hamburg,yes,EDDH,HAM,EDDH,,https://www.hamburg-airport.de/en/,https://en.wikipedia.org/wiki/Hamburg_Airport,Hamburg-Fuhlsbüttel Airport
-2216,EDDK,large_airport,Cologne Bonn Airport,50.865898,7.14274,302,EU,DE,DE-NW,Köln (Cologne),yes,EDDK,CGN,EDDK,,http://www.koeln-bonn-airport.de/en/,https://en.wikipedia.org/wiki/Cologne_Bonn_Airport,Köln
-2217,EDDL,large_airport,Düsseldorf Airport,51.289501,6.76678,147,EU,DE,DE-NW,Düsseldorf,yes,EDDL,DUS,EDDL,,http://www.dus.com/dus_en/,https://en.wikipedia.org/wiki/D%C3%BCsseldorf_Airport,
-2218,EDDM,large_airport,Munich Airport,48.353802,11.7861,1487,EU,DE,DE-BY,Munich,yes,EDDM,MUC,EDDM,,http://www.munich-airport.com/,https://en.wikipedia.org/wiki/Munich_Airport,"Franz Josef Strauss Airport, Flughafen München Franz Josef Strauß"
-2219,EDDN,large_airport,Nuremberg Airport,49.498699,11.078056,1046,EU,DE,DE-BY,Nuremberg,yes,EDDN,NUE,EDDN,,https://www.airport-nuernberg.de/english,https://en.wikipedia.org/wiki/Nuremberg_Airport,Nürnberg
-2220,EDDP,large_airport,Leipzig/Halle Airport,51.420657,12.232705,465,EU,DE,DE-SN,Schkeuditz,yes,EDDP,LEJ,EDDP,,https://www.mdf-ag.com/,https://en.wikipedia.org/wiki/Leipzig/Halle_Airport,Schkeuditz Airport
-2222,EDDS,large_airport,Stuttgart Airport,48.689899,9.22196,1276,EU,DE,DE-BW,Stuttgart,yes,EDDS,STR,EDDS,,http://www.flughafen-stuttgart.de/,https://en.wikipedia.org/wiki/Stuttgart_Airport,
-2224,EDDV,large_airport,Hannover Airport,52.461102,9.68508,183,EU,DE,DE-NI,Hannover,yes,EDDV,HAJ,EDDV,,https://www.hannover-airport.de,https://en.wikipedia.org/wiki/Hanover/Langenhagen_International_Airport,
-2225,EDDW,large_airport,Bremen Airport,53.046786,8.78932,14,EU,DE,DE-HB,Bremen,yes,EDDW,BRE,EDDW,,https://www.bremen-airport.com,https://en.wikipedia.org/wiki/Bremen_Airport,
-2227,EDFH,large_airport,Frankfurt-Hahn Airport,49.946353,7.261734,1649,EU,DE,DE-RP,Frankfurt am Main (Lautzenhausen),yes,EDFH,HHN,EDFH,,https://www.hahn-airport.de/en/home,https://en.wikipedia.org/wiki/Frankfurt-Hahn_Airport,
-2237,EDJA,large_airport,Memmingen Allgau Airport,47.988092,10.238248,2077,EU,DE,DE-BY,Memmingen,yes,EDJA,FMM,EDJA,,,https://en.wikipedia.org/wiki/Memmingen_Airport,ETSM
-2244,EDLP,large_airport,Paderborn Lippstadt Airport,51.612527,8.617459,699,EU,DE,DE-NW,Büren,yes,EDLP,PAD,EDLP,,,https://en.wikipedia.org/wiki/Paderborn_Lippstadt_Airport,
-2247,EDLW,large_airport,Dortmund Airport,51.518299,7.61224,425,EU,DE,DE-NW,Dortmund,yes,EDLW,DTM,EDLW,,https://www.dortmund-airport.com/,https://en.wikipedia.org/wiki/Dortmund_Airport,
-2256,EDNY,large_airport,Bodensee Airport Friedrichshafen,47.671299,9.51149,1367,EU,DE,DE-BW,Friedrichshafen,yes,EDNY,FDH,EDNY,,https://www.bodensee-airport.eu,https://en.wikipedia.org/wiki/Friedrichshafen_Airport,Bodensee Airport Friedrichshafen
-2270,EDSB,large_airport,Karlsruhe Baden-Baden Airport,48.7794,8.0805,408,EU,DE,DE-BW,Rheinmünster,yes,EDSB,FKB,EDSB,,http://www.baden-airpark.de/startseite.html,https://en.wikipedia.org/wiki/Baden_Airpark,Baden Airpark
-2285,EDVK,large_airport,Kassel Airport,51.418395,9.391638,820,EU,DE,DE-HE,Calden,yes,EDVK,KSF,EDVK,,http://www.flughafenkassel.de/,https://en.wikipedia.org/wiki/Kassel_Airport,Kassel-Calden
-2301,EETN,large_airport,Lennart Meri Tallinn Airport,59.413246,24.83264,131,EU,EE,EE-37,Tallinn,yes,EETN,TLL,EETN,,https://airport.ee/,https://en.wikipedia.org/wiki/Tallinn_Airport,Tallinna Lennujaam
-2307,EFHK,large_airport,Helsinki Vantaa Airport,60.318363,24.963341,179,EU,FI,FI-18,Helsinki (Vantaa),yes,EFHK,HEL,EFHK,,https://www.finavia.fi/en/airports/helsinki-airport,https://en.wikipedia.org/wiki/Helsinki_Airport,
-2314,EFIV,large_airport,Ivalo Airport,68.6073,27.4053,481,EU,FI,FI-10,Ivalo,yes,EFIV,IVL,EFIV,,http://www.finavia.fi/en/ivalo/,https://en.wikipedia.org/wiki/Ivalo_Airport,
-2325,EFKT,large_airport,Kittilä International Airport,67.700996,24.8468,644,EU,FI,FI-10,Kittilä,yes,EFKT,KTT,EFKT,,http://www.finavia.fi/en/kittila/,https://en.wikipedia.org/wiki/Kittil%C3%A4_Airport,
-2326,EFKU,large_airport,Kuopio Airport,63.007099,27.7978,323,EU,FI,FI-15,Kuopio / Siilinjärvi,yes,EFKU,KUO,EFKU,,https://www.finavia.fi/en/kuopio/,https://en.wikipedia.org/wiki/Kuopio_Airport,
-2329,EFLP,large_airport,Lappeenranta Airport,61.044601,28.144743,349,EU,FI,FI-02,Lappeenranta,yes,EFLP,LPP,EFLP,,https://lppairport.fi/en,https://en.wikipedia.org/wiki/Lappeenranta_Airport,
-2334,EFOU,large_airport,Oulu Airport,64.930099,25.354601,47,EU,FI,FI-14,Oulu / Oulunsalo,yes,EFOU,OUL,EFOU,,https://www.finavia.fi/en/oulu/,https://en.wikipedia.org/wiki/Oulu_Airport,
-2341,EFRO,large_airport,Rovaniemi Airport,66.563327,25.829751,642,EU,FI,FI-10,Rovaniemi,yes,EFRO,RVN,EFRO,,http://www.finavia.fi/en/rovaniemi/,https://en.wikipedia.org/wiki/Rovaniemi_Airport,
-2347,EFTP,large_airport,Tampere-Pirkkala Airport,61.414101,23.604401,390,EU,FI,FI-11,Tampere / Pirkkala,yes,EFTP,TMP,EFTP,,https://www.finavia.fi/en/tampere-pirkkala/,https://en.wikipedia.org/wiki/Tampere-Pirkkala_Airport,
-2349,EFTU,large_airport,Turku Airport,60.514099,22.2628,161,EU,FI,FI-19,Turku,yes,EFTU,TKU,EFTU,,https://www.finavia.fi/en/turku/,https://en.wikipedia.org/wiki/Turku_Airport,
-2351,EFVA,large_airport,Vaasa Airport,63.05023,21.762543,19,EU,FI,FI-12,Vaasa,yes,EFVA,VAA,EFVA,,http://www.finavia.fi/en/vaasa/,https://en.wikipedia.org/wiki/Vaasa_Airport,
-2385,EGAA,large_airport,Belfast International Airport,54.6575012207,-6.2158298492399995,268,EU,GB,GB-NIR,Belfast,yes,EGAA,BFS,EGAA,,http://www.belfastairport.com/,https://en.wikipedia.org/wiki/Belfast_International_Airport,"Aldergrove, RAF Aldergrove"
-2389,EGBB,large_airport,Birmingham Airport,52.453899,-1.74803,327,EU,GB,GB-ENG,"Birmingham, West Midlands",yes,EGBB,BHX,EGBB,,https://www.birminghamairport.co.uk/,https://en.wikipedia.org/wiki/Birmingham_Airport,Birmingham International Airport
-2398,EGCC,large_airport,Manchester Airport,53.349375,-2.279521,257,EU,GB,GB-ENG,"Manchester, Greater Manchester",yes,EGCC,MAN,EGCC,,http://www.manchesterairport.co.uk/,https://en.wikipedia.org/wiki/Manchester_Airport,"Ringway Airport, RAF Ringway"
-2415,EGFF,large_airport,Cardiff International Airport,51.396702,-3.34333,220,EU,GB,GB-WLS,Cardiff,yes,EGFF,CWL,EGFF,,http://www.cwlfly.com/,https://en.wikipedia.org/wiki/Cardiff_Airport,"Caerdydd, Cardiff International Airport, Maes Awyr Caerdydd, Rhoose, Y Rhws"
-2417,EGGD,large_airport,Bristol Airport,51.382326,-2.716453,622,EU,GB,GB-ENG,Bristol,yes,EGGD,BRS,EGGD,,http://www.bristolairport.co.uk/,https://en.wikipedia.org/wiki/Bristol_Airport,Lulsgate Bottom
-2418,EGGP,large_airport,Liverpool John Lennon Airport,53.334863,-2.849637,80,EU,GB,GB-ENG,Liverpool,yes,EGGP,LPL,EGGP,,http://www.liverpoolairport.com/,https://en.wikipedia.org/wiki/Liverpool_John_Lennon_Airport,
-2434,EGLL,large_airport,London Heathrow Airport,51.470748,-0.459909,83,EU,GB,GB-ENG,London,yes,EGLL,LHR,EGLL,,http://www.heathrow.com/,https://en.wikipedia.org/wiki/Heathrow_Airport,"LON, Londres"
-2444,EGNM,large_airport,Leeds Bradford Airport,53.865898,-1.66057,681,EU,GB,GB-ENG,"Leeds, West Yorkshire",yes,EGNM,LBA,EGNM,,http://www.lbia.co.uk/,https://en.wikipedia.org/wiki/Leeds_Bradford_International_Airport,
-2447,EGNS,large_airport,Isle of Man Airport,54.083081,-4.623871,52,EU,IM,IM-U-A,Castletown,yes,EGNS,IOM,EGNS,,http://www.iom-airport.com/,https://en.wikipedia.org/wiki/Isle_of_Man_Airport,"Ronaldsway, Douglas"
-2448,EGNT,large_airport,Newcastle International Airport,55.037958,-1.689577,266,EU,GB,GB-ENG,"Newcastle upon Tyne, Tyne and Wear",yes,EGNT,NCL,EGNT,,http://www.newcastleairport.com/,https://en.wikipedia.org/wiki/Newcastle_International_Airport,
-2450,EGNX,large_airport,East Midlands Airport,52.8311,-1.32806,306,EU,GB,GB-ENG,"Nottingham, Leicestershire",yes,EGNX,EMA,EGNX,,http://www.eastmidlandsairport.com/,https://en.wikipedia.org/wiki/East_Midlands_Airport,RAF Castle Donington
-2459,EGPD,large_airport,Aberdeen International Airport,57.2019,-2.19778,215,EU,GB,GB-SCT,Aberdeen,yes,EGPD,ABZ,EGPD,,http://www.aberdeenairport.com/,https://en.wikipedia.org/wiki/Aberdeen_Airport,Dyce
-2461,EGPF,large_airport,Glasgow Airport,55.871899,-4.43306,26,EU,GB,GB-SCT,Glasgow,yes,EGPF,GLA,EGPF,,http://www.glasgowairport.com/,https://en.wikipedia.org/wiki/Glasgow_International_Airport,"Port-adhair Eadar-nàiseanta Ghlaschu, RAF Abbotsinch, RAF Ayr"
-2462,EGPH,large_airport,Edinburgh Airport,55.950145,-3.372288,135,EU,GB,GB-SCT,"Ingliston, Edinburgh",yes,EGPH,EDI,EGPH,,http://www.edinburghairport.com/,https://en.wikipedia.org/wiki/Edinburgh_Airport,
-2513,EHAM,large_airport,Amsterdam Airport Schiphol,52.308601,4.76389,-11,EU,NL,NL-NH,Amsterdam,yes,EHAM,AMS,EHAM,,https://www.schiphol.nl/,https://en.wikipedia.org/wiki/Amsterdam_Airport_Schiphol,
-2515,EHBK,large_airport,Maastricht Aachen Airport,50.911087,5.769401,375,EU,NL,NL-LI,Maastricht,yes,EHBK,MST,EHBK,,,https://en.wikipedia.org/wiki/Maastricht_Aachen_Airport,
-2518,EHEH,large_airport,Eindhoven Airport,51.4500999451,5.37452983856,74,EU,NL,NL-NB,Eindhoven,yes,EHEH,EIN,EHEH,,http://www.eindhovenairport.nl/,https://en.wikipedia.org/wiki/Eindhoven_Airport,Welschap Airport
-2519,EHGG,large_airport,Groningen Airport Eelde,53.119107,6.577652,17,EU,NL,NL-DR,Groningen,yes,EHGG,GRQ,EHGG,,,https://en.wikipedia.org/wiki/Groningen_Airport_Eelde,
-2524,EHRD,large_airport,Rotterdam The Hague Airport,51.956902,4.43722,-15,EU,NL,NL-ZH,Rotterdam,yes,EHRD,RTM,EHRD,,https://www.rotterdamthehagueairport.nl/,https://en.wikipedia.org/wiki/Rotterdam_The_Hague_Airport,Vliegveld Zestienhoven
-2530,EICK,large_airport,Cork International Airport,51.841301,-8.49111,502,EU,IE,IE-CO,Cork,yes,EICK,ORK,EICK,,http://www.corkairport.com/,https://en.wikipedia.org/wiki/Cork_Airport,Aerfort Chorcaí
-2533,EIDW,large_airport,Dublin Airport,53.428713,-6.262121,242,EU,IE,IE-D,Dublin,yes,EIDW,DUB,EIDW,,http://www.dublinairport.com/,https://en.wikipedia.org/wiki/Dublin_Airport,Aerfort Bhaile Átha Cliath
-2534,EIKN,large_airport,Ireland West Airport Knock,53.910439,-8.817002,665,EU,IE,IE-MO,Charlestown,yes,EIKN,NOC,EIKN,,http://www.irelandwestairport.com/,https://en.wikipedia.org/wiki/Ireland_West_Airport_Knock,"Connaught, Horan International Airport"
-2537,EINN,large_airport,Shannon Airport,52.702,-8.92482,46,EU,IE,IE-CE,Shannon,yes,EINN,SNN,EINN,,http://www.shannonairport.com/,https://en.wikipedia.org/wiki/Shannon_Airport,
-2540,EKAH,large_airport,Aarhus Airport,56.303331,10.618286,82,EU,DK,DK-82,Aarhus,yes,EKAH,AAR,EKAH,,http://www.aar.dk/,https://en.wikipedia.org/wiki/Aarhus_Airport,Tirstrup
-2541,EKBI,large_airport,Billund Airport,55.740335,9.157019,247,EU,DK,DK-83,Billund,yes,EKBI,BLL,EKBI,,http://www.billund-airport.dk/?sc_lang=en,https://en.wikipedia.org/wiki/Billund_Airport,
-2542,EKCH,large_airport,Copenhagen Kastrup Airport,55.617900848389,12.656000137329,17,EU,DK,DK-84,Copenhagen,yes,EKCH,CPH,EKCH,,http://www.cph.dk/en/,https://en.wikipedia.org/wiki/Copenhagen_Airport,"København, Malmö"
-2549,EKOD,large_airport,Odense Hans Christian Andersen Airport,55.475307,10.327206,56,EU,DK,DK-83,Odense,yes,EKOD,ODE,EKOD,,,https://en.wikipedia.org/wiki/Hans_Christian_Andersen_Airport,Beldringe
-2559,EKVG,large_airport,Vágar Airport,62.063256,-7.275782,280,EU,FO,FO-U-A,Vágar,yes,EKVG,FAE,EKVG,,https://www.fae.fo/,https://en.wikipedia.org/wiki/V%C3%A1gar_Airport,"Faroes, RAF Vágar"
-2562,EKYT,large_airport,Aalborg Airport,57.094763,9.84993,10,EU,DK,DK-81,Aalborg,yes,EKYT,AAL,EKYT,,http://www.aal.dk,https://en.wikipedia.org/wiki/Aalborg_Airport,
-2563,ELLX,large_airport,Luxembourg-Findel International Airport,49.626845,6.212134,1234,EU,LU,LU-L,Luxembourg,yes,ELLX,LUX,ELLX,,https://www.lux-airport.lu/en/,https://en.wikipedia.org/wiki/Luxembourg-Findel_International_Airport,
-2564,ENAL,large_airport,Ålesund Airport,62.560443,6.110845,69,EU,NO,NO-15,Ålesund,yes,ENAL,AES,ENAL,,https://www.avinor.no/airport/alesund/,https://en.wikipedia.org/wiki/%C3%85lesund_Airport%2C_Vigra,"Vigra, Ålesund Vigra Airport"
-2569,ENBO,large_airport,Bodø Airport,67.269203,14.3653,42,EU,NO,NO-18,Bodø,yes,ENBO,BOO,ENBO,,http://www.avinor.no/en/airport/bodo/,https://en.wikipedia.org/wiki/Bod%C3%B8_Airport,"Bodø Air Force Base, Bodø Main Air Station"
-2570,ENBR,large_airport,"Bergen Airport, Flesland",60.2934,5.21814,170,EU,NO,NO-46,Bergen,yes,ENBR,BGO,ENBR,,http://www.avinor.no/en/airport/bergen,https://en.wikipedia.org/wiki/Bergen_Airport%2C_Flesland,
-2572,ENCN,large_airport,Kristiansand Airport,58.204201,8.08537,57,EU,NO,NO-42,Kristiansand(Kjevik),yes,ENCN,KRS,ENCN,,http://www.avinor.no/en/airport/kristiansand,https://en.wikipedia.org/wiki/Kristiansand_Airport%2C_Kjevik,Kjevik Airport
-2575,ENEV,large_airport,Harstad/Narvik Airport,68.491302,16.678101,84,EU,NO,NO-18,Evenes,yes,ENEV,EVE,ENEV,,https://avinor.no/en/airport/harstadnarvik-airport/,https://en.wikipedia.org/wiki/Harstad/Narvik_Airport%2C_Evenes,"Harstad/Narvik lufthavn, Evenes, Evenes Airport"
-2578,ENGM,large_airport,Oslo-Gardermoen International Airport,60.193901,11.1004,681,EU,NO,NO-32,Oslo (Gardermoen),yes,ENGM,OSL,ENGM,,https://avinor.no/en/airport/oslo-airport,"https://en.wikipedia.org/wiki/Oslo_Airport,_Gardermoen",
-2599,ENTC,large_airport,Tromsø Airport,69.683296,18.9189,31,EU,NO,NO-55,Tromsø,yes,ENTC,TOS,ENTC,,http://www.avinor.no/en/airport/tromso,https://en.wikipedia.org/wiki/Troms%C3%B8_Airport,"Langnes, Tromsøya, Tromso"
-2600,ENTO,large_airport,"Sandefjord Airport, Torp",59.186699,10.2586,286,EU,NO,NO-39,Sandefjord(Torp),yes,ENTO,TRF,ENTO,,https://torp.no/,https://en.wikipedia.org/wiki/Sandefjord_Airport%2C_Torp,Torp
-2601,ENVA,large_airport,"Trondheim Airport, Værnes",63.457802,10.924,56,EU,NO,NO-50,Trondheim,yes,ENVA,TRD,ENVA,,https://avinor.no/en/airport/trondheim-airport/,https://en.wikipedia.org/wiki/Trondheim_Airport%2C_V%C3%A6rnes,
-2602,ENZV,large_airport,"Stavanger Airport, Sola",58.876701,5.63778,29,EU,NO,NO-11,Stavanger,yes,ENZV,SVG,ENZV,,http://www.avinor.no/en/airport/stavanger/,"https://en.wikipedia.org/wiki/Stavanger_Airport,_Sola","Sola Air Station, Stavanger lufthavn, Sola"
-2608,EPGD,large_airport,Gdańsk Lech Wałęsa Airport,54.377602,18.4662,489,EU,PL,PL-PM,Gdańsk,yes,EPGD,GDN,EPGD,,http://www.airport.gdansk.pl/,https://en.wikipedia.org/wiki/Gda%C5%84sk_Lech_Wa%C5%82%C4%99sa_Airport,Gdańsk-Rębiechowo
-2609,EPKK,large_airport,Kraków John Paul II International Airport,50.077702,19.7848,791,EU,PL,PL-MA,Balice,yes,EPKK,KRK,EPKK,,http://www.krakowairport.pl/en/,https://en.wikipedia.org/wiki/Kraków_John_Paul_II_International_Airport,Krakov
-2613,EPKT,large_airport,Katowice Wojciech Korfanty International Airport,50.476015,19.080705,995,EU,PL,PL-SL,Katowice,yes,EPKT,KTW,EPKT,,http://katowice.airport.com,https://en.wikipedia.org/wiki/Katowice_International_Airport,"Pyrzowice, Dąbrowa Górnicza, Katowice, Silesia, GOP, Silesia Metropolis, Gliwice, Piekary Śląskie, Bytom, Zabrze, Sosnowiec"
-309484,EPLB,large_airport,Lublin Airport,51.240157,22.713461,633,EU,PL,PL-LU,Lublin,yes,EPLB,LUZ,EPLB,,,https://en.wikipedia.org/wiki/Lublin_Airport,
-2616,EPLL,large_airport,Łódź Władysław Reymont Airport,51.721901,19.3981,604,EU,PL,PL-LD,Łódź,yes,EPLL,LCJ,EPLL,,https://www.lodz-airport.pl/en,https://en.wikipedia.org/wiki/%C5%81%C3%B3d%C5%BA_W%C5%82adys%C5%82aw_Reymont_Airport,Lublinek
-2625,EPPO,large_airport,Poznań-Ławica Airport,52.421598,16.823359,308,EU,PL,PL-WP,Poznań,yes,EPPO,POZ,EPPO,,https://poznanairport.pl,https://en.wikipedia.org/wiki/Pozna%C5%84-%C5%81awica_Airport,Poznań–Ławica Henryk Wieniawski Airport
-2629,EPRZ,large_airport,Rzeszów-Jasionka Airport,50.109791,22.024155,693,EU,PL,PL-PK,Jasionka,yes,EPRZ,RZE,EPRZ,,https://www.rzeszowairport.pl,https://en.wikipedia.org/wiki/Rzesz%C3%B3w-Jasionka_Airport,
-2630,EPSC,large_airport,Solidarity Szczecin–Goleniów Airport,53.584702,14.9022,154,EU,PL,PL-ZP,Szczecin(Glewice),yes,EPSC,SZZ,EPSC,,http://www.airport.com.pl/en/index.php,https://en.wikipedia.org/wiki/Szczecin-Goleni%C3%B3w_%22Solidarno%C5%9B%C4%87%22_Airport,"Solidarność, Glewice, Port Lotniczy Szczecin–Goleniów im. NSZZ Solidarność"
-2637,EPWA,large_airport,Warsaw Chopin Airport,52.165699,20.9671,362,EU,PL,PL-MZ,Warsaw,yes,EPWA,WAW,EPWA,,http://www.lotnisko-chopina.pl/?lang=en,https://en.wikipedia.org/wiki/Warsaw_Frederic_Chopin_Airport,"Okęcie, Warszawa"
-2638,EPWR,large_airport,Copernicus Wrocław Airport,51.103719,16.882096,404,EU,PL,PL-DS,Wrocław,yes,EPWR,WRO,EPWR,,http://www.airport.wroclaw.pl/en/index.php,https://en.wikipedia.org/wiki/Copernicus_Airport_Wroc%C5%82aw,"Strachowice, Breslau, Wroclaw"
-2648,ESGG,large_airport,Göteborg Landvetter Airport,57.6628,12.2798,506,EU,SE,SE-Q,Göteborg,yes,ESGG,GOT,ESGG,,https://www.swedavia.com/landvetter/,https://en.wikipedia.org/wiki/G%C3%B6teborg_Landvetter_Airport,"Göteborg-Landvetter, Gothenburg"
-2660,ESKN,large_airport,Stockholm Skavsta Airport,58.789656,16.911479,140,EU,SE,SE-D,Nyköping,yes,ESKN,NYO,ESKN,,,https://en.wikipedia.org/wiki/Stockholm-Skavsta_Airport,
-316498,ESKS,large_airport,Scandinavian Mountains Airport,61.16508,12.83352,1608,EU,SE,SE-W,Malung-Sälen,yes,ESKS,SCR,ESKS,,https://scandinavianmountains.se/en/home/,https://en.wikipedia.org/wiki/Scandinavian_Mountains_Airport,"Sälens Flygplats, Trysil, Sälen Trysil Airport, Sälen/Scandinavian Mountains Airport"
-2669,ESMS,large_airport,Malmö Sturup Airport,55.535564,13.376327,236,EU,SE,SE-M,Malmö,yes,ESMS,MMX,ESMS,,http://www.swedavia.com/malmo/,https://en.wikipedia.org/wiki/Malm%C3%B6_Airport,
-2685,ESNQ,large_airport,Kiruna Airport,67.821999,20.3368,1508,EU,SE,SE-BD,Kiruna,yes,ESNQ,KRN,ESNQ,,https://www.swedavia.com/kiruna/,https://en.wikipedia.org/wiki/Kiruna_Airport,
-2689,ESNU,large_airport,Umeå Airport,63.791801,20.282801,24,EU,SE,SE-AC,Umeå,yes,ESNU,UME,ESNU,,https://www.swedavia.com/umea/,https://en.wikipedia.org/wiki/Ume%C3%A5_Airport,
-2696,ESOW,large_airport,Stockholm Västerås Airport,59.589401,16.6336,21,EU,SE,SE-U,Stockholm / Västerås,yes,ESOW,VST,ESOW,,,https://en.wikipedia.org/wiki/Stockholm-V%C3%A4ster%C3%A5s_Airport,
-2697,ESPA,large_airport,Luleå Airport,65.5438,22.122,65,EU,SE,SE-BD,Luleå,yes,ESPA,LLA,ESPA,,https://www.swedavia.com/lulea/,https://en.wikipedia.org/wiki/Lule%C3%A5_Airport,Kallax Air Base
-2701,ESSA,large_airport,Stockholm-Arlanda Airport,59.64849,17.928829,137,EU,SE,SE-AB,Stockholm,yes,ESSA,ARN,ESSA,,http://www.swedavia.se/arlanda/,https://en.wikipedia.org/wiki/Stockholm-Arlanda_Airport,
-2706,ESSL,large_airport,Linköping City Airport,58.404909,15.684499,172,EU,SE,SE-E,Linköping,yes,ESSL,LPI,ESSL,,http://www.linkopingsflygplats.se/,https://en.wikipedia.org/wiki/Link%C3%B6ping_SAAB_Airport,
-2710,ESSV,large_airport,Visby Airport,57.6628,18.346201,164,EU,SE,SE-I,Visby,yes,ESSV,VBY,ESSV,,https://www.swedavia.com/visby/,https://en.wikipedia.org/wiki/Visby_Airport,
-2757,EVLA,large_airport,Liepāja International Airport,56.517502,21.096901,16,EU,LV,LV-112,Liepāja,no,EVLA,LPX,EVLA,,http://www.liepaja-airport.lv/,https://en.wikipedia.org/wiki/Liep%C4%81ja_International_Airport,
-2758,EVRA,large_airport,Riga International Airport,56.920752,23.970711,36,EU,LV,LV-062,Riga,yes,EVRA,RIX,EVRA,,http://www.riga-airport.com/,https://en.wikipedia.org/wiki/Riga_International_Airport,
-2760,EYKA,large_airport,Kaunas International Airport,54.963965,24.08582,256,EU,LT,LT-KU,Kaunas,yes,EYKA,KUN,EYKA,,http://www.kaunasair.lt/index.php?lang=2&m=2&p=210,https://en.wikipedia.org/wiki/Kaunas_Airport,Kauno tarptautinis Oro Uostas
-2762,EYPA,large_airport,Palanga International Airport,55.973202,21.093901,33,EU,LT,LT-KL,Palanga,yes,EYPA,PLQ,EYPA,,http://www.palanga-airport.lt/,https://en.wikipedia.org/wiki/Palanga_International_Airport,
-2766,EYVI,large_airport,Vilnius International Airport,54.634102,25.285801,648,EU,LT,LT-VL,Vilnius,yes,EYVI,VNO,EYVI,,http://www.vilnius-airport.lt/en/,https://en.wikipedia.org/wiki/Vilnius_International_Airport,
-3972,LATI,large_airport,Tirana International Airport Mother Teresa,41.4147,19.7206,126,EU,AL,AL-02,Rinas,yes,LATI,TIA,LATI,,http://www.tirana-airport.com/,https://en.wikipedia.org/wiki/Tirana_International_Airport_N%C3%ABn%C3%AB_Tereza,"Rinas International Airport, Aeroporti Nënë Tereza"
-3974,LBBG,large_airport,Burgas Airport,42.569917,27.515173,135,EU,BG,BG-02,Burgas,yes,LBBG,BOJ,LBBG,,,https://en.wikipedia.org/wiki/Burgas_Airport,Bourgas
-3976,LBPD,large_airport,Plovdiv International Airport,42.067799,24.8508,597,EU,BG,BG-16,Plovdiv,yes,LBPD,PDV,LBPD,,http://www.plovdivairport.com/,https://en.wikipedia.org/wiki/Plovdiv_International_Airport,
-3977,LBSF,large_airport,Sofia Airport,42.696357,23.417671,1742,EU,BG,BG-22,Sofia,yes,LBSF,SOF,LBSF,,http://sofia-airport.bg,https://en.wikipedia.org/wiki/Sofia_Airport,"Sofia International Airport, Vrazhdebna Air Base"
-3979,LBWN,large_airport,Varna Airport,43.232101,27.8251,230,EU,BG,BG-03,Varna,yes,LBWN,VAR,LBWN,,,https://en.wikipedia.org/wiki/Varna_Airport,Aksakovo
-3984,LDDU,large_airport,Dubrovnik Ruđer Bošković Airport,42.562247,18.265543,527,EU,HR,HR-19,Dubrovnik,yes,LDDU,DBV,LDDU,,https://www.airport-dubrovnik.hr/en,https://en.wikipedia.org/wiki/Dubrovnik_Airport,"Močići Airport, Zračna luka Ruđer Bošković Dubrovnik"
-3987,LDPL,large_airport,Pula Airport,44.893501,13.9222,274,EU,HR,HR-18,Pula,yes,LDPL,PUY,LDPL,,https://airport-pula.hr/en/,https://en.wikipedia.org/wiki/Pula_Airport,
-3989,LDRI,large_airport,Rijeka Airport,45.216376,14.57085,278,EU,HR,HR-08,Rijeka(Omišalj),yes,LDRI,RJK,LDRI,,https://www.rijeka-airport.hr/,https://en.wikipedia.org/wiki/Rijeka_Airport,"Reka, Rika, Fiume, Omišalj"
-3991,LDSP,large_airport,Split Saint Jerome Airport,43.538898,16.298,79,EU,HR,HR-17,Split,yes,LDSP,SPU,LDSP,,https://split-airport.hr,https://en.wikipedia.org/wiki/Split_Airport,
-3993,LDZA,large_airport,Zagreb Franjo Tuđman International Airport,45.742901,16.0688,353,EU,HR,HR-01,Velika Gorica,yes,LDZA,ZAG,LDZA,,https://www.zagreb-airport.hr/en,https://en.wikipedia.org/wiki/Zagreb_Airport,Pleso
-3994,LDZD,large_airport,Zadar Airport,44.096986,15.353565,289,EU,HR,HR-13,Zadar,yes,LDZD,ZAD,LDZD,,https://www.zadar-airport.hr/en,https://en.wikipedia.org/wiki/Zadar_Airport,
-3997,LEAL,large_airport,Alicante-Elche Miguel Hernández Airport,38.2822,-0.558156,142,EU,ES,ES-VC,Alicante,yes,LEAL,ALC,LEAL,,https://www.aena.es/en/alicante-elche.html,https://en.wikipedia.org/wiki/Alicante–Elche_Miguel_Hernández_Airport,
-3999,LEAS,large_airport,Asturias Airport,43.563599,-6.03462,416,EU,ES,ES-AS,Ranón,yes,LEAS,OVD,LEAS,,https://www.aena.es/en/asturias.html,https://en.wikipedia.org/wiki/Asturias_Airport,
-4001,LEBB,large_airport,Bilbao Airport,43.301102,-2.91061,138,EU,ES,ES-PV,Bilbao,yes,LEBB,BIO,LEBB,,https://www.aena.es/en/bilbao.html,https://en.wikipedia.org/wiki/Bilbao_Airport,
-4004,LEBL,large_airport,Josep Tarradellas Barcelona-El Prat Airport,41.2971,2.07846,12,EU,ES,ES-CT,Barcelona,yes,LEBL,BCN,LEBL,,https://www.aena.es/en/josep-tarradellas-barcelona-el-prat.html,https://en.wikipedia.org/wiki/Barcelona%E2%80%93El_Prat_Airport,"El Prat Airport,Barcelona International,Josep Tarradellas Barcelona-El Prat Airport"
-4010,LEGE,large_airport,Girona-Costa Brava Airport,41.904639,2.761774,468,EU,ES,ES-CT,Girona,yes,LEGE,GRO,LEGE,,https://www.aena.es/en/girona-costa-brava.html,https://en.wikipedia.org/wiki/Girona-Costa_Brava_Airport,"Girona, Costa Brava, Girona-Costa Brava"
-4013,LEIB,large_airport,Ibiza Airport,38.872898,1.37312,24,EU,ES,ES-IB,Ibiza (Eivissa),yes,LEIB,IBZ,LEIB,,https://www.aena.es/en/ibiza.html,https://en.wikipedia.org/wiki/Ibiza_Airport,
-4019,LEMD,large_airport,Adolfo Suárez Madrid–Barajas Airport,40.493407,-3.572249,1998,EU,ES,ES-MD,Madrid,yes,LEMD,MAD,LEMD,,https://www.aena.es/en/adolfo-suarez-madrid-barajas.html,https://en.wikipedia.org/wiki/Adolfo_Su%C3%A1rez_Madrid%E2%80%93Barajas_Airport,"Leganés, Madrid Barajas International Airport"
-4020,LEMG,large_airport,Málaga-Costa del Sol Airport,36.6749,-4.49911,53,EU,ES,ES-AN,Málaga,yes,LEMG,AGP,LEMG,,https://www.aena.es/en/malaga-costa-del-sol.html,https://en.wikipedia.org/wiki/M%C3%A1laga_Airport,"Costa del Sol, Malaga"
-4021,LEMH,large_airport,Menorca Airport,39.862598,4.21865,302,EU,ES,ES-IB,Mahón (Maó),yes,LEMH,MAH,LEMH,,https://www.aena.es/en/menorca.html,https://en.wikipedia.org/wiki/Menorca_Airport,Menorca
-308134,LEMI,large_airport,Region of Murcia International Airport,37.802852,-1.124884,644,EU,ES,ES-MC,Corvera,yes,LEMI,RMU,LEMI,,https://www.aena.es/en/internacional-region-de-murcia.html,https://en.wikipedia.org/wiki/Murcia-Corvera_Airport,
-4035,LEPA,large_airport,Palma de Mallorca Airport,39.551701,2.73881,27,EU,ES,ES-IB,Palma de Mallorca,yes,LEPA,PMI,LEPA,,https://www.aena.es/en/palma-de-mallorca.html,https://en.wikipedia.org/wiki/Son_Sant_Joan_Airport,"Son Sant Joan Airport, LESJ"
-4031,LERS,large_airport,Reus Airport,41.147509,1.168354,233,EU,ES,ES-CT,Reus,yes,LERS,REU,LERS,,https://www.aena.es/en/reus.html,https://en.wikipedia.org/wiki/Reus_Airport,
-4038,LEST,large_airport,Santiago-Rosalía de Castro Airport,42.896301,-8.41514,1213,EU,ES,ES-GA,Santiago de Compostela,yes,LEST,SCQ,LEST,,https://www.aena.es/en/santiago-rosalia-de-castro.html,https://en.wikipedia.org/wiki/Santiago_de_Compostela_Airport,
-4042,LEVC,large_airport,Valencia Airport,39.489162,-0.480961,240,EU,ES,ES-VC,Valencia,yes,LEVC,VLC,LEVC,,https://www.aena.es/en/valencia.html,https://en.wikipedia.org/wiki/Valencia_Airport,
-4048,LEZG,large_airport,Zaragoza Airport,41.666199,-1.04155,863,EU,ES,ES-AR,Zaragoza,yes,LEZG,ZAZ,LEZG,,https://www.aena.es/en/zaragoza.html,https://en.wikipedia.org/wiki/Zaragoza_Airport,Zaragoza Air Base
-4049,LEZL,large_airport,Seville Airport,37.417999,-5.89311,112,EU,ES,ES-AN,Seville,yes,LEZL,SVQ,LEZL,,https://www.aena.es/en/seville.html,https://en.wikipedia.org/wiki/Seville_Airport,"Sevilla, Sevilla Airport"
-4060,LFBD,large_airport,Bordeaux–Mérignac Airport,44.82865,-0.715356,162,EU,FR,FR-NAQ,Bordeaux,yes,LFBD,BOD,LFBD,,https://www.bordeaux.aeroport.fr/,https://en.wikipedia.org/wiki/Bordeaux%E2%80%93M%C3%A9rignac_Airport,
-4070,LFBO,large_airport,Toulouse-Blagnac Airport,43.629101,1.36382,499,EU,FR,FR-OCC,Toulouse/Blagnac,yes,LFBO,TLS,LFBO,,http://www.toulouse.aeroport.fr/,https://en.wikipedia.org/wiki/Toulouse_Blagnac_International_Airport,Airbus
-4123,LFKB,large_airport,Bastia-Poretta International airport,42.5527,9.48373,26,EU,FR,FR-COR,Bastia,yes,LFKB,BIA,LFKB,,https://bastia-aeroport.cci.corsica/,https://en.wikipedia.org/wiki/Bastia_-_Poretta_Airport,
-4125,LFKF,large_airport,Figari Sud-Corse Airport,41.50185,9.097092,85,EU,FR,FR-COR,Figari,yes,LFKF,FSC,LFKF,,https://figari-aeroport.cci.corsica/,https://en.wikipedia.org/wiki/Figari_Sud-Corse_Airport,
-4132,LFLC,large_airport,Clermont-Ferrand Auvergne airport,45.786701,3.16917,1090,EU,FR,FR-ARA,Clermont-Ferrand,yes,LFLC,CFE,LFLC,,https://www.clermont-aeroport.com/en,https://en.wikipedia.org/wiki/Clermont-Ferrand_Auvergne_Airport,
-4137,LFLL,large_airport,Lyon Saint-Exupéry Airport,45.725996,5.090139,821,EU,FR,FR-ARA,"Colombier-Saugnieu, Rhône",yes,LFLL,LYS,LFLL,,https://www.lyonaeroports.com/,https://en.wikipedia.org/wiki/Lyon%E2%80%93Saint-Exup%C3%A9ry_Airport,"Lyon, Saint-Exupéry, Satolas"
-4155,LFML,large_airport,Marseille Provence Airport,43.438088,5.2125,74,EU,FR,FR-PAC,"Marignane, Bouches-du-Rhône",yes,LFML,MRS,LFML,,https://www.marseille.aeroport.fr/,https://en.wikipedia.org/wiki/Marseille_Provence_Airport,
-4156,LFMN,large_airport,Nice-Côte d'Azur Airport,43.658401,7.21587,12,EU,FR,FR-PAC,"Nice, Alpes-Maritimes",yes,LFMN,NCE,LFMN,,https://www.nice.aeroport.fr/en,https://en.wikipedia.org/wiki/C%C3%B4te_d'Azur_International_Airport,
-4161,LFMT,large_airport,Montpellier-Méditerranée Airport,43.576199,3.96301,17,EU,FR,FR-OCC,Montpellier/Méditerranée,yes,LFMT,MPL,LFMT,,https://www.montpellier.aeroport.fr/,https://en.wikipedia.org/wiki/Montpellier_-_M%C3%A9diterran%C3%A9e_Airport,
-4169,LFOB,large_airport,Beauvais-Tillé airport,49.454399,2.11278,359,EU,FR,FR-HDF,Beauvais,yes,LFOB,BVA,LFOB,,https://www.aeroportparisbeauvais.com/,https://en.wikipedia.org/wiki/Paris_Beauvais_Till%C3%A9_Airport,Beauvais-Tillé
-4185,LFPG,large_airport,Charles de Gaulle International Airport,49.00896,2.554117,392,EU,FR,FR-IDF,"Paris (Roissy-en-France, Val-d'Oise)",yes,LFPG,CDG,LFPG,,http://www.aeroportsdeparis.fr/,https://en.wikipedia.org/wiki/Charles_de_Gaulle_Airport,"PAR, Aéroport Roissy-Charles de Gaulle, Roissy Airport"
-4202,LFQQ,large_airport,Lille Airport,50.566564,3.102429,157,EU,FR,FR-HDF,Lesquin,yes,LFQQ,LIL,LFQQ,,https://www.lille.aeroport.fr/home/,https://en.wikipedia.org/wiki/Lille_Airport,Aéroport de Lille. Lille-Lesquin Airport
-4206,LFRB,large_airport,Brest Bretagne airport,48.447899,-4.41854,325,EU,FR,FR-BRE,Brest,yes,LFRB,BES,LFRB,,https://www.brest.aeroport.bzh,https://en.wikipedia.org/wiki/Brest_Bretagne_Airport,
-4221,LFRS,large_airport,Nantes Atlantique Airport,47.153198,-1.61073,90,EU,FR,FR-PDL,Nantes,yes,LFRS,NTE,LFRS,,https://www.nantes.aeroport.fr/en,https://en.wikipedia.org/wiki/Nantes_Atlantique_Airport,
-4226,LFSB,large_airport,EuroAirport Basel–Mulhouse–Freiburg,47.60068,7.521117,885,EU,FR,FR-GES,Bâle / Mulhouse,yes,LFSB,BSL,LFSB,,http://www.euroairport.com/,https://en.wikipedia.org/wiki/EuroAirport_Basel-Mulhouse-Freiburg,"MLH, EAP, LSZM, Bâle, Basle"
-4238,LFST,large_airport,Strasbourg Airport,48.5383,7.62823,505,EU,FR,FR-GES,Strasbourg,yes,LFST,SXB,LFST,,http://www.strasbourg.aeroport.fr/E/index.php,https://en.wikipedia.org/wiki/Strasbourg_Airport,BA 124
-4251,LGAV,large_airport,Athens Eleftherios Venizelos International Airport,37.936401,23.9445,308,EU,GR,GR-I,Spata-Artemida,yes,LGAV,ATH,LGAV,,https://www.aia.gr,https://en.wikipedia.org/wiki/Athens_International_Airport,
-4258,LGIR,large_airport,Heraklion International Nikos Kazantzakis Airport,35.339699,25.1803,115,EU,GR,GR-M,Heraklion,yes,LGIR,HER,LGIR,,https://www.heraklion-airport.gr/en/,"https://en.wikipedia.org/wiki/Heraklion_International_Airport_""Nikos_Kazantzakis""",Crete Island
-4266,LGKR,large_airport,Corfu Ioannis Kapodistrias International Airport,39.60145,19.912179,6,EU,GR,GR-F,Kerkyra (Corfu),yes,LGKR,CFU,LGKR,,https://www.cfu-airport.gr/en,https://en.wikipedia.org/wiki/Corfu_International_Airport,Corfu
-4268,LGKV,large_airport,Kavala Alexander the Great International Airport,40.9133,24.6192,18,EU,GR,GR-A,Kavala,yes,LGKV,KVA,LGKV,,https://www.kva-airport.gr/en,https://en.wikipedia.org/wiki/Kavala_International_Airport,Megas Alexandros
-4281,LGSA,large_airport,Chania International Airport,35.531207,24.150673,490,EU,GR,GR-M,Souda,yes,LGSA,CHQ,LGSA,,,https://en.wikipedia.org/wiki/Chania_International_Airport,
-4286,LGSR,large_airport,Santorini International Airport,36.400045,25.478638,127,EU,GR,GR-L,Santorini Island,yes,LGSR,JTR,LGSR,,https://www.jtr-airport.gr/,https://en.wikipedia.org/wiki/Santorini_(Thira)_National_Airport,
-4293,LGTS,large_airport,Thessaloniki Macedonia International Airport,40.51928,22.970009,22,EU,GR,GR-B,Thessaloniki,yes,LGTS,SKG,LGTS,,https://www.skg-airport.gr/en,https://en.wikipedia.org/wiki/Thessaloniki_Airport,Makedonia. Macedonia. Salonica
-4296,LHBP,large_airport,Budapest Liszt Ferenc International Airport,47.43018,19.262393,495,EU,HU,HU-BU,Budapest,yes,LHBP,BUD,LHBP,,http://www.bud.hu/english,https://en.wikipedia.org/wiki/Budapest_Ferenc_Liszt_International_Airport,"Ferihegyi nemzetközi repülőtér, Budapest Liszt Ferenc international Airport"
-4297,LHDC,large_airport,Debrecen International Airport,47.489469,21.616278,359,EU,HU,HU-HB,Debrecen,yes,LHDC,DEB,LHDC,,http://www.airportdebrecen.hu/,https://en.wikipedia.org/wiki/Debrecen_International_Airport,Debreceni nemzetközi repülőtér
-4302,LHPP,large_airport,Pécs-Pogány International Airport,45.988891,18.242044,651,EU,HU,HU-BA,Pécs,yes,LHPP,PEV,LHPP,,http://www.airportpecs.hu/,https://en.wikipedia.org/wiki/P%C3%A9cs-Pog%C3%A1ny_International_Airport,"Pecs South Airport, QPJ"
-4310,LIBD,large_airport,Bari Karol Wojtyła International Airport,41.138901,16.760599,193,EU,IT,IT-75,Bari,yes,LIBD,BRI,LIBD,BA02,http://www.seap-puglia.it/default.asp?idlingua=2&idcontenuto=25,https://en.wikipedia.org/wiki/Bari_Karol_Wojty%C5%82a_Airport,"Bari ""Karol Wojtyla"" International Airport, Palese Macchie Airport, Palese Airport"
-4314,LIBP,large_airport,Abruzzo Airport,42.431079,14.182981,48,EU,IT,IT-65,Pescara,yes,LIBP,PSR,LIBP,PE01,http://www.abruzzo-airport.it/eng/index.php,https://en.wikipedia.org/wiki/Abruzzo_Airport,"Pescara, Abruzzo Pasquale Liberi International"
-4315,LIBR,large_airport,Brindisi Airport,40.6576,17.947001,47,EU,IT,IT-75,Brindisi,yes,LIBR,BDS,LIBR,BR03,http://www.seap-puglia.it/default.asp?idlingua=2&idcontenuto=29,https://en.wikipedia.org/wiki/Brindisi_Airport,"Brindisi Papola Casale Airport, Brindisi Salento Airport, Brindisi Casale Antonio Papolo Airport, Salento Airport"
-4317,LICA,large_airport,Lamezia Terme Sant'Eufemia International Airport,38.906214,16.246007,39,EU,IT,IT-78,Lamezia Terme (CZ),yes,LICA,SUF,LICA,CZ02,,https://en.wikipedia.org/wiki/Lamezia_Terme_International_Airport,
-4318,LICC,large_airport,Catania-Fontanarossa Airport,37.466801,15.0664,39,EU,IT,IT-82,Catania,yes,LICC,CTA,LICC,CT03,http://www.aeroporto.catania.it/,https://en.wikipedia.org/wiki/Catania-Fontanarossa_Airport,"Lanza Di Trabie, Catania-Fontanarossa Vincenzo Bellini"
-4321,LICJ,large_airport,Falcone–Borsellino Airport,38.175999,13.091,65,EU,IT,IT-82,Palermo,yes,LICJ,PMO,LICJ,PA03,http://www.gesap.it/index.php,https://en.wikipedia.org/wiki/Falcone%E2%80%93Borsellino_Airport,"Palermo Airport, Punta Raisi Airport"
-4332,LIEE,large_airport,Cagliari Elmas Airport,39.251499,9.05428,13,EU,IT,IT-88,Cagliari,yes,LIEE,CAG,LIEE,CA07,http://www.cagliariairport.it/en/,https://en.wikipedia.org/wiki/Cagliari_Elmas_Airport,"Cagliari Airport,Elmas"
-4333,LIEO,large_airport,Olbia Costa Smeralda Airport,40.898953,9.518457,37,EU,IT,IT-88,Olbia (SS),yes,LIEO,OLB,LIEO,SS03,https://www.geasar.it/en,https://en.wikipedia.org/wiki/Olbia_Costa_Smeralda_Airport,
-4340,LIMC,large_airport,Milan Malpensa International Airport,45.6306,8.72811,768,EU,IT,IT-25,Ferno (VA),yes,LIMC,MXP,LIMC,MI12,http://www.sea-aeroportimilano.it/en/malpensa/index.phtml,https://en.wikipedia.org/wiki/Malpensa_Airport,"MIL, Silvio Berlusconi"
-4342,LIMF,large_airport,Turin Airport,45.200802,7.64963,989,EU,IT,IT-21,Caselle Torinese (TO),yes,LIMF,TRN,LIMF,TO11,http://www.aeroportoditorino.it/,https://en.wikipedia.org/wiki/Turin_International_Airport,"Torino-Caselle Airport, Sandro Pertini Airport, Turin-Caselle Airport"
-4344,LIMJ,large_airport,Genoa Cristoforo Colombo Airport,44.412039,8.840732,13,EU,IT,IT-42,Genova (GE),yes,LIMJ,GOA,LIMJ,GE01,http://www.aeroportodigenova.com/en/home/index.php,https://en.wikipedia.org/wiki/Genoa_Cristoforo_Colombo_Airport,"Genova Sestri, Sestri Cristoforo Colombo Airport, Cristoforo Colombo Airport"
-4354,LIPE,large_airport,Bologna Guglielmo Marconi Airport,44.5354,11.2887,123,EU,IT,IT-45,Bologna,yes,LIPE,BLQ,LIPE,BO08,http://www.bologna-airport.it/?LN=UK,https://en.wikipedia.org/wiki/Bologna_Airport,"Guglielmo Marconi Airport, Borgo Panigale Airport"
-4361,LIPQ,large_airport,Trieste Airport,45.827862,13.466672,39,EU,IT,IT-36,Ronchi dei Legionari/Trieste,yes,LIPQ,TRS,LIPQ,GO02,http://www.triesteairport.it,https://en.wikipedia.org/wiki/Trieste_%E2%80%93_Friuli_Venezia_Giulia_Airport,"Ronchi Dei Legionari Airport, Trieste-Ronchi dei Legionari Airport"
-4362,LIPR,large_airport,Federico Fellini International Airport,44.020024,12.612198,40,EU,IT,IT-45,Rimini (RN),yes,LIPR,RMI,LIPR,RN01,http://www.riminiairport.com/english/,https://en.wikipedia.org/wiki/Federico_Fellini_International_Airport,"Rimini Miramare Airport, Rimini San Marino International Airport"
-4366,LIPX,large_airport,Verona Villafranca Valerio Catullo Airport,45.394955,10.887303,239,EU,IT,IT-34,Caselle (VR),yes,LIPX,VRN,LIPX,VR10,http://www.aeroportoverona.it/,https://en.wikipedia.org/wiki/Verona_Airport,"Valerio Catullo, Villafranca International Airport, Valerio Catullo Airport, Villafranca Airport"
-4368,LIPZ,large_airport,Venice Marco Polo Airport,45.505299,12.3519,7,EU,IT,IT-34,Venezia (VE),yes,LIPZ,VCE,LIPZ,VE05,http://www.veniceairport.com/core/index.jsp?_requestid=37300&language=en,https://en.wikipedia.org/wiki/Venice_Marco_Polo_Airport,"Venezia-Tessera, Venice-Tessera"
-4372,LIRF,large_airport,Rome–Fiumicino Leonardo da Vinci International Airport,41.804532,12.251998,13,EU,IT,IT-62,Rome,yes,LIRF,FCO,LIRF,RM11,http://www.adr.it/portal/portal/adr/Fiumicino/Leonardo_da_vinci/Header_Window?action=2,https://en.wikipedia.org/wiki/Rome_Fiumicino_Airport,"ROM, Rome Fiumicino Airport, Fiumicino Airport"
-4378,LIRN,large_airport,Naples International Airport,40.886002,14.2908,294,EU,IT,IT-72,Napoli,yes,LIRN,NAP,LIRN,NA01,http://www.portal.gesac.it/,https://en.wikipedia.org/wiki/Naples_International_Airport,"Capodichino Airport, Aeroporto Internazionale di Napoli-Capodichino Ugo Niutta, Ariopuorto 'nternazziunale 'e Napule-Capodichino Ugo Niutta"
-4379,LIRP,large_airport,Pisa International Airport,43.683899,10.3927,6,EU,IT,IT-52,Pisa (PI),yes,LIRP,PSA,LIRP,PI05,http://www.pisa-airport.com/,https://en.wikipedia.org/wiki/Pisa_International_Airport,"Galileo Galilei Airport, San Giusto Airport"
-4380,LIRQ,large_airport,"Florence Airport, Peretola",43.808558,11.202822,142,EU,IT,IT-52,Firenze (FI),yes,LIRQ,FLR,LIRQ,FI04,http://www.aeroporto.firenze.it/,https://en.wikipedia.org/wiki/Florence_Airport,"Firenze, Amerigo Vespucci Airport, Aeroporto di Firenze-Peretola"
-4384,LIRZ,large_airport,Perugia San Francesco d'Assisi – Umbria International Airport,43.095901,12.5132,697,EU,IT,IT-55,Perugia (PG),yes,LIRZ,PEG,LIRZ,PG10,http://www.airport.umbria.it/,https://en.wikipedia.org/wiki/Perugia_San_Francesco_d%27Assisi_%E2%80%93_Umbria_International_Airport,"Perugia San Francesco d'Assisi, Perugia Sant'Egidio Airport, Umbria International Airport"
-4386,LJLJ,large_airport,Ljubljana Jože Pučnik Airport,46.223701,14.4576,1273,EU,SI,SI-012,Zgornji Brnik,yes,LJLJ,LJU,LJLJ,,http://www.lju-airport.si/,https://en.wikipedia.org/wiki/Ljubljana_Jo%C5%BEe_Pu%C4%8Dnik_Airport,"Ljubljana, Kranj"
-4393,LKCS,large_airport,České Budějovice South Bohemian Airport,48.948171,14.42832,1417,EU,CZ,CZ-JC,České Budějovice,yes,LKCS,JCL,LKCS,,https://www.airport-cb.cz/,https://en.wikipedia.org/wiki/%C4%8Cesk%C3%A9_Bud%C4%9Bjovice_Airport,Jihočeské letiště České Budějovice
-4399,LKKV,large_airport,Karlovy Vary Airport,50.202999,12.915,1989,EU,CZ,CZ-KA,Karlovy Vary,yes,LKKV,KLV,LKKV,,http://www.airport-k-vary.cz/indexEN.php,https://en.wikipedia.org/wiki/Karlovy_Vary_Airport,Karlovy Vary International
-4402,LKMT,large_airport,Leoš Janáček Airport Ostrava,49.696301,18.111099,844,EU,CZ,CZ-MO,Mošnov,yes,LKMT,OSR,LKMT,,http://www.airport-ostrava.cz/en/,https://en.wikipedia.org/wiki/Ostrava_Leos_Janacek_Airport,Ostrava-Mošnov International Airport
-4405,LKPD,large_airport,Pardubice Airport,50.015049,15.73981,741,EU,CZ,CZ-PA,Pardubice,yes,LKPD,PED,LKPD,,http://www.airport-pardubice.cz/?lang=en,https://en.wikipedia.org/wiki/Pardubice_Airport,Letiště Pardubice
-4408,LKPR,large_airport,Václav Havel Airport Prague,50.100874,14.259911,1247,EU,CZ,CZ-PR,Prague,yes,LKPR,PRG,LKPR,,http://www.prg.aero,https://en.wikipedia.org/wiki/Václav_Havel_Airport_Prague,"Letiště Praha-Ruzyně, Ruzyně International Airport, Letiště Václava Havla Praha"
-4427,LMML,large_airport,Malta International Airport,35.845932,14.491546,300,EU,MT,MT-25,Valletta,yes,LMML,MLA,LMML,,https://www.maltairport.com/,https://en.wikipedia.org/wiki/Malta_International_Airport,"Luqa Airport, Valletta, Gudja, RAF Luqa"
-4430,LOWG,large_airport,Graz Airport,46.9911,15.4396,1115,EU,AT,AT-6,Feldkirchen bei Graz,yes,LOWG,GRZ,LOWG,,http://www.flughafen-graz.at/,https://en.wikipedia.org/wiki/Graz_Airport,"Thalerhof Airport, Fliegerhorst Nittner, Nittner Air Base, Christophorus 12"
-4431,LOWI,large_airport,Innsbruck Airport,47.260201,11.344,1907,EU,AT,AT-7,Innsbruck,yes,LOWI,INN,LOWI,,http://www.innsbruck-airport.com/,https://en.wikipedia.org/wiki/Innsbruck_Airport,Kranebitten Airport
-4435,LOWK,large_airport,Klagenfurt Airport,46.642502,14.3377,1472,EU,AT,AT-2,Klagenfurt am Wörthersee,yes,LOWK,KLU,LOWK,,http://www.klagenfurt-airport.com/,https://en.wikipedia.org/wiki/Klagenfurt_Airport,"Kärnten Airport, Christophorus 11"
-4432,LOWL,large_airport,Linz-Hörsching Airport,48.235362,14.188128,980,EU,AT,AT-4,Linz,yes,LOWL,LNZ,LOWL,,http://www.flughafen-linz.at/,https://en.wikipedia.org/wiki/Linz_Airport,"Blue Danube Airport, Vogler Air Base, Fliegerhorst Vogler, Christophorus 10"
-4433,LOWS,large_airport,Salzburg Airport,47.793301,13.0043,1411,EU,AT,AT-5,Salzburg,yes,LOWS,SZG,LOWS,,http://www.salzburg-airport.com/,https://en.wikipedia.org/wiki/Salzburg_Airport,Christophorus 6
-4434,LOWW,large_airport,Vienna International Airport,48.110298,16.5697,600,EU,AT,AT-9,Vienna,yes,LOWW,VIE,LOWW,,http://www.viennaairport.com/en/,https://en.wikipedia.org/wiki/Vienna_International_Airport,
-4448,LPFR,large_airport,Faro - Gago Coutinho International Airport,37.015909,-7.970939,24,EU,PT,PT-08,Faro,yes,LPFR,FAO,LPFR,,http://faroairport.pt,https://en.wikipedia.org/wiki/Faro_Airport_(Portugal),
-4452,LPMA,large_airport,Cristiano Ronaldo International Airport,32.697812,-16.774613,192,EU,PT,PT-30,Funchal,yes,LPMA,FNC,LPMA,,http://www.aeroportomadeira.pt,https://en.wikipedia.org/wiki/Madeira_Airport,"Madeira, Funchal"
-4456,LPPD,large_airport,João Paulo II Airport,37.7411994934,-25.6979007721,259,EU,PT,PT-20,Ponta Delgada,yes,LPPD,PDL,LPPD,,http://www.ana.pt/en-US/Aeroportos/acores/PontaDelgada/Pages/Homepage-PontaDelgada.aspx,https://en.wikipedia.org/wiki/Jo%C3%A3o_Paulo_II_Airport,
-4459,LPPR,large_airport,Francisco de Sá Carneiro Airport,41.2481002808,-8.68138980865,228,EU,PT,PT-13,Porto,yes,LPPR,OPO,LPPR,,http://www.ana.pt/en-US/Aeroportos/porto/Porto/Pages/Homepage-Porto.aspx,https://en.wikipedia.org/wiki/Francisco_S%C3%A1_Carneiro_Airport,
-4461,LPPT,large_airport,Lisbon Humberto Delgado Airport,38.7813,-9.13592,374,EU,PT,PT-11,Lisbon,yes,LPPT,LIS,LPPT,,https://lisbonairport.pt,https://en.wikipedia.org/wiki/Lisbon_Airport,"Lisboa, Portela"
-4467,LQBK,large_airport,Banja Luka International Airport,44.941399,17.297501,400,EU,BA,BA-SRP,Mahovljani,yes,LQBK,BNX,LQBK,,http://www.banjaluka-airport.com/,https://en.wikipedia.org/wiki/Banja_Luka_International_Airport,Mahovljani Airport
-4468,LQMO,large_airport,Mostar International Airport,43.282489,17.846101,156,EU,BA,BA-BIH,Mostar,yes,LQMO,OMO,LQMO,,http://www.mostar-airport.ba/,https://en.wikipedia.org/wiki/Mostar_International_Airport,
-4469,LQSA,large_airport,Sarajevo International Airport,43.8246,18.331499,1708,EU,BA,BA-BIH,Sarajevo,yes,LQSA,SJJ,LQSA,,http://www.sarajevo-airport.ba/,https://en.wikipedia.org/wiki/Sarajevo_International_Airport,
-4470,LQTZ,large_airport,Tuzla International Airport,44.459858,18.723627,784,EU,BA,BA-BIH,Dubrave Gornje,yes,LQTZ,TZL,LQTZ,,http://www.tuzla-airport.ba/,https://en.wikipedia.org/wiki/Tuzla_International_Airport,
-4472,LRBC,large_airport,Bacău George Enescu International  Airport,46.5219,26.910299,607,EU,RO,RO-BC,Bacău,yes,LRBC,BCM,LRBC,,http://www.bacauairport.ro/,https://en.wikipedia.org/wiki/Bac%C4%83u_International_Airport,"Bacau, RoAF 95th Air Base"
-333670,LRBV,large_airport,Brașov-Ghimbav International Airport,45.70558,25.522871,1740,EU,RO,RO-BV,Brașov (Ghimbav),yes,LRBV,GHV,LRBV,,https://brasovairport.ro/,https://en.wikipedia.org/wiki/Brașov-Ghimbav_International_Airport,Aeroportul Internațional Brașov-Ghimbav
-4475,LRCK,large_airport,Mihail Kogălniceanu International Airport,44.362202,28.4883,353,EU,RO,RO-CT,Constanța,yes,LRCK,CND,LRCK,,http://www.mk-airport.ro/,https://en.wikipedia.org/wiki/Mihail_Kog%C4%83lniceanu_International_Airport,"Constanța, Mihail Kogalniceanu, RoAF 57th Air Base"
-4476,LRCL,large_airport,Avram Iancu Cluj International Airport,46.786042,23.685733,1039,EU,RO,RO-CJ,Cluj-Napoca,yes,LRCL,CLJ,LRCL,,http://www.airportcluj.ro/,https://en.wikipedia.org/wiki/Cluj_International_Airport,Someşeni Airport
-4479,LRCV,large_airport,Craiova International Airport,44.3181,23.888599,626,EU,RO,RO-DJ,Craiova,yes,LRCV,CRA,LRCV,,http://www.aeroportcraiova.ro/,https://en.wikipedia.org/wiki/Craiova_International_Airport,
-4480,LRIA,large_airport,Iaşi International Airport,47.179633,27.621431,411,EU,RO,RO-IS,Iaşi,yes,LRIA,IAS,LRIA,,https://www.aeroport-iasi.ro/,https://en.wikipedia.org/wiki/Ia%C5%9Fi_International_Airport,"Iasi, Jassy"
-4481,LROD,large_airport,Oradea International Airport,47.025299,21.9025,465,EU,RO,RO-BH,Oradea,yes,LROD,OMR,LROD,,https://www.aeroportoradea.ro/,https://en.wikipedia.org/wiki/Oradea_International_Airport,
-4482,LROP,large_airport,Bucharest Henri Coandă International Airport,44.571792,26.103285,314,EU,RO,RO-IF,Otopeni,yes,LROP,OTP,LROP,,http://www.bucharestairports.ro/en/,https://en.wikipedia.org/wiki/Henri_Coand%C4%83_International_Airport,"BUH, Otopeni Airport, RoAF 90th Airlift Base"
-4483,LRSB,large_airport,Sibiu International Airport,45.785841,24.086666,1496,EU,RO,RO-SB,Sibiu,yes,LRSB,SBZ,LRSB,,http://www.sibiuairport.ro/,https://en.wikipedia.org/wiki/Sibiu_International_Airport,
-4485,LRSV,large_airport,Suceava Ștefan cel Mare International Airport,47.6875,26.354099,1375,EU,RO,RO-SV,Suceava,yes,LRSV,SCV,LRSV,,http://www.aeroportsuceava.ro/index_en.html,https://en.wikipedia.org/wiki/Suceava_Airport,
-4488,LRTR,large_airport,Timișoara Traian Vuia International Airport,45.809898,21.3379,348,EU,RO,RO-TM,Timişoara,yes,LRTR,TSR,LRTR,,http://www.aerotim.ro/,https://en.wikipedia.org/wiki/Traian_Vuia_International_Airport,"RoAF 93rd Air Base, Giarmata Airport, Temesvár, Temeschburg, Temeswar, Temeschwar, Тимишоара, Темишвар, Temišvar, Banat"
-4490,LSGG,large_airport,Geneva International Airport,46.238098,6.10895,1411,EU,CH,CH-GE,Geneva,yes,LSGG,GVA,LSGG,,https://www.gva.ch/,https://en.wikipedia.org/wiki/Geneva_Airport,Cointrin Airport
-4505,LSZH,large_airport,Zürich Airport,47.458056,8.548056,1417,EU,CH,CH-ZH,Zurich,yes,LSZH,ZRH,LSZH,,http://www.zurich-airport.com/,https://en.wikipedia.org/wiki/Zurich_Airport,
-317457,LTFM,large_airport,İstanbul Airport,41.274874,28.732136,325,EU,TR,TR-34,Istanbul,yes,LTFM,IST,LTFM,,https://www.istairport.com/,https://en.wikipedia.org/wiki/Istanbul_Airport,Arnavutköy
-4571,LUKK,large_airport,Chişinău International Airport,46.92774,28.931704,399,EU,MD,MD-CU,Chişinău,yes,LUKK,RMO,LUKK,,http://www.airport.md/,https://en.wikipedia.org/wiki/Chi%C5%9Fin%C4%83u_International_Airport,KIV
-4572,LWOH,large_airport,Ohrid St. Paul the Apostle Airport,41.18,20.7423,2313,EU,MK,MK-003,Ohrid,yes,LWOH,OHD,LWOH,,https://ohd.airports.com.mk/,https://en.wikipedia.org/wiki/Ohrid_Airport,
-4573,LWSK,large_airport,Skopje International Airport,41.958087,21.622581,781,EU,MK,MK-008,Ilinden,yes,LWSK,SKP,LWSK,,http://skp.airports.com.mk/,https://en.wikipedia.org/wiki/Skopje_Airport,Petrovec
-4574,LXGB,large_airport,Gibraltar Airport,36.151679,-5.34978,12,EU,GI,GI-U-A,Gibraltar,yes,LXGB,GIB,LXGB,,https://www.gibraltarairport.gi/,https://en.wikipedia.org/wiki/Gibraltar_Airport,
-4610,LYBE,large_airport,Belgrade Nikola Tesla Airport,44.818401,20.309099,335,EU,RS,RS-00,Belgrade,yes,LYBE,BEG,LYBE,,http://www.beg.aero/,https://en.wikipedia.org/wiki/Belgrade_Nikola_Tesla_Airport,"Beograd, Surčin Airport"
-4612,LYNI,large_airport,Niš Constantine the Great Airport,43.336538,21.856242,648,EU,RS,RS-20,Niš,yes,LYNI,INI,LYNI,,https://ini.aerodromisrbije.rs/en/,https://en.wikipedia.org/wiki/Ni%C5%A1_Constantine_the_Great_Airport,Aerodrom Konstantin Veliki Niš
-4613,LYPG,large_airport,Podgorica Airport / Podgorica Golubovci Airbase,42.359402,19.2519,141,EU,ME,ME-16,Podgorica,yes,LYPG,TGD,LYPG,,https://montenegroairports.com/en/podgorica-airport/,https://en.wikipedia.org/wiki/Podgorica_Airport,"Podgorica Airbase, Golubovci Airbase, Аеродром Подгорица, Aerodrom Podgorica"
-4617,LZIB,large_airport,M. R. Štefánik Airport,48.1702,17.2127,436,EU,SK,SK-BL,Bratislava,yes,LZIB,BTS,LZIB,,,https://en.wikipedia.org/wiki/M._R._%C5%A0tef%C3%A1nik_Airport,
-6467,UKBB,large_airport,Boryspil International Airport,50.345001,30.894699,427,EU,UA,UA-32,Boryspil,no,UKBB,KBP,UKBB,,https://kbp.aero/en/,https://en.wikipedia.org/wiki/Boryspil_International_Airport,"Borispol, Міжнародний аеропорт ""Бориспіль"", Kyiv"
-6474,UKFF,large_airport,Simferopol International Airport,45.0522,33.975101,639,EU,UA,UA-43,Simferopol,no,UKFF,SIP,UKFF,URFF,https://new.sipaero.ru/,https://en.wikipedia.org/wiki/Simferopol_International_Airport,
-6481,UKLL,large_airport,Lviv International Airport,49.8125,23.9561,1071,EU,UA,UA-46,Lviv,no,UKLL,LWO,UKLL,,http://www.airport.lviv.ua/index.php?id=home&L=1,https://en.wikipedia.org/wiki/Lviv_International_Airport,"Міжнародний аеропорт ""Львів"""
-6487,UKOO,large_airport,Odesa International Airport,46.427196,30.672649,172,EU,UA,UA-51,Odesa,no,UKOO,ODS,,,https://www.airport.od.ua/,https://en.wikipedia.org/wiki/Odessa_International_Airport,"ODS, UKOO, УКОО, Odesa Central, Міжнародний аеропорт Одеса, Odessa Airport"
-6489,ULLI,large_airport,Pulkovo Airport,59.800301,30.262501,78,EU,RU,RU-SPE,St. Petersburg,yes,ULLI,LED,ULLI,,https://pulkovoairport.ru/,https://en.wikipedia.org/wiki/Pulkovo_Airport,"Аэропо́рт Пу́лково, Leningrad, Shosseynaya Airport, Saint Petersburg, Petrograd"
-6490,ULMM,large_airport,Emperor Nicholas II Murmansk Airport,68.7817,32.750801,266,EU,RU,RU-MUR,Murmansk,yes,ULMM,MMK,ULMM,,http://www.airport-murmansk.ru/,https://en.wikipedia.org/wiki/Murmansk_Airport,"Аэропо́рт Му́рманска им. Николая II or Аэропорт Мурмаши, Мурманск"
-6495,UMBB,large_airport,Brest International Airport,52.108138,23.89676,468,EU,BY,BY-BR,Brest,yes,UMBB,BQT,UMBB,,https://www.ban.by/filialy/brest,https://en.wikipedia.org/wiki/Brest_Airport,Аэропорт Брест
-6498,UMKK,large_airport,Khrabrovo Airport,54.89161,20.598559,42,EU,RU,RU-KGD,Kaliningrad,yes,UMKK,KGD,UMKK,,https://kgdavia.ru/,https://en.wikipedia.org/wiki/Khrabrovo_Airport,"УМКК, Храброво"
-6501,UMMS,large_airport,Minsk National Airport,53.888071,28.039964,670,EU,BY,BY-MI,Minsk,yes,UMMS,MSQ,UMMS,,http://airport.by/en,https://en.wikipedia.org/wiki/Minsk_National_Airport,"Нацыянальны аэрапорт, Minsk 2 Airport"
-6507,UNNT,large_airport,Novosibirsk Tolmachevo Airport,55.019756,82.618675,365,EU,RU,RU-NVS,Novosibirsk,yes,UNNT,OVB,UNNT,,http://eng.tolmachevo.ru/,https://en.wikipedia.org/wiki/Tolmachevo_Airport,
-6512,URKK,large_airport,Krasnodar Pashkovsky International Airport,45.034465,39.174215,118,EU,RU,RU-KDA,Krasnodar,yes,URKK,KRR,URKK,,https://krr.aero/en/,https://en.wikipedia.org/wiki/Pashkovsky_Airport,"Pashkovskiy Airport, Pashkovsky Airport"
-6514,URMM,large_airport,Mineralnye Vody Airport,44.225101,43.081902,1054,EU,RU,RU-STA,Mineralnyye Vody,yes,URMM,MRV,URMM,,,https://en.wikipedia.org/wiki/Mineralnye_Vody_Airport,
-326363,URRP,large_airport,Platov International Airport,47.493888,39.924722,213,EU,RU,RU-ROS,Rostov-on-Don,no,URRP,ROV,URRP,,,https://en.wikipedia.org/wiki/Platov_International_Airport,"УРРП, Международный аэропорт Платов"
-6519,URSS,large_airport,Sochi International Airport,43.449902,39.9566,89,EU,RU,RU-KDA,Sochi,yes,URSS,AER,URSS,,https://aer.aero/en,https://en.wikipedia.org/wiki/Sochi_International_Airport,"Adler Airport, Black Sea, Международный Аэропорт Сочи"
-6522,URWW,large_airport,Volgograd International Airport,48.78134,44.339194,482,EU,RU,RU-VGG,Volgograd,yes,URWW,VOG,URWW,,,https://en.wikipedia.org/wiki/Volgograd_International_Airport,"Gumrak Airport, Аэропорт Волгоград, Аэропорт Гумрак"
-26395,UUDL,large_airport,Golden Ring Yaroslavl International Airport,57.560699,40.157398,287,EU,RU,RU-YAR,Tunoshna,yes,UUDL,IAR,UUDL,,,https://en.wikipedia.org/wiki/Tunoshna,
-26396,UUEE,large_airport,Sheremetyevo International Airport,55.976858,37.41121,622,EU,RU,RU-MOS,Moscow,yes,UUEE,SVO,UUEE,,http://svo.aero/,https://en.wikipedia.org/wiki/Sheremetyevo_International_Airport,"УУЕЕ, Москва, MOW, Международный аэропорт Шереметьево, Alexander S. Pushkin"
-26403,UWGG,large_airport,Nizhny Novgorod / Strigino International Airport,56.227351,43.785152,256,EU,RU,RU-NIZ,Nizhny Novgorod,yes,UWGG,GOJ,UWGG,,http://www.airportnn.ru/en/,https://en.wikipedia.org/wiki/Nizhny_Novgorod_International_Airport,"УВГГ, ЬВГГ, Нижний Новгород / Стригино"
-42965,UWPS,large_airport,Saransk International Airport,54.12513,45.212257,676,EU,RU,RU-MO,Saransk,yes,UWPS,SKX,UWPS,,,https://en.wikipedia.org/wiki/Saransk_Airport,Аэропорт Саранск
-26411,UWUU,large_airport,Ufa International Airport,54.557499,55.874401,449,EU,RU,RU-BA,Ufa,yes,UWUU,UFA,UWUU,,http://www.airportufa.ru/en/,https://en.wikipedia.org/wiki/Ufa_International_Airport,"УВУУ, Международный аэропорт Уфа"
-26412,UWWW,large_airport,Kurumoch International Airport,53.504902,50.164299,477,EU,RU,RU-SAM,Samara,yes,UWWW,KUF,UWWW,,https://kuf.aero/en/,https://en.wikipedia.org/wiki/Kurumoch_International_Airport,"УВВВ, Самара / Курумоч"

docker-compose.ci.yml

@@ -14,6 +14,11 @@ services:
     image: flight-ops-ci
     environment:
       FLIGHT_TEST_HOOKS: "1"
+      # v0.65.0: shorten the pool refill cooldowns to seconds so e2e can watch taken slots come back;
+      # the job LIFETIME stays at its 1 h default on purpose — state.spec.ts restarts the container
+      # mid-suite and must not race a whole board expiring (the expire-package hook ages jobs instead).
+      FLIGHT_JOB_REFILL_MS: "5000"
+      FLIGHT_JOB_SMALL_REFILL_MS: "2000"
     volumes:
       # Self-hosted map-asset pack (styles/fonts/sprites): the workflow downloads it into ./public
       # before build; absent/empty → app falls back to remote OFM styles. Mirrors docker-compose.yml's

docker-compose.yml

@@ -6,13 +6,12 @@ services:
     volumes:
       - "./public:/app/public"
       # Game state SQLite (v0.6.0): seeded on first run, must survive rebuilds.
-      # Dedicated dir — do NOT mount over /app/data (would mask airports_eu.csv).
+      # Dedicated dir — do NOT mount over /app/data (would mask airports_world.csv).
       - "./db:/app/db"
-    environment:
+    # No environment on purpose (#135, v0.62.0): FLIGHT_TEST_HOOKS must NOT be set in production —
-      # e2e-only affordance (v0.7.0): enables POST /api/test/create-package and
+    # it enables the /api/test/* hooks AND makes tickOnce honor legacy stored timeScale values
-      # /api/test/expire-package so the suites can force known routes/expiries;
+    # (pre-v0.52.0 saves hold 1000). The e2e suite runs only in CI against docker-compose.ci.yml,
-      # 404 without this var.
+    # which sets the var itself.
-      FLIGHT_TEST_HOOKS: "1"
     networks:
       - dev_net
     labels:

e2e/actions.spec.ts

@@ -14,7 +14,8 @@ import { windBurnFactor } from '../lib/sim/movement';
 // penalty while grounded; expired packages deliver/abandon with no reward and no
 // penalty. Mirrors lib/game/penalty.ts for exact-value assertions.
 
-const SCALE = 1000; // fastest sim speed (v0.14.0 ladder top) — keeps flights to seconds of real time
+const SCALE = 1000; // test rate for fast-forwarding legs — keeps flights to seconds of real time
+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)
 
 // Mirrors lib/sim/movement.ts (v0.16.0 weight-proportional burn).
@@ -39,7 +40,7 @@ function penaltyFor(reward: number, createdSimTime: number, deadlineSimTime: num
 
 interface StateBody {
   account: { cash: number; reputation: number };
-  simState: { clockMs: number; timeScale: number; paused: boolean };
+  simState: { clockMs: number }; // ISS-117: the snapshot carries only the game clock
   planes: Array<{ id: string; status: string; fuel: number; maxFuel: number; locationIcao: string; destIcao: string | null }>;
   packages: Array<{
     id: string; originIcao: string; destIcao: string; reward: number; cargoType: string; cargoCount: number;
@@ -49,9 +50,14 @@ interface StateBody {
 }
 
 async function getState(page: Page): Promise<StateBody> {
+  // ISS-127: /api/state intermittently 500s under scale-1000 dind load; a throw here would
+  // instantly fail any expect.poll callback, so retry briefly instead.
+  for (let attempt = 1; ; attempt++) {
     const res = await page.request.get('/api/state');
-  expect(res.ok()).toBeTruthy();
+    if (res.status() === 200) return (await res.json()) as StateBody;
-  return (await res.json()) as StateBody;
+    if (attempt >= 3) throw new Error(`/api/state returned ${res.status()} after 3 attempts`);
+    await page.waitForTimeout(500);
+  }
 }
 
 // The e2e instance runs with FLIGHT_TEST_HOOKS=1 (docker-compose.yml) — the hook is live.
@@ -69,11 +75,6 @@ async function createPackage(
   return (await res.json()) as StateBody['packages'][number];
 }
 
-async function postSim(page: Page, body: Record<string, unknown>): Promise<void> {
-  const res = await page.request.post('/api/sim', { data: body });
-  expect(res.ok()).toBeTruthy();
-}
-
 // Test hook (FLIGHT_TEST_HOOKS=1): top a plane's tank back to full — replaces the removed /refuel
 // endpoint (ISS-082). Reads maxFuel from the snapshot so no catalog mirror is needed.
 async function setFuelFull(page: Page, planeId: string): Promise<void> {
@@ -82,15 +83,39 @@ 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);
 }
 
-// Set the time scale and VERIFY from the response that it stuck — if something external ever
+// Test hook (FLIGHT_TEST_HOOKS=1): set the world rate and VERIFY from the response that it stuck —
-// resets the live instance's controls mid-test, fail loudly here instead of timing out later.
+// if something external ever resets the live instance's controls mid-test, fail loudly here instead of timing out later.
-// ISS-041 also clears pause: a landing pauses the sim, so any fast-forward after one must
-// resume it or the clock stays frozen and the next wait hangs.
 async function setScale(page: Page, scale: number): Promise<void> {
-  const res = await page.request.post('/api/sim', { data: { timeScale: scale, paused: false } });
+  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/sim`).toBe(scale);
+  expect(body.timeScale, `timeScale should be ${scale} after POST /api/test/set-timescale`).toBe(scale);
+}
+
+// Test hook (FLIGHT_TEST_HOOKS=1): force a plane's health and/or repair gate — same shape as e2e/sim.spec.ts.
+async function setHealth(page: Page, planeId: string, fields: Record<string, unknown>): Promise<void> {
+  const res = await page.request.post('/api/test/set-health', { data: { planeId, ...fields } });
+  expect(res.status()).toBe(200);
+}
+
+// A fully grounded fleet freezes the world clock (#135) — put the starter in repair so the clock
+// runs at FULL scale for tests that need fast-forwarding. The €1.5k repair cost is why the expiry
+// test captures its cash/rep baseline AFTER deactivateWorld; deactivateWorld restores full health
+// and no gate afterwards.
+async function activateWorld(page: Page): Promise<void> {
+  await setHealth(page, 'plane-starter', { health: 50 });
+  expect((await page.request.post('/api/planes/plane-starter/repair')).status()).toBe(200);
+}
+
+// Shorten the repair gate to "now" — the next advancing tick flips the plane back to available.
+async function deactivateWorld(page: Page): Promise<void> {
+  await setHealth(page, 'plane-starter', { health: 100, repairUntilMs: 0 });
+  await expect
+    .poll(async () => (await getState(page)).planes.find((p) => p.id === 'plane-starter')?.status ?? '', {
+      timeout: 30_000,
+      message: 'waiting for the starter to flip back to available',
+    })
+    .toBe('available');
 }
 
 // Closest airport to the hub from /api/airports → shortest possible flight. Returns both
@@ -110,10 +135,10 @@ async function nearestToHub(page: Page): Promise<{ icao: string; lat: number; lo
   return { icao: nearest.icao, lat: nearest.lat, lon: nearest.lon, hubLat: hub.lat, hubLon: hub.lon };
 }
 
-// Every spec that touches the time controls restores scale=1 / unpaused on exit so
+// Every spec that touches the world rate restores it to the fixed world rate (ISS-117) on exit so
 // a failure mid-test can't leave the live instance fast-forwarded for later specs.
 test.afterEach(async ({ page }) => {
-  await postSim(page, { timeScale: 1, paused: false });
+  await setScale(page, WORLD);
 });
 
 test.describe.configure({ mode: 'serial' }); // shared live DB — order matters within this file
@@ -142,8 +167,7 @@ async function flyHomeViaApi(page: Page): Promise<void> {
     plane = s.planes.find((p) => p.id === 'plane-starter')!;
   }
   if (plane.locationIcao !== HUB) {
-    // ISS-041: the landing above paused the sim — setScale clears pause so the return leg
+    // Make sure the world rate is back at SCALE so the return leg fast-forwards.
-    // fast-forwards instead of taking real-time hours.
     await setScale(page, SCALE);
     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)
@@ -158,6 +182,10 @@ async function flyHomeViaApi(page: Page): Promise<void> {
       expect(res.ok()).toBeTruthy();
     }
   }
+  // Run #168 retry cascade: a dirty self-heal return leg lands with a low tank, and the test's own
+  // dispatch then auto-refuels AFTER its cash baseline is captured — top up for free (test hook) so
+  // exact-cash assertions never see that cost.
+  await setFuelFull(page, 'plane-starter');
 }
 
 
@@ -197,6 +225,8 @@ test('full core loop via UI: load → fly to destination → exact reward + rep
   await expect(onboardRow, 'loaded package appears in the on-board list').toBeVisible();
   // ISS-081 (v0.40.0): the on-board route shows ICAO tags, not full airport names.
   await expect(page.getByTestId(`onboard-route-${pkg.id}`)).toContainText(`${HUB} → ${nearest.icao}`);
+  // v0.48.0 (ISS-095): leg distance on the on-board line, right after the route — integer km.
+  await expect(page.getByTestId(`onboard-distance-${pkg.id}`)).toHaveText(/^\d+km$/);
 
   // FLY via the UI: click the fly-to button in the on-board list (ISS-081: ICAO label).
   const flyBtn = page.getByTestId(`fly-to-${pkg.id}`);
@@ -253,8 +283,7 @@ test('full core loop via UI: load → fly to destination → exact reward + rep
   // ISS-082 (v0.42.0): manual refuel is gone — the return leg below auto-refuels on dispatch; the
   // exact top-up cost delta is pinned in e2e/right-pane.spec.ts instead of here.
 
-  // Restore: fly home (repositioning — no package needed in the v0.12.0 model). ISS-041: the
+  // Restore: fly home (repositioning — no package needed in the v0.12.0 model), at SCALE.
-  // arrival above paused the sim, so re-set SCALE for the return leg (setScale clears pause).
   await setScale(page, SCALE);
   const homeRes = await page.request.post(`/api/planes/${planeId}/fly`, { data: { destIcao: HUB } });
   expect(homeRes.ok()).toBeTruthy();
@@ -302,7 +331,6 @@ 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
   await flyHomeViaApi(page);
-  const before = await getState(page);
 
   // A: load, let it expire while loaded, then FLY to its destination — arrival must
   // unbind it WITHOUT paying out. B: load, let it expire, abandon for free. B's
@@ -316,12 +344,23 @@ test('expired packages deliver and abandon with no reward and no penalty', async
     expect(res.ok()).toBeTruthy();
   }
 
+  // A fully grounded fleet freezes the world clock (#135) — put the starter in repair for the expiry
+  // window so scale 1000 can fast-forward past both deadlines quickly. The €1.5k repair cost is why
+  // the cash/rep baseline below is captured AFTER deactivateWorld, not before it.
+  await activateWorld(page);
+  try {
     // Fast-forward past both deadlines — the tick flips loaded → expired (slot kept).
     await setScale(page, SCALE);
     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);
     expect(s.packages.find((p) => p.id === pkgB.id)!.status).toBe('expired');
+  } finally {
+    await deactivateWorld(page);
+  }
+
+  const before = await getState(page); // baseline AFTER the repair cost — no-reward assertions compare against this
+  let s = before;
 
   // Fly to the destination — arrival unbinds A for free (no reward, no rep).
   const flyRes = await page.request.post('/api/planes/plane-starter/fly', { data: { destIcao: 'LEMD' } });
@@ -343,8 +382,7 @@ 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. ISS-041: the LEMD arrival above paused the sim, so
+  // Restore: top up + fly home at SCALE.
-  // re-set SCALE for the return leg (setScale clears pause; the expiry wait's scale is kept).
   await setFuelFull(page, 'plane-starter');
   await setScale(page, SCALE);
   const homeRes = await page.request.post('/api/planes/plane-starter/fly', { data: { destIcao: HUB } });
@@ -384,8 +422,7 @@ test('load and fly validation paths (404 / 409 / 400)', async ({ page }) => {
   res = await page.request.post(`/api/packages/${pkg.id}/abandon`);
   expect(res.status()).toBe(409);
 
-  // Fly home from the hop so the fuel section starts at the hub. ISS-041: the hop arrival above
+  // Fly home from the hop so the fuel section starts at the hub, at SCALE.
-  // paused the sim, so re-set SCALE for this leg (setScale clears pause).
   await setScale(page, SCALE);
   res = await page.request.post('/api/planes/plane-starter/fly', { data: { destIcao: HUB } });
   expect(res.ok()).toBeTruthy();

e2e/admin.spec.ts

@@ -0,0 +1,111 @@
+import { expect, test } from '@playwright/test';
+
+// v0.71.0 — Admin panel e2e: top-bar button → modal with login form; wrong credentials show an
+// error; a session minted by the /api/test/admin-session hook (FLIGHT_TEST_HOOKS=1) authenticates
+// WITHOUT the real admin password ever appearing in test code; then the generic DB grid is
+// exercised end-to-end: table list → edit + save a cell (verified by an independent re-fetch) →
+// add a row → delete it → logout back to the login form.
+
+const SESSION_KEY = 'flight.session'; // must match components/AdminPanel.tsx
+
+async function mintAdminSession(page: import('@playwright/test').Page): Promise<string> {
+  const res = await page.request.post('/api/test/admin-session');
+  expect(res.status(), 'admin-session hook should be enabled in the CI stack (FLIGHT_TEST_HOOKS=1)').toBe(200);
+  return ((await res.json()) as { sessionId: string }).sessionId;
+}
+
+test('admin panel: login form, wrong-creds error, session auth, DB grid CRUD, logout', async ({ page }) => {
+  await page.goto('/');
+  const adminBtn = page.getByTestId('admin-btn');
+  await expect(adminBtn).toBeVisible({ timeout: 30_000 });
+
+  // --- Open the modal: no stored session → login form.
+  await adminBtn.click();
+  const dialog = page.locator('[role="dialog"]');
+  await expect(dialog).toBeVisible();
+  await expect(page.getByTestId('admin-username')).toBeVisible();
+  await expect(page.getByTestId('admin-password')).toBeVisible();
+
+  // --- Wrong credentials → error line (the seeded admin's plaintext is never used here).
+  await page.getByTestId('admin-username').fill('kamilkrzywda');
+  await page.getByTestId('admin-password').fill('wrong-password-on-purpose');
+  await page.getByTestId('admin-login-submit').click();
+  await expect(page.getByTestId('admin-error')).toBeVisible({ timeout: 10_000 });
+
+  // --- Authenticate via the test hook + localStorage, then reopen the panel.
+  const sessionId = await mintAdminSession(page);
+  // Both values must be passed as arguments — the function runs in the browser, where Node-side
+  // variables are not in scope.
+  await page.evaluate(([key, sid]) => window.localStorage.setItem(key, sid), [SESSION_KEY, sessionId]);
+  await page.reload();
+  await expect(adminBtn).toBeVisible({ timeout: 30_000 });
+  await adminBtn.click();
+
+  // --- Authenticated admin → table list including packages and users.
+  const tables = page.getByTestId('admin-tables');
+  await expect(tables).toBeVisible({ timeout: 30_000 });
+  await expect(page.getByTestId('admin-table-packages')).toBeVisible();
+  await expect(page.getByTestId('admin-table-users')).toBeVisible();
+
+  // --- Open packages, edit one cell, Save; verify via an INDEPENDENT re-fetch of the same route.
+  await page.getByTestId('admin-table-packages').click();
+  const grid = page.getByTestId('admin-rows');
+  await expect(grid).toBeVisible({ timeout: 30_000 });
+
+  const rowidCell = page.getByTestId('admin-cell-0-__rowid');
+  const originalRowid = Number(await rowidCell.inputValue());
+  expect(Number.isInteger(originalRowid)).toBeTruthy();
+
+  const rewardCell = page.getByTestId('admin-cell-0-reward');
+  await rewardCell.fill('987654');
+  await page.getByTestId('admin-save-0').click();
+
+  // The grid re-fetches after save — the edited cell shows the new value…
+  await expect(rewardCell).toHaveValue('987654', { timeout: 15_000 });
+  // …and an independent request (not the grid's) confirms it persisted server-side.
+  const check = await page.request.get('/api/admin/tables/packages/rows?limit=500', {
+    headers: { 'X-Flight-Session': sessionId },
+  });
+  expect(check.status()).toBe(200);
+  const fetched = (await check.json()) as { rows: Array<Record<string, unknown>> };
+  const row = fetched.rows.find((r) => Number(r.__rowid) === originalRowid);
+  expect(row, 'edited packages row must still exist').toBeTruthy();
+  expect(Number(row?.reward)).toBe(987654);
+
+  // --- Add a row (users table — fewest required columns), then delete it again.
+  await page.getByTestId('admin-back').click();
+  await expect(tables).toBeVisible();
+  await page.getByTestId('admin-table-users').click();
+  const usersGrid = page.getByTestId('admin-rows');
+  await expect(usersGrid).toBeVisible({ timeout: 30_000 });
+
+  const existingRows = await page.getByTestId(/admin-save-\d+/).count();
+  await page.getByTestId('admin-add-row').click();
+  const n = existingRows; // the new empty row is appended last
+  await page.getByTestId(`admin-cell-${n}-id`).fill('user-e2e-admin-test');
+  await page.getByTestId(`admin-cell-${n}-username`).fill('e2e-admin-user');
+  await page.getByTestId(`admin-cell-${n}-password_hash`).fill('aa$bb'); // any string — dev-tool insert, not a real credential
+  await page.getByTestId(`admin-cell-${n}-created_at`).fill(String(Date.now()));
+  await page.getByTestId(`admin-save-${n}`).click();
+
+  // The inserted row is visible after the grid's post-save re-fetch.
+  const bodyRows = usersGrid.locator('tbody tr');
+  const findUserRow = async (): Promise<number> => {
+    const count = await bodyRows.count();
+    for (let i = 0; i < count; i++) {
+      if ((await page.getByTestId(`admin-cell-${i}-username`).inputValue()) === 'e2e-admin-user') return i;
+    }
+    return -1;
+  };
+  await expect.poll(findUserRow, { timeout: 15_000 }).toBeGreaterThanOrEqual(0);
+  const addedIdx = await findUserRow();
+
+  // Delete it again — gone after the post-delete re-fetch.
+  await page.getByTestId(`admin-delete-${addedIdx}`).click();
+  await expect.poll(findUserRow, { timeout: 15_000 }).toBe(-1);
+
+  // --- Logout returns to the login form.
+  await page.getByTestId('admin-logout').click();
+  await expect(page.getByTestId('admin-username')).toBeVisible({ timeout: 10_000 });
+  await expect(tables).toBeHidden();
+});

e2e/api.spec.ts

@@ -13,26 +13,31 @@ test('GET /api/version returns the app version from package.json', async ({ page
   expect(body.version).toBe(pkg.version);
 });
 
-test('GET /api/openapi serves the spec with all thirteen endpoints and the package.json version', async ({ page }) => {
+test('GET /api/openapi serves the spec with all seventeen endpoints and the package.json version', async ({ page }) => {
   const res = await page.request.get('/api/openapi');
   expect(res.status()).toBe(200);
   expect(res.headers()['content-type']).toContain('application/json');
   const spec = (await res.json()) as { info: { title: string; version: string }; paths: Record<string, unknown> };
   expect(spec.info.title).toBe('Flight Ops API');
   expect(spec.info.version).toBe(pkg.version);
-  // v0.12.0 swaps the contract accept/dispatch pair for package load/abandon + plane fly.
+  // v0.12.0 swaps the contract accept/dispatch pair for package load/abandon + plane fly;
+  // v0.71.0 adds the admin panel (login/logout/me + guarded DB CRUD).
   expect(Object.keys(spec.paths).sort()).toEqual([
+    '/api/admin/tables', // v0.71.0 — admin panel
+    '/api/admin/tables/{name}/rows', // v0.71.0 — GET+PUT+POST+DELETE on one path
     '/api/airports',
+    '/api/events', // v0.57.0 (ISS-129) — SSE state stream
+    '/api/login', // v0.71.0 — admin panel auth
+    '/api/logout', // v0.71.0
     '/api/market/buy-plane',
     '/api/market/sell-plane',
+    '/api/me', // v0.71.0
     '/api/packages/{id}/abandon',
-    '/api/packages/{id}/ignore', // v0.29.0 (ISS-047 part B)
     '/api/packages/{id}/load',
     '/api/planes/{planeId}/fly',
     '/api/planes/{planeId}/queue',
     '/api/planes/{planeId}/queue/cancel',
     '/api/planes/{planeId}/repair', // v0.39.0 (ISS-069)
-    '/api/sim',
     '/api/state',
     '/api/version',
   ]);

e2e/events.spec.ts

@@ -0,0 +1,77 @@
+import { test, expect } from '@playwright/test';
+
+// ISS-129 (v0.57.0): /api/events pushes full state snapshots over SSE — the current snapshot on
+// connect, then one after every sim tick (~1 s; the background tick runs even while idle since
+// v0.56.0, so no scale hook is needed). Reached via the same base URL as playwright.config.ts
+// (E2E_BASE_URL, defaulting to the live instance) — node-side fetch, no browser involved.
+const baseUrl = process.env.E2E_BASE_URL ?? 'https://flight.dev.kkhost.pl';
+
+interface StateBody {
+  simState: { clockMs: number };
+  packages?: Array<{ status: string }>;
+}
+
+// ISS-133 (v0.59.0): frames carry only the package statuses the client renders — terminal history
+// (delivered/abandoned) is unbounded in the DB and must never leak into a pushed frame.
+const ALLOWED_PACKAGE_STATUSES = new Set(['open', 'loaded', 'expired']);
+
+test('GET /api/events streams state snapshots over SSE', async () => {
+  const res = await fetch(`${baseUrl}/api/events`, { headers: { Accept: 'text/event-stream' } });
+  expect(res.status).toBe(200);
+  expect(res.headers.get('content-type')).toContain('text/event-stream');
+  expect(res.body).not.toBeNull();
+
+  const reader = res.body!.getReader();
+  const decoder = new TextDecoder();
+  let buffer = '';
+  const clocks: number[] = []; // simState.clockMs of each parsed snapshot event
+  const statusesSeen = new Set<string>(); // package statuses observed in any frame (ISS-133)
+  let maxFrameBytes = 0;
+
+  try {
+    // Collect two snapshot events: the initial one, then at least one pushed by a background tick.
+    const deadline = Date.now() + 15_000;
+    while (clocks.length < 2 && Date.now() < deadline) {
+      let chunk: ReadableStreamReadResult<Uint8Array>;
+      try {
+        chunk = await Promise.race([
+          reader.read(),
+          new Promise<never>((_, reject) =>
+            setTimeout(() => reject(new Error('SSE stream stalled')), Math.max(1, deadline - Date.now())),
+          ),
+        ]);
+      } catch {
+        break; // stalled or past the deadline — let the length assertion report it
+      }
+      if (chunk.done) break; // stream ended early — same
+      buffer += decoder.decode(chunk.value, { stream: true });
+      let sep: number;
+      while ((sep = buffer.indexOf('\n\n')) >= 0) {
+        const frame = buffer.slice(0, sep);
+        buffer = buffer.slice(sep + 2);
+        for (const line of frame.split('\n')) {
+          if (!line.startsWith('data: ')) continue; // heartbeats are comment lines (" : ping")
+          const snap = JSON.parse(line.slice('data: '.length)) as StateBody;
+          clocks.push(snap.simState.clockMs);
+          for (const p of snap.packages ?? []) statusesSeen.add(p.status);
+          maxFrameBytes = Math.max(maxFrameBytes, line.length);
+        }
+      }
+    }
+  } finally {
+    await reader.cancel(); // close the stream → server unsubscribes
+  }
+
+  // The initial snapshot arrives on connect; the second comes from a background tick within ~1 s.
+  // A grounded fleet freezes the clock (#135), so consecutive frames may carry the SAME clockMs —
+  // non-decreasing is what proves real pushes, not replays (advance itself is pinned in sim.spec.ts).
+  expect(clocks.length).toBeGreaterThanOrEqual(2);
+  expect(clocks[1]).toBeGreaterThanOrEqual(clocks[0]);
+
+  // ISS-133: no terminal package history in any frame (the DB keeps it forever; frames must not),
+  // and a bounded frame size even on an instance with long-running history (~597 KB pre-v0.59.0).
+  for (const status of statusesSeen) {
+    expect(ALLOWED_PACKAGE_STATUSES.has(status)).toBe(true);
+  }
+  expect(maxFrameBytes).toBeLessThan(200_000);
+});

e2e/expiry.spec.ts

@@ -0,0 +1,92 @@
+import type { Page } from '@playwright/test';
+import { expect, test } from '@playwright/test';
+// Real helpers (v0.54.0) — the expiry floor must match lib/ exactly; Playwright resolves the repo's
+// tsconfig paths, so importing beats mirroring a third copy of the constants/formulas.
+import { haversineKm } from '../lib/geo';
+import { travelDurationMs } from '../lib/sim/movement';
+import { FASTEST_CATALOG_SPEED_KMH } from '../lib/game/catalog';
+import { EXPIRY_BUFFER_MS } from '../lib/game/seed';
+
+// v0.54.0 (ISS-119) — long priority jobs must be finishable: a package's deadline is clamped up to
+// now + travel time at the fastest catalog speed + buffer, so no generated job can expire before even
+// the best plane could land. The EXISTING POST /api/test/create-package hook (FLIGHT_TEST_HOOKS=1)
+// forces a far-apart endpoint pair (~9000 km, at MAX_JOB_LEG_KM); this spec asserts the invariant on
+// every returned package — no new server hooks needed. No scale changes, plane interaction, polling or
+// map queries are involved (the assertion is self-contained in the hook response), so none of those
+// conventions apply here.
+
+const FROM = 'EDDB'; // Berlin Brandenburg
+const TO = 'KSMF'; // Sacramento International — ~9000 km from EDDB, at MAX_JOB_LEG_KM
+const COUNT = 10; // priority packages created and checked
+
+interface Pkg {
+  id: string;
+  originIcao: string;
+  destIcao: string;
+  createdSimTime: number;
+  deadlineSimTime: number;
+}
+
+async function createPriorityPackage(page: Page, from: string, to: string): Promise<Pkg> {
+  const res = await page.request.post('/api/test/create-package', { data: { originIcao: from, destIcao: to, special: 'priority' } });
+  expect(res.status()).toBe(201);
+  return (await res.json()) as Pkg;
+}
+
+test('long-leg priority packages always expire after travel time at max speed + buffer', async ({ page }) => {
+  // The pair's real coordinates from the live dataset — the floor is computed on the same km the server uses.
+  const res = await page.request.get('/api/airports');
+  expect(res.ok()).toBeTruthy();
+  const fc = (await res.json()) as { features: Array<{ properties: { icao: string; lat: number; lon: number } }> };
+  const from = fc.features.find((f) => f.properties.icao === FROM)?.properties;
+  const to = fc.features.find((f) => f.properties.icao === TO)?.properties;
+  expect(from, `${FROM} missing from the airport dataset`).toBeTruthy();
+  expect(to, `${TO} missing from the airport dataset`).toBeTruthy();
+  if (!from || !to) return; // guarded above — keeps the math below total
+
+  const km = haversineKm(from.lat, from.lon, to.lat, to.lon);
+  expect(km).toBeGreaterThan(7_000); // guard: the pair must still be a long leg or this test is vacuous
+  const floorMs = travelDurationMs(km, FASTEST_CATALOG_SPEED_KMH) + EXPIRY_BUFFER_MS;
+
+  const created: Pkg[] = [];
+  try {
+    for (let i = 0; i < COUNT; i++) {
+      const pkg = await createPriorityPackage(page, FROM, TO);
+      expect(pkg.originIcao).toBe(FROM);
+      expect(pkg.destIcao).toBe(TO);
+      // The invariant (ISS-119): the deadline must leave at least travel time + buffer after creation.
+      // deadlineSimTime = round(now + offset) with offset ≥ floorMs, so this holds exactly.
+      const offsetMs = pkg.deadlineSimTime - pkg.createdSimTime;
+      expect(offsetMs).toBeGreaterThanOrEqual(Math.floor(floorMs));
+      // And the clamp must not blow past the priority ceiling (36 h) — the deadline stays sane.
+      expect(offsetMs).toBeLessThanOrEqual(36 * 3_600_000);
+      created.push(pkg);
+    }
+  } finally {
+    // Cleanup: age out every package this test created so it leaves no trace on the shared board.
+    for (const pkg of created) {
+      const r = await page.request.post('/api/test/expire-package', { data: { packageId: pkg.id } });
+      expect(r.ok(), `expiring ${pkg.id}`).toBeTruthy();
+    }
+  }
+});
+
+// v0.65.0: open jobs live on the WALL clock — JOB_LIFETIME_MS after createdRealMs they expire
+// regardless of time scale or fleet state. The age hook (FLIGHT_TEST_HOOKS=1) stamps a job past its
+// lifetime and runs a tick, so expiry is observable in one round-trip; self-contained like the test
+// above (the assertion lives in the hook response, no /api/state polling).
+test('an open job aged past its wall-clock lifetime expires on the next tick', async ({ page }) => {
+  const pkg = await createPriorityPackage(page, FROM, TO);
+
+  const res = await page.request.post('/api/test/expire-package', { data: { packageId: pkg.id } });
+  expect(res.status()).toBe(200);
+  const aged = (await res.json()) as Pkg & { status: string };
+  expect(aged.id).toBe(pkg.id);
+  expect(aged.status, 'the hook runs a tick after aging the job, so it is expired by response time').toBe('expired');
+
+  // Unknown ids and non-open jobs still 404.
+  const missing = await page.request.post('/api/test/expire-package', { data: { packageId: 'no-such-id' } });
+  expect(missing.status()).toBe(404);
+  const alreadyExpired = await page.request.post('/api/test/expire-package', { data: { packageId: pkg.id } });
+  expect(alreadyExpired.status()).toBe(404); // expired is not open — the hook only ages live jobs
+});

e2e/hover.spec.ts

@@ -11,7 +11,8 @@ import { test, expect, type Page } from '@playwright/test';
 // cargo rows and the Relocate section; the relocate preview rings only its TARGET airport, which
 // additionally gets a distinct green ring in `airports-target-highlight` (ISS-022).
 
-const SCALE = 1000; // fastest sim speed (v0.14.0 ladder top) — keeps flights to seconds of real time
+const SCALE = 1000; // test rate for fast-forwarding legs — keeps flights to seconds of real time
+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.
 const DEST = 'LEMD';
@@ -41,35 +42,34 @@ interface PackageState {
 
 interface StateBody {
   account: { cash: number; reputation: number };
-  simState: { clockMs: number; timeScale: number; paused: boolean };
+  simState: { clockMs: number }; // ISS-117: the snapshot carries only the game clock
   planes: PlaneState[];
   packages: PackageState[];
 }
 
 async function getState(page: Page): Promise<StateBody> {
+  // ISS-127: /api/state intermittently 500s under scale-1000 dind load; a throw here would
+  // instantly fail any expect.poll callback, so retry briefly instead.
+  for (let attempt = 1; ; attempt++) {
     const res = await page.request.get('/api/state');
-  expect(res.status()).toBe(200);
+    if (res.status() === 200) return (await res.json()) as StateBody;
-  return (await res.json()) as StateBody;
+    if (attempt >= 3) throw new Error(`/api/state returned ${res.status()} after 3 attempts`);
+    await page.waitForTimeout(500);
+  }
 }
 
-async function postSim(page: Page, body: unknown) {
+// Test hook (FLIGHT_TEST_HOOKS=1): set the world rate and VERIFY from the response that it stuck —
-  return page.request.post('/api/sim', { data: body });
+// a silent reset would otherwise surface as an unexplained landing-wait timeout.
-}
-
-// Set the time scale and VERIFY from the response that it stuck — a silent reset would
-// otherwise surface as an unexplained landing-wait timeout. ISS-041 also clears pause: a
-// landing pauses the sim, so any fast-forward after one must resume it or the clock stays frozen.
 async function setScale(page: Page, scale: number): Promise<void> {
-  const res = await page.request.post('/api/sim', { data: { timeScale: scale, paused: false } });
+  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/sim`).toBe(scale);
+  expect(body.timeScale, `timeScale should be ${scale} after POST /api/test/set-timescale`).toBe(scale);
 }
 
-// Leave the live instance in a sane state for the other specs (scale 1, running).
+// Leave the live instance in a sane state for the other specs (the fixed world rate).
 test.afterEach(async ({ page }) => {
-  const res = await postSim(page, { timeScale: 1, paused: false });
+  await setScale(page, WORLD);
-  expect(res.status()).toBe(200);
 });
 
 // Test hook (FLIGHT_TEST_HOOKS=1): create an open package on a known route.
@@ -89,34 +89,30 @@ 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);
 }
 
-// Self-heal: let any in-flight leg finish, then reposition plane-starter home via the API.
+// Self-heal (same pattern as e2e/panes.spec.ts): restore full health / clear any repair gate from an
+// interrupted run, let any in-flight leg finish, then reposition plane-starter home via the API.
 async function flyHomeViaApi(page: Page): Promise<void> {
-  const s0 = await getState(page);
+  // v0.39.0 (ISS-069): wear accumulates across the shared CI DB — restore full health and clear any
-  const starter = s0.planes.find((p) => p.id === 'plane-starter')!;
+  // active repair gate from an interrupted run before acting on the starter.
+  expect((await page.request.post('/api/test/set-health', { data: { planeId: 'plane-starter', health: 100, repairUntilMs: 0 } })).status()).toBe(200);
+  let s = await getState(page); // ticks — a shortened gate flips the plane back to available here
+  let starter = s.planes.find((p) => p.id === 'plane-starter')!;
   if (starter.status === 'flying' || starter.locationIcao !== HUB) {
     // Fast-forward any leftover leg / repositioning flight (~20 s real time worst case at 1000×).
     await setScale(page, SCALE);
   }
   if (starter.status === 'flying') {
-    await expect
+    // While flying, locationIcao stays at the DEPARTURE airport — re-read state after landing.
-      .poll(async () => (await getState(page)).planes.find((p) => p.id === 'plane-starter')?.status === 'available', {
+    await expect.poll(async () => ((await getState(page)).planes.find((p) => p.id === 'plane-starter')?.status ?? ''), { timeout: 240_000 }).toBe('available');
-        timeout: 240_000,
+    s = await getState(page);
-        message: 'waiting for an in-flight plane-starter to land',
+    starter = s.planes.find((p) => p.id === 'plane-starter')!;
-      })
-      .toBe(true);
   }
   if (starter.locationIcao !== HUB) {
-    // ISS-041: the landing above paused the sim — setScale clears pause so the return leg
+    // Make sure the world rate is back at SCALE so the return leg fast-forwards.
-    // fast-forwards instead of taking real-time hours.
     await setScale(page, SCALE);
     const res = await page.request.post('/api/planes/plane-starter/fly', { data: { destIcao: HUB } });
     expect(res.status()).toBe(200); // repositioning needs no package (v0.12.0 manual flight)
-    await expect
+    await expect.poll(async () => ((await getState(page)).planes.find((p) => p.id === 'plane-starter')?.locationIcao ?? ''), { timeout: 240_000 }).toBe(HUB);
-      .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);
   }
 }
 
@@ -166,8 +162,8 @@ async function unhover(page: Page): Promise<void> {
 }
 
 // Fit the map so all given airports are in-viewport — queryRenderedFeatures only returns
-// features rendered inside the CURRENT viewport, and the default Frankfurt-centered view leaves
+// features rendered inside the CURRENT viewport, and the v0.70.0 default world view ([0,0] z2) leaves
-// far endpoints (LEMD) off-screen even when they match a layer filter.
+// far endpoints (e.g. NFTF) off-screen even when they match a layer filter.
 async function fitToAirports(page: Page, icaos: string[]): Promise<void> {
   const fc = (await (await page.request.get('/api/airports')).json()) as {
     features: Array<{ properties: { icao: string; lat: number; lon: number } }>;
@@ -177,6 +173,16 @@ async function fitToAirports(page: Page, icaos: string[]): Promise<void> {
     if (!f) throw new Error(`airport ${icao} not found in /api/airports`);
     return [f.properties.lon, f.properties.lat] as [number, number];
   });
+  // ISS-120 (v0.53.0): raw min/max bounds for a pair straddling ±180 span the WRONG side of the globe
+  // (−175…+174 covers the Atlantic, not the Pacific) — unwrap each point relative to its predecessor so
+  // the bounds follow the short arc across the date line. Non-crossing pairs are unchanged.
+  for (let i = 1; i < points.length; i++) {
+    let lon = points[i]![0];
+    const prev = points[i - 1]![0];
+    while (lon - prev > 180) lon -= 360;
+    while (prev - lon > 180) lon += 360;
+    points[i]![0] = lon;
+  }
   await page.evaluate((pts: [number, number][]) => {
     const m = (window as any).__flightMap;
     if (!m) throw new Error('map not ready');
@@ -223,8 +229,13 @@ const HOVER_ROUTE_EPS_DEG = 0.05; // ~5 km: above worst-case quantization at any
 
 async function expectHoverRoute(page: Page, fromIcao: string, toIcao: string): Promise<void> {
   const [from, to] = await Promise.all([airportLonLat(page, fromIcao), airportLonLat(page, toIcao)]);
-  const near = (a: [number, number], b: [number, number]) =>
+  // ISS-120 (v0.53.0): antimeridian-crossing traces end UNWRAPPED — the dest-side endpoint is ≡ dest
-    Math.abs(a[0] - b[0]) <= HOVER_ROUTE_EPS_DEG && Math.abs(a[1] - b[1]) <= HOVER_ROUTE_EPS_DEG;
+  // (mod 360) but sits at e.g. +184.9 instead of −175.1, so compare longitudes on the circle. For any
+  // two lons within ±180 of each other this equals the plain |Δlon| — existing routes are unaffected.
+  const near = (a: [number, number], b: [number, number]) => {
+    const dLon = Math.abs(a[0] - b[0]);
+    return Math.min(dLon, 360 - dLon) <= HOVER_ROUTE_EPS_DEG && Math.abs(a[1] - b[1]) <= HOVER_ROUTE_EPS_DEG;
+  };
   await expect.poll(async () => {
     const feats = (await renderedFeatures(page, ['hover-route'])) as Array<{ geometry?: { type: string; coordinates: [number, number][] } }>;
     // Features are plain objects with in-page-evaluated geometry (see renderedFeatures). The filter
@@ -310,8 +321,7 @@ test('hovering an open package highlights its endpoint airports', async ({ page
   const row = page.locator(`li[data-testid="open-package-${pkg.id}"]`);
   await expect(row, 'the hook-created package appears in the list').toBeVisible({ timeout: 15_000 });
 
-  // Both endpoints must be in-viewport for queryRenderedFeatures to see them (LEMD is off-screen
+  // Both endpoints must be in-viewport for queryRenderedFeatures to see them.
-  // at the default Frankfurt-centered view).
   await fitToAirports(page, [HUB, DEST]);
 
   expect(await renderedFeatures(page, ['airports-highlight'])).toHaveLength(0);
@@ -350,6 +360,57 @@ test('hovering an open package highlights its endpoint airports', async ({ page
   }).toBe(0);
 });
 
+// ISS-120 (v0.53.0): Frankfurt → Fua'amotu (Tonga) — their short great circle crosses ±180 EASTWARD
+// (sampled: the raw longitude sequence jumps ~360° at the crossing, same as the original NZAA→NFTF pair).
+// Before the fix the arc's wrapped samples jumped +179.x → −179.x and MapLibre connected them with a
+// chord across the whole map; now the trace is one continuous line. v0.65.0: origin moved from NZAA to
+// EDDF — open jobs only render where a plane can take them (the pool), so the hook must create it at
+// the hub; same crossing, no relocation needed.
+test('hovering an antimeridian-crossing package draws one continuous trace, no chord across the map', async ({ page }) => {
+  test.setTimeout(300_000); // self-heal can take minutes after an interrupted run
+  await flyHomeViaApi(page);
+
+  const pkg = await createPackage(page, HUB, 'NFTF');
+
+  await page.goto('/');
+  await waitForAirportCount(page);
+
+  const row = page.locator(`li[data-testid="open-package-${pkg.id}"]`);
+  await expect(row, 'the hook-created package appears in the list').toBeVisible({ timeout: 15_000 });
+
+  // fitToAirports unwraps crossing pairs (ISS-120) so both endpoints are in-viewport. EDDF→NFTF spans
+  // ~176° of longitude — fitting it needs z≈1, below the old MIN_ZOOM=3 floor; since v0.70.0 minZoom is
+  // natively 0 (components/Map.tsx), no setMinZoom workaround is needed anymore. Quantization stays
+  // ≤~0.02° even near z=0, below EPS (:214–228).
+  await fitToAirports(page, [HUB, 'NFTF']);
+
+  await row.hover();
+  await expectHoverRoute(page, HUB, 'NFTF'); // endpoint check is mod-360 aware now (ISS-120)
+
+  // The regression itself: no rendered segment may contain a ±180 longitude jump — that was the chord.
+  await expect.poll(async () => {
+    const feats = (await renderedFeatures(page, ['hover-route'])) as Array<{ geometry?: { type: string; coordinates: [number, number][] } }>;
+    const segs = feats.filter(
+      (f): f is { geometry: { type: 'LineString'; coordinates: [number, number][] } } =>
+        !!f.geometry && f.geometry.type === 'LineString' && Array.isArray(f.geometry.coordinates) && f.geometry.coordinates.length >= 2,
+    );
+    if (!segs.length) return false; // none yet — keep polling
+    for (const s of segs) {
+      const c = s.geometry.coordinates;
+      for (let i = 1; i < c.length; i++) {
+        if (Math.abs(c[i]![0] - c[i - 1]![0]) >= 180) return false; // a wrapped jump — the chord bug is back
+      }
+    }
+    return true;
+  }, { timeout: 15_000, message: 'waiting for the hover-route trace to be continuous across the antimeridian' }).toBe(true);
+
+  await unhover(page);
+  await expect.poll(async () => (await renderedFeatures(page, ['hover-route'])).length, {
+    timeout: 15_000,
+    message: 'waiting for the hover route trace to clear after mouseleave',
+  }).toBe(0);
+});
+
 test('hovering an on-board cargo row draws its trace and keeps the plane halo', async ({ page }) => {
   test.setTimeout(300_000); // self-heal can take minutes after an interrupted run
   await flyHomeViaApi(page); // deterministic: the starter sits grounded at EDDF
@@ -472,8 +533,9 @@ test('hovering the fleet row of a flying plane highlights its route', async ({ p
   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): the route line stays drawn while paused.
+  // e2e/map-interactions.spec.ts' marker click): at scale 1 the leg takes minutes of real time, and
-  await postSim(page, { paused: true });
+  // the route line stays drawn while frozen.
+  await setScale(page, 1);
 
   await block.hover();
   await expect.poll(async () => {
@@ -489,7 +551,7 @@ test('hovering the fleet row of a flying plane highlights its route', async ({ p
 
   // Resume and fast-forward to arrival, then fly home so the live instance stays in its
   // onboarding state (starter grounded at EDDF) for the other specs.
-  await postSim(page, { timeScale: SCALE, paused: false });
+  await setScale(page, SCALE);
   await expect
     .poll(async () => {
       const p = (await getState(page)).planes.find((x) => x.id === 'plane-starter');
@@ -497,7 +559,7 @@ 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);
 
-  // ISS-041: the arrival above paused the sim, so re-set SCALE for this leg (setScale clears pause).
+  // Re-set SCALE for the return leg.
   await setScale(page, SCALE);
   const home = await page.request.post('/api/planes/plane-starter/fly', { data: { destIcao: HUB } });
   expect(home.status()).toBe(200);
@@ -535,10 +597,10 @@ test('hovering an on-board package while its carrier is mid-flight traces from t
   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
-  // auto-chain the queued EHAM leg, which would change (or empty) the trace while we assert. Paused,
+  // auto-chain the queued EHAM leg, which would change (or empty) the trace while we assert. At
-  // every /api/state snapshot reports the same state — and the new rule's start point is the LANDING
+  // scale 1 every /api/state snapshot reports the same state for minutes — and the new rule's start
-  // airport regardless of progress, so no mid-flight position window is needed at all.
+  // point is the LANDING airport regardless of progress, so no mid-flight position window is needed at all.
-  await postSim(page, { paused: true });
+  await setScale(page, 1);
 
   const row = page.locator(`[data-testid="onboard-package-${pkg.id}"]`);
   await expect(row, 'the loaded package appears in the On board section').toBeVisible({ timeout: 15_000 });
@@ -584,7 +646,7 @@ 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); // also clears the pause above
+  await setScale(page, SCALE);
   await expect
     .poll(async () => {
       const p = (await getState(page)).planes.find((x) => x.id === 'plane-starter');
@@ -595,7 +657,7 @@ 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
 
-  // ISS-041: the arrival above paused the sim, so re-set SCALE for this leg (setScale clears pause).
+  // Re-set SCALE for the return leg.
   await setScale(page, SCALE);
   const home = await page.request.post('/api/planes/plane-starter/fly', { data: { destIcao: HUB } });
   expect(home.status()).toBe(200);

e2e/maintenance.spec.ts

@@ -1,20 +1,17 @@
 import type { Page } from '@playwright/test';
 import { expect, test } from '@playwright/test';
-// Real helpers (v0.39.0) — the broken-state burn math must match lib/ exactly; Playwright resolves
+// v0.39.0 (ISS-069) — maintenance: expectations use the real balance constants.
-// the repo's tsconfig paths, so importing beats mirroring a third copy of the formulas.
+import { REPAIR_COST } from '../lib/game/catalog';
-import { initialBearingDeg } from '../lib/geo';
-import { weatherFor } from '../lib/weather';
-import { fuelAtWeighted, windBurnFactor } from '../lib/sim/movement';
-// v0.39.0 (ISS-069) — maintenance: expectations use the real balance constants + burn helpers.
-import { BROKEN_BURN_MULTIPLIER, REPAIR_COST } from '../lib/game/catalog';
 
-// v0.39.0 (ISS-069) — maintenance visible flow against the live origin: health is shown per plane in
+// v0.39.0 (ISS-069), reworked in v0.45.0 (ISS-089) — maintenance visible flow against the live
-// the fleet list; forcing it to 0 via the set-health hook shows the "broken" pill and makes a short
+// origin: health is shown per plane in the fleet list; forcing it to 0 via the set-health hook shows
-// full-tank leg burn ×1.5 more fuel (asserted with the real lib helpers); clicking Repair deducts
+// the "broken" pill and blocks dispatch with a 409 that mutates nothing; clicking Repair deducts
-// exactly REPAIR_COST, restores health and grounds the plane ("in repair" pill) until its gate
+// exactly REPAIR_COST and grounds the plane ("in repair" pill) while its health is still ~0 — the
-// passes; shortening the gate via the hook brings it back to service on the next tick.
+// engine heals it gradually over the gate, landing on exactly 100 when the (hook-shortened) gate
+// passes.
 
-const SCALE = 1000; // fastest sim speed (v0.14.0 ladder top) — keeps flights to seconds of real time
+const SCALE = 1000; // test rate for fast-forwarding legs — keeps flights to seconds of real time
+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';
 
@@ -39,24 +36,29 @@ interface CatalogEntry {
 
 interface StateBody {
   account: { cash: number };
-  simState: { clockMs: number; timeScale: number; paused: boolean };
+  simState: { clockMs: number }; // ISS-117: the snapshot carries only the game clock
   planes: PlaneState[];
   catalog: CatalogEntry[];
 }
 
 async function getState(page: Page): Promise<StateBody> {
+  // ISS-127: /api/state intermittently 500s under scale-1000 dind load; a throw here would
+  // instantly fail any expect.poll callback, so retry briefly instead.
+  for (let attempt = 1; ; attempt++) {
     const res = await page.request.get('/api/state');
-  expect(res.status()).toBe(200);
+    if (res.status() === 200) return (await res.json()) as StateBody;
-  return (await res.json()) as StateBody;
+    if (attempt >= 3) throw new Error(`/api/state returned ${res.status()} after 3 attempts`);
+    await page.waitForTimeout(500);
+  }
 }
 
-// Set the time scale and VERIFY from the response that it stuck — a silent reset would otherwise
+// Test hook (FLIGHT_TEST_HOOKS=1): set the world rate and VERIFY from the response that it stuck —
-// surface as an unexplained wait timeout. Also clears pause (ISS-041: landings slow to 1×).
+// a silent reset would otherwise surface as an unexplained wait timeout.
 async function setScale(page: Page, scale: number): Promise<void> {
-  const res = await page.request.post('/api/sim', { data: { timeScale: scale, paused: false } });
+  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/sim`).toBe(scale);
+  expect(body.timeScale, `timeScale should be ${scale} after POST /api/test/set-timescale`).toBe(scale);
 }
 
 // Test hook (FLIGHT_TEST_HOOKS=1): force a plane's health and/or shorten an active repair gate.
@@ -69,14 +71,6 @@ async function setHealth(
   return (await res.json()) as StateBody;
 }
 
-// Test hook (FLIGHT_TEST_HOOKS=1): top a plane's tank back to full — replaces the removed /refuel
-// endpoint (ISS-082). Reads maxFuel from the snapshot so no catalog mirror is needed.
-async function setFuelFull(page: Page, planeId: string): Promise<void> {
-  const s = await getState(page);
-  const p = s.planes.find((x) => x.id === planeId)!;
-  expect((await page.request.post('/api/test/set-fuel', { data: { planeId, fuel: p.maxFuel } })).status()).toBe(200);
-}
-
 // 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;
@@ -88,8 +82,7 @@ function haversineKm(lat1: number, lon1: number, lat2: number, lon2: number): nu
   return 2 * 6371 * Math.asin(Math.min(1, Math.sqrt(a)));
 }
 
-// Closest airport to EDDF from /api/airports — the short fixed leg for the broken-burn flight.
+// Closest airport to EDDF from /api/airports — any known destination for the blocked-dispatch check.
-// Returns both endpoints' coordinates so the exact-km fuel assertion 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 } }>;
@@ -138,7 +131,7 @@ async function healStarterHome(page: Page): Promise<void> {
     starter = s.planes.find((p) => p.id === STARTER)!;
   }
   if (starter.locationIcao !== HUB) {
-    // ISS-041: the landing above slowed the sim to 1× — setScale restores it for the return leg.
+    // Make sure the world rate is back at SCALE for the return leg.
     await setScale(page, SCALE);
     // 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.
@@ -165,16 +158,15 @@ async function restoreStarter(page: Page): Promise<void> {
 
 test.describe.configure({ mode: 'serial' }); // shared live DB — order matters within this file
 
-// On exit (success or failure): restore scale=1 / unpaused for the other specs (house convention)
+// On exit (success or failure): restore the fixed world rate for the other specs (house convention)
 // and leave a clean starter — full health, no active repair gate.
 test.afterEach(async ({ page }) => {
-  const res = await page.request.post('/api/sim', { data: { timeScale: 1, paused: false } });
+  await setScale(page, WORLD);
-  expect(res.status()).toBe(200);
   await restoreStarter(page);
 });
 
-test('health shown → broken burn ×1.5 → repair grounds for 3 sim days → back to service', async ({ page }) => {
+test('health shown → broken cannot fly → gradual repair → back to service', async ({ page }) => {
-  test.setTimeout(300_000); // self-heal + one short leg at 1000× + the shortened repair gate wait
+  test.setTimeout(300_000); // self-heal + the shortened repair gate wait (no flight leg since v0.45.0)
 
   await healStarterHome(page); // deterministic: the starter sits grounded at EDDF
 
@@ -188,41 +180,25 @@ test('health shown → broken burn ×1.5 → repair grounds for 3 sim days → b
   await expect(page.getByTestId(`plane-health-${STARTER}`), 'health readout shows the forced value')
     .toContainText('42%');
 
-  // (b) Force broken — the pill shows, and a short full-tank leg burns ×1.5 more fuel.
+  // (b) Force broken — the pill shows, and dispatch is blocked with a 409 that mutates nothing.
   s = await setHealth(page, { planeId: STARTER, health: 0 });
   expect(s.planes.find((p) => p.id === STARTER)!.health).toBe(0);
   await expect(page.getByTestId(`plane-broken-${STARTER}`), 'the broken pill appears')
     .toHaveText('broken', { timeout: 15_000 });
 
-  // Full tank for the flight (ISS-082 hook — dispatch would only top up to 150% of the leg, not full)…
+  // The destination is irrelevant — a broken plane must be rejected BEFORE any refuel math (v0.45.0).
-  await setFuelFull(page, STARTER);
+  const nearest = await nearestToHub(page);
+  const fuelBefore = s.planes.find((p) => p.id === STARTER)!.fuel;
+  const flyRes = await page.request.post(`/api/planes/${STARTER}/fly`, { data: { destIcao: nearest.icao } });
+  expect(flyRes.status()).toBe(409); // broken planes cannot take off…
+  expect(((await flyRes.json()) as { error: string }).error).toMatch(/broken \(health 0\)/);
+
   s = await getState(page);
   const starter = s.planes.find((p) => p.id === STARTER)!;
-  expect(starter.fuel).toBe(starter.maxFuel);
+  expect(starter.status).toBe('available'); // still grounded…
+  expect(starter.fuel).toBe(fuelBefore); // …and the auto-refuel never ran — tank untouched
 
-  // …then fly the short fixed leg HUB → nearest via the API (the UI under test is maintenance, not dispatch).
+  // (c) Repair through the UI: exact cash drop + "in repair" pill, health still ~0 (gradual heal).
-  const nearest = await nearestToHub(page);
-  expect((await page.request.post(`/api/planes/${STARTER}/fly`, { data: { destIcao: nearest.icao } })).status()).toBe(200);
-  await setScale(page, SCALE);
-  await expect
-    .poll(async () => ((await getState(page)).planes.find((p) => p.id === STARTER)?.locationIcao ?? ''), {
-      timeout: 120_000,
-      message: 'waiting for the broken plane to land at the nearest airport',
-    })
-    .toBe(nearest.icao);
-
-  // Landed fuel matches the ×1.5-adjusted closed form (real lib helpers — same pattern as right-pane.spec.ts).
-  s = await getState(page);
-  const landed = s.planes.find((p) => p.id === STARTER)!;
-  const entry = s.catalog.find((e) => e.model === starter.model)!;
-  const km = haversineKm(nearest.hubLat, nearest.hubLon, nearest.lat, nearest.lon);
-  const wHub = weatherFor(HUB);
-  const burn = entry.burnPerKm * windBurnFactor(wHub.windKt, wHub.windDirDeg, initialBearingDeg(nearest.hubLat, nearest.hubLon, nearest.lat, nearest.lon));
-  expect(landed.fuel).toBeCloseTo(fuelAtWeighted(starter.maxFuel, burn * BROKEN_BURN_MULTIPLIER, entry.emptyWeightKg, entry.maxFuel, km, 1), 6);
-  // Wear clamped at 0 — the broken plane stays broken.
-  expect(landed.health).toBe(0);
-
-  // (c) Repair through the UI: exact cash drop + "in repair" pill.
   const cashBefore = s.account.cash;
   const repairBtn = page.getByTestId(`repair-${STARTER}`);
   await expect(repairBtn, 'the Repair button shows for a grounded worn plane').toBeVisible({ timeout: 15_000 });
@@ -237,7 +213,7 @@ test('health shown → broken burn ×1.5 → repair grounds for 3 sim days → b
   expect(post.account.cash).toBeCloseTo(cashBefore - REPAIR_COST, 6); // exactly REPAIR_COST
   const repaired = post.planes.find((p) => p.id === STARTER)!;
   expect(repaired.status).toBe('repairing');
-  expect(repaired.health).toBe(100); // restored to full…
+  expect(repaired.health).toBeLessThan(5); // still ~0 — the engine heals it gradually over the gate (v0.45.0)…
   expect(repaired.repairUntilSimTime).not.toBeNull(); // …with the gate set (3 sim days out)
 
   await expect(page.getByTestId(`plane-repairing-${STARTER}`), 'the "in repair" pill appears')

e2e/map-interactions.spec.ts

@@ -14,7 +14,8 @@ const HUB = 'EDDF'; // must match HUB_ICAO in lib/game/seed.ts
 // land in ~2 s — shorter than the map poll + click pipeline). Round-trip burn (~4970 L) fits
 // the 6300 L tank, so a full-tank departure always makes it home.
 const DEST = 'LEMD';
-const SCALE = 1000; // fastest sim speed (v0.14.0 ladder top)
+const SCALE = 1000; // test rate for fast-forwarding legs
+const WORLD = 24; // the fixed world rate (ISS-117) — must match lib/worldClock.ts
 
 interface PlaneState {
   id: string;
@@ -40,7 +41,7 @@ interface PackageState {
 
 interface StateBody {
   account: { cash: number; reputation: number };
-  simState: { clockMs: number; timeScale: number; paused: boolean };
+  simState: { clockMs: number }; // ISS-117: the snapshot carries only the game clock
   planes: PlaneState[];
   packages: PackageState[];
 }
@@ -59,29 +60,28 @@ function haversineKm(lat1: number, lon1: number, lat2: number, lon2: number): nu
 }
 
 async function getState(page: Page): Promise<StateBody> {
+  // ISS-127: /api/state intermittently 500s under scale-1000 dind load; a throw here would
+  // instantly fail any expect.poll callback, so retry briefly instead.
+  for (let attempt = 1; ; attempt++) {
     const res = await page.request.get('/api/state');
-  expect(res.status()).toBe(200);
+    if (res.status() === 200) return (await res.json()) as StateBody;
-  return (await res.json()) as StateBody;
+    if (attempt >= 3) throw new Error(`/api/state returned ${res.status()} after 3 attempts`);
+    await page.waitForTimeout(500);
+  }
 }
 
-async function postSim(page: Page, body: unknown) {
+// Test hook (FLIGHT_TEST_HOOKS=1): set the world rate and VERIFY from the response that it stuck —
-  return page.request.post('/api/sim', { data: body });
+// a silent reset would otherwise surface as an unexplained landing-wait timeout.
-}
-
-// Set the time scale and VERIFY from the response that it stuck — a silent reset would
-// otherwise surface as an unexplained landing-wait timeout. ISS-041 also clears pause: a
-// landing pauses the sim, so any fast-forward after one must resume it or the clock stays frozen.
 async function setScale(page: Page, scale: number): Promise<void> {
-  const res = await page.request.post('/api/sim', { data: { timeScale: scale, paused: false } });
+  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/sim`).toBe(scale);
+  expect(body.timeScale, `timeScale should be ${scale} after POST /api/test/set-timescale`).toBe(scale);
 }
 
-// Leave the live instance in a sane state for the other specs (scale 1, running).
+// Leave the live instance in a sane state for the other specs (the fixed world rate).
 test.afterEach(async ({ page }) => {
-  const res = await postSim(page, { timeScale: 1, paused: false });
+  await setScale(page, WORLD);
-  expect(res.status()).toBe(200);
 });
 
 // Test hook (FLIGHT_TEST_HOOKS=1): create an open package on a known route.
@@ -120,7 +120,8 @@ async function loadAndFly(page: Page, fromIcao: string, toIcao: string): Promise
   return pkg;
 }
 
-// All features of a GeoJSON source (viewport-independent), [] until the map/source exists.
+// Features in LOADED tiles only — MapLibre loads GeoJSON per viewport tile, so the camera must be over
+// the area of interest first ([] until then). Same trap as run-176: default world view + Pacific plane = [].
 function sourceFeatures(page: Page, sourceId: string) {
   return page.evaluate((srcId: string) => {
     const m = (window as any).__flightMap;
@@ -154,7 +155,23 @@ test('airport popup shows name, ICAO, local time and generated weather', async (
     { timeout: 15_000 },
   ).toBeGreaterThan(0);
 
-  // LFRS Nantes Atlantique — same isolated marker as e2e/map.spec.ts.
+  // LFRS Nantes Atlantique — same isolated marker as e2e/map.spec.ts. The v0.70.0 default view
+  // ([0,0] z2) shows both Africa + Europe with overlapping markers (nearest neighbour LFRB Brest is
+  // only ~13–19 px away at z2), so frame LFRS at z5 first — its nearest marker is then ~104 px away.
+  await page.evaluate(() => {
+    (window as any).__flightMap.jumpTo({ center: [-1.61073, 47.153198], zoom: 5 });
+  });
+  // Wait until LFRS's marker is actually rendered at the new camera before clicking it.
+  await expect.poll(async () =>
+    page.evaluate(() => {
+      const map = (window as any).__flightMap;
+      const p = map.project([-1.61073, 47.153198]);
+      return (map.queryRenderedFeatures([p.x, p.y], { layers: ['airports-circles'] }) as Array<{ properties?: Record<string, unknown> }>)
+        .some((f) => f.properties?.icao === 'LFRS');
+    }),
+    { timeout: 15_000 },
+  ).toBe(true);
+
   const pt = await page.evaluate(() => {
     const map = (window as any).__flightMap;
     const p = map.project([-1.61073, 47.153198]); // LFRS Nantes Atlantique
@@ -235,7 +252,7 @@ test('plane markers move while flying and the plane popup shows status + route',
   // 2) Fly the plane and speed up — its current leg must appear as a route line.
   const fly = await page.request.post('/api/planes/plane-starter/fly', { data: { destIcao: DEST } });
   expect(fly.status()).toBe(200);
-  await postSim(page, { timeScale: SCALE });
+  await setScale(page, SCALE);
 
   await expect
     .poll(async () => {
@@ -258,23 +275,35 @@ test('plane markers move while flying and the plane popup shows status + route',
   // The arc itself stays covered by unit tests: lib/mapData.test.ts.)
 
   // 4) Click the flying plane → status popup with model, status, fuel and the leg.
-  // Freeze the sim so the click can't miss a fast-moving marker: at scale 1000 the rendered
+  // Freeze the sim so the click can't miss a moving marker: at scale 1000 the rendered marker lags
-  // marker lags our fresh /api/state fetch by up to one map poll (~1 s) — tens of px of drift
+  // our fresh /api/state fetch by up to one map poll (~1 s). At scale 1 (and this continent-level
-  // on this leg. Pausing makes the position static; we resume right after the popup checks.
+  // view) the per-second drift is sub-pixel, so the position is static for all practical purposes;
-  await postSim(page, { paused: true });
+  // we restore SCALE right after the popup checks.
+  await setScale(page, 1);
+  // At scale 1 a flying plane still advances every tick (the ATR72 cruises ~0.14 km/s of real time),
+  // so exact lat/lon equality between polls can never hold — "settled" means slow enough to click:
+  // two consecutive snapshots within EPS of each other. Per-tick advance is clamped to
+  // MAX_TICK_ELAPSED_MS (2 s) × scale, so at scale 1 the worst-case per-poll drift is ~0.5 km even
+  // for the fastest catalog plane; 5 km sits far above that and far below what a still-fast clock
+  // would show (~km per poll pair).
   let prevPos: { lat: number; lon: number } | null = null;
   await expect
     .poll(async () => {
       const p = (await getState(page)).planes.find((x) => x.id === 'plane-starter');
       if (!p || p.status !== 'flying') return false;
-      if (prevPos && prevPos.lat === p.lat && prevPos.lon === p.lon) return true;
+      if (prevPos && haversineKm(prevPos.lat, prevPos.lon, p.lat, p.lon) < 5) return true;
       prevPos = { lat: p.lat, lon: p.lon };
       return false;
-    }, { timeout: 15_000, message: 'waiting for the paused clock to freeze the plane position' })
+    }, { timeout: 15_000, message: 'waiting for the scale-1 clock to slow the plane to click-safe drift' })
     .toBe(true);
 
-  // Click the RENDERED marker position, not a fresh /api/state fetch. With the sim paused
+  // queryRenderedFeatures is viewport-scoped, and at the v0.70.0 default view ([0,0] z2) this pane
-  // above the server's analytic position is static — but the map renders from its own ~1 s
+  // only shows latitudes ~±51° — EDDF (50°N) sits right at its edge, so frame both endpoints of the
+  // leg to guarantee the plane marker is rendered wherever it is on it.
+  await fitToAirports(page, [HUB, DEST]);
+
+  // Click the RENDERED marker position, not a fresh /api/state fetch. With the clock at scale 1
+  // above the server's analytic position barely moves — but the map renders from its own ~1 s
   // poll, so right after the freeze confirmation the last rendered frame can still be up to
   // one poll interval stale (tens of px at scale 1000 on this leg) and a click projected
   // from a fresh fetch misses the small circle layer (CI run #37). Poll for the plane's
@@ -314,8 +343,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}`);
 
-  // Resume before step 5 — the landing wait needs a running clock.
+  // Restore SCALE before step 5 — the landing wait needs a fast clock.
-  await postSim(page, { timeScale: SCALE, paused: false });
+  await setScale(page, SCALE);
 
   // 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
@@ -330,3 +359,245 @@ test('plane markers move while flying and the plane popup shows status + route',
 
   await loadAndFly(page, DEST, HUB);
 });
+
+// ISS-124 (v0.58.0): a marker on a leg crossing the antimeridian must not teleport — its longitude is
+// unwrapped against the departure airport in planesGeoJson (lib/mapData.ts), so consecutive polls stay
+// continuous exactly like the route line. The starter can't fly EDDF→NZAA in one leg (~19,000 km vs the
+// ATR72's ~3,700 km guaranteed range), so relocation is a fewest-legs chain over /api/airports with each
+// hop ≤ MAX_LEG_KM (within that range even in worst-case headwind); set-fuel tops the tank for free before
+// every dispatch so auto-refuel costs nothing.
+const MAX_LEG_KM = 3400;
+
+// Fewest-legs chain from → to over /api/airports, each hop ≤ maxLegKm — BFS with adjacency sorted by
+// (distance, ICAO) so the chain is deterministic for a given dataset. Excludes `from`, includes `to`.
+async function chainTo(page: Page, fromIcao: string, toIcao: string): Promise<string[]> {
+  const fc = (await (await page.request.get('/api/airports')).json()) as {
+    features: Array<{ properties: { icao: string; lat: number; lon: number } }>;
+  };
+  const aps = fc.features.map((f) => f.properties);
+  const toRad = (d: number) => (d * Math.PI) / 180;
+  const havKm = (a: { lat: number; lon: number }, b: { lat: number; lon: number }) => {
+    const dLat = toRad(b.lat - a.lat);
+    const dLon = toRad(b.lon - a.lon);
+    const s = Math.sin(dLat / 2) ** 2 + Math.cos(toRad(a.lat)) * Math.cos(toRad(b.lat)) * Math.sin(dLon / 2) ** 2;
+    return 2 * 6371 * Math.asin(Math.min(1, Math.sqrt(s)));
+  };
+  const idx = new Map(aps.map((a, i) => [a.icao, i]));
+  const adj: Array<Array<[number, number]>> = aps.map(() => []);
+  for (let i = 0; i < aps.length; i++) {
+    for (let j = i + 1; j < aps.length; j++) {
+      const d = havKm(aps[i]!, aps[j]!);
+      if (d <= MAX_LEG_KM) {
+        adj[i]!.push([j, d]);
+        adj[j]!.push([i, d]);
+      }
+    }
+  }
+  for (const a of adj) a.sort((x, y) => x[1] - y[1] || aps[x[0]]!.icao.localeCompare(aps[y[0]]!.icao));
+  const s = idx.get(fromIcao)!;
+  const t = idx.get(toIcao)!;
+  const prev = new Array<number>(aps.length).fill(-1);
+  const queue: number[] = [s];
+  for (let qi = 0; qi < queue.length && prev[t] === -1; qi++) {
+    const u = queue[qi]!;
+    for (const [v] of adj[u]!) {
+      if (prev[v] === -1) {
+        prev[v] = u;
+        queue.push(v);
+      }
+    }
+  }
+  expect(prev[t], `no ≤${MAX_LEG_KM} km chain from ${fromIcao} to ${toIcao}`).not.toBe(-1);
+  const path: string[] = [];
+  for (let cur = t; cur !== s; cur = prev[cur]!) path.unshift(aps[cur]!.icao);
+  return path;
+}
+
+// plane-starter's marker from the planes source: its position plus whether that frame is a FLYING one.
+// Extracted IN-PAGE because MapLibre feature geometry can be a lazy prototype getter that Playwright's
+// evaluate serialization drops (same trap as e2e/hover.spec.ts). The `flying` flag matters for the
+// sampling loop: a grounded frame snaps back to the raw airport coordinate (−175.1), which is the same
+// screen point but a 360° jump in raw data — only flying frames may be recorded. `lat` feeds the
+// freshness gate below (a stale source frame sits far from where the SERVER says the plane is).
+function starterMarker(page: Page): Promise<{ lat: number; lon: number; flying: boolean } | null> {
+  return page.evaluate(() => {
+    const m = (window as any).__flightMap;
+    if (!m || !m.getSource('planes')) return null;
+    try {
+      for (const f of m.querySourceFeatures('planes') as Array<{ properties?: Record<string, unknown>; geometry?: { coordinates: number[] } }>) {
+        if (f.properties?.id === 'plane-starter' && f.geometry) {
+          return { lat: f.geometry.coordinates[1]!, lon: f.geometry.coordinates[0]!, flying: f.properties.flying === true };
+        }
+      }
+    } catch {
+      // map/source not ready yet — null keeps the caller polling
+    }
+    return null;
+  });
+}
+
+// Jump the camera to a box around the given airports. Copied from e2e/hover.spec.ts — that version
+// unwraps crossing pairs (ISS-120) so a ±180-straddling pair fits the Pacific, not the Atlantic.
+async function fitToAirports(page: Page, icaos: string[]): Promise<void> {
+  const fc = (await (await page.request.get('/api/airports')).json()) as {
+    features: Array<{ properties: { icao: string; lat: number; lon: number } }>;
+  };
+  const points = icaos.map((icao) => {
+    const f = fc.features.find((x) => x.properties.icao === icao);
+    if (!f) throw new Error(`airport ${icao} not found in /api/airports`);
+    return [f.properties.lon, f.properties.lat] as [number, number];
+  });
+  for (let i = 1; i < points.length; i++) {
+    let lon = points[i]![0];
+    const prev = points[i - 1]![0];
+    while (lon - prev > 180) lon -= 360;
+    while (prev - lon > 180) lon += 360;
+    points[i]![0] = lon;
+  }
+  await page.evaluate((pts: [number, number][]) => {
+    const m = (window as any).__flightMap;
+    if (!m) throw new Error('map not ready');
+    const lons = pts.map((p) => p[0]);
+    const lats = pts.map((p) => p[1]);
+    // duration 0 → instant camera jump, no animation to wait out.
+    m.fitBounds(
+      [
+        [Math.min(...lons), Math.min(...lats)],
+        [Math.max(...lons), Math.max(...lats)],
+      ],
+      { padding: 40, duration: 0 },
+    );
+  }, points);
+  // Give the renderer a beat after the camera jump before asserting on rendered features.
+  await page.waitForTimeout(300);
+}
+
+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
+
+  await page.goto('/');
+  await waitForAirportCount(page);
+
+  const ORIGIN = 'NZAA'; // Auckland — east of +170
+  const CROSS_DEST = 'NFTF'; // Fua'amotu (Tonga) — west of −175; the short arc crosses ±180 EASTWARD
+
+  // 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 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
+  // grounded at HUB so no later spec's fly-home gets a 409 (the run-176 pollution cascade).
+  try {
+    let loc = (await getState(page)).planes.find((p) => p.id === 'plane-starter')!.locationIcao;
+    if (loc !== ORIGIN) {
+      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 expect.poll(async () => (await getState(page)).planes.find((p) => p.id === 'plane-starter')?.locationIcao ?? '', { timeout: 240_000 }).toBe(next);
+      }
+    }
+
+    // Fresh page before the crossing leg: this test's page has been alive ~3 min (relocation chain) and
+    // under dind load the browser's state feed can go stale — a frozen planes source would then keep an
+    // old FLYING frame from a relocation hop, fooling the flying poll below and sampling stale lons.
+    // Server state persists across reloads; the plane is grounded at ORIGIN here, so on this fresh page
+    // ONLY the crossing leg can ever produce a flying frame.
+    await page.reload();
+    await waitForAirportCount(page);
+
+    // The crossing package + dispatch. RUN-179 DATA COLLECTION: server-side truth is logged at every
+    // phase (unconditionally — Playwright puts test stdout in the job log for failed tests), so a failed
+    // run shows exactly what /api/state said while the browser source was sampled.
+    const fmtPlane = (p: PlaneState) => `status=${p.status} loc=${p.locationIcao} dest=${p.destIcao ?? '-'} lat=${p.lat.toFixed(4)} lon=${p.lon.toFixed(4)}`;
+    await setFuelFull(page, 'plane-starter');
+    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')!)}`);
+    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
+    // Pacific leg: fit the camera over both endpoints first or the plane feature never appears in queries.
+    await fitToAirports(page, [ORIGIN, CROSS_DEST]);
+
+    // Wait until SERVER state shows plane-starter flying on THIS specific leg (origin/dest pair match) AND
+    // the planes source agrees. A marker-only poll could pass on a stale FLYING frame from an earlier hop;
+    // sampling must start only when this leg is actually underway server-side.
+    await expect.poll(async () => {
+      const p = (await getState(page)).planes.find((x) => x.id === 'plane-starter')!;
+      if (!(p.status === 'flying' && p.locationIcao === ORIGIN && p.destIcao === CROSS_DEST)) return false;
+      return (await starterMarker(page))?.flying ?? false;
+    }, { timeout: 30_000, message: `server must show plane-starter flying ${ORIGIN}->${CROSS_DEST} AND the planes source must show it flying` }).toBe(true);
+    console.log(`[antimeridian] FLYING first observed (server): ${fmtPlane((await getState(page)).planes.find((x) => x.id === 'plane-starter')!)}`);
+
+    // Sample the marker's longitude while it crosses. Stop once the SERVER says landed; record only
+    // FLYING frames — a grounded frame snaps back to the raw airport coordinate (−175.1), the same screen
+    // point but a 360° jump in raw data, and could land between this loop's server read and source read.
+    // Freshness gate: the browser's source may lag server truth by a tick or two (SSE + tile re-render),
+    // but a FROZEN frame would otherwise pass continuity vacuously and never show the crossing — accept
+    // only frames within ~700 km of where the SERVER says the plane is (~5 s of flight at ×1000); haversine
+    // is ±360°-periodic in Δlon, so wrapped server lon vs unwrapped marker lon compare directly.
+    const lons: number[] = [];
+    const lats: number[] = [];
+    let rawSamples = 0;
+    const rejected: string[] = [];
+    const acceptedDetail: string[] = [];
+    for (;;) {
+      const p = (await getState(page)).planes.find((x) => x.id === 'plane-starter')!;
+      if (p.status !== 'flying') break;
+      rawSamples++;
+      const marker = await starterMarker(page);
+      if (!marker || !marker.flying) {
+        rejected.push(`raw#${rawSamples} server(${p.lat.toFixed(4)},${p.lon.toFixed(4)}) marker=${marker ? `not-flying (${marker.lat.toFixed(4)},${marker.lon.toFixed(4)})` : 'null'}`);
+      } else {
+        const d = haversineKm(p.lat, p.lon, marker.lat, marker.lon);
+        if (d < 700) {
+          lons.push(marker.lon);
+          lats.push(marker.lat);
+          // Δlon ≈ 0 → source tracks the wrapped server lon (unwrap NOT applied or pre-crossing);
+          // Δlon ≈ +360 post-crossing → unwrap IS applied to what starterMarker reads.
+          acceptedDetail.push(`server(${p.lat.toFixed(4)},${p.lon.toFixed(4)}) source(lon=${marker.lon.toFixed(4)} lat=${marker.lat.toFixed(4)}) Δlon=${(marker.lon - p.lon).toFixed(2)}`);
+        } else {
+          rejected.push(`raw#${rawSamples} server(${p.lat.toFixed(4)},${p.lon.toFixed(4)}) marker(${marker.lat.toFixed(4)},${marker.lon.toFixed(4)}) dist=${d.toFixed(1)}km ≥700`);
+        }
+      }
+      await page.waitForTimeout(500);
+    }
+
+    // Unconditional diagnostics (run-179): full arrays + raw/accepted/rejected counts, so the failure log
+    // maps directly to a cause: constant ≈174.8 → frozen pre-crossing frame; values below −180 → westward
+    // unwrap; > 180 with Δlon≈+360 → correct eastward unwrap; empty after gate → source never fresh.
+    console.log(`[antimeridian] sampled lons (n=${lons.length}): ${JSON.stringify(lons)}`);
+    console.log(`[antimeridian] sampled lats (n=${lats.length}): ${JSON.stringify(lats)}`);
+    console.log(`[antimeridian] raw samples=${rawSamples} accepted=${lons.length} rejected=${rejected.length}`);
+    for (const r of rejected) console.log(`[antimeridian] REJECTED: ${r}`);
+    const detail = acceptedDetail.length <= 10 ? acceptedDetail : [...acceptedDetail.slice(0, 5), '…', ...acceptedDetail.slice(-5)];
+    for (const a of detail) console.log(`[antimeridian] ACCEPTED: ${a}`);
+
+    expect(lons.length, `sampled lons (n=${lons.length}): ${JSON.stringify(lons)}; rejected: ${rejected.join(' | ')}`).toBeGreaterThan(3); // a real flight window of FRESH frames (stale ones are gated out above), not a degenerate one
+    for (let i = 1; i < lons.length; i++) {
+      expect(Math.abs(lons[i]! - lons[i - 1]!), `marker jumped between samples ${i - 1} and ${i}`).toBeLessThan(180); // the ISS-124 bug
+    }
+    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
+    // state. The package was delivered on arrival (generous deadline).
+    await setScale(page, SCALE);
+    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 expect.poll(async () => (await getState(page)).planes.find((p) => p.id === 'plane-starter')?.locationIcao ?? '', { timeout: 240_000 }).toBe(next);
+      }
+    }
+  }
+});

e2e/map.spec.ts

@@ -8,9 +8,32 @@ const APP_URL = '/';
 const pkg = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf8')) as { version: string };
 
 // Must match MIN_ZOOM / MAX_ZOOM exported from components/Map.tsx.
-const MIN_ZOOM = 3;
+const MIN_ZOOM = 0; // v0.70.0: lowered 3 → 0 so the whole earth is visible when fully zoomed out
 const MAX_ZOOM = 11;
 
+// LFRS Nantes Atlantique — the marker-click target of this file (and e2e/map-interactions.spec.ts,
+// e2e/relocation.spec.ts). The v0.70.0 default view ([0,0] z2) shows both Africa + Europe with
+// overlapping markers (nearest neighbour LFRB Brest is only ~13–19 px away at z2), so every click
+// test first frames LFRS at z5 — its nearest marker is then ~104 px away and the projected center
+// cannot hit a neighbouring circle.
+const LFRS: [number, number] = [-1.61073, 47.153198];
+
+async function frameLfrs(page: Page): Promise<void> {
+  await page.evaluate((c) => (window as any).__flightMap.jumpTo({ center: c, zoom: 5 }), LFRS);
+  // Wait until LFRS's marker is actually rendered at the new camera before clicking it. The
+  // coordinate is passed AS AN ARGUMENT — evaluate callbacks run in the browser, where Node-scope
+  // values don't exist (same trap as e2e/relocation.spec.ts).
+  await expect.poll(async () =>
+    page.evaluate((c) => {
+      const map = (window as any).__flightMap;
+      const p = map.project(c);
+      return (map.queryRenderedFeatures([p.x, p.y], { layers: ['airports-circles'] }) as Array<{ properties?: Record<string, unknown> }>)
+        .some((f) => f.properties?.icao === 'LFRS');
+    }, LFRS),
+    { timeout: 15_000 },
+  ).toBe(true);
+}
+
 async function waitForAirportCount(page: Page): Promise<number> {
   const countEl = page.getByTestId('airport-count');
   await expect.poll(async () => {
@@ -22,11 +45,21 @@ async function waitForAirportCount(page: Page): Promise<number> {
   return parseInt(text.match(/(\d+)/)?.[1] ?? '0', 10);
 }
 
-test('page loads with the map and EU airport count', async ({ page }) => {
+test('page loads with the map and world airport count', async ({ page }) => {
   await page.goto(APP_URL);
   await expect(page.getByTestId('map')).toBeVisible();
   const count = await waitForAirportCount(page);
   expect(count).toBeGreaterThan(0);
+
+  // v0.70.0 default view: null island [0,0] at zoom 2 (Africa + Europe both visible). The map
+  // instance exists by the time the airport count renders — it is created before airports load.
+  const view = await page.evaluate(() => {
+    const m = (window as any).__flightMap;
+    return { lng: m.getCenter().lng, lat: m.getCenter().lat, z: m.getZoom() };
+  });
+  expect(view.z).toBeCloseTo(2);
+  expect(view.lng).toBeCloseTo(0);
+  expect(view.lat).toBeCloseTo(0);
 });
 
 test('header shows the app version sourced from package.json', async ({ page }) => {
@@ -56,18 +89,15 @@ test('clicking an airport marker opens a popup with name and ICAO', async ({ pag
     { timeout: 15_000 },
   ).toBeGreaterThan(0);
 
-  // Project LFRS (Nantes Atlantique) to screen space via the dev hook, then click it.
+  // Frame LFRS (Nantes Atlantique) so its marker is isolated again — see frameLfrs above for why
-  // Nantes is used because the v0.9.0 three-pane layout narrows the map column to ~660 px at
+  // the v0.70.0 default view needs this — then project it to screen space via the dev hook and click.
-  // the default 1280×720 viewport, which puts UKBB Boryspil (~475 px east of the [10,52] center)
+  await frameLfrs(page);
-  // outside the initial view; LFRS is now the most isolated large_airport marker inside it — its
+  const pt = await page.evaluate((c) => {
-  // nearest neighbour is LFRB Nantes–Montoir ~78 px away at the initial zoom, so its marker cannot
-  // be overlapped by a neighbouring circle.
-  const pt = await page.evaluate(() => {
     const map = (window as any).__flightMap;
-    const p = map.project([-1.61073, 47.153198]); // LFRS Nantes Atlantique — see the marker-click test above for why
+    const p = map.project(c); // LFRS Nantes Atlantique — see frameLfrs above for why it's framed at z5
     const rect = map.getContainer().getBoundingClientRect();
     return { x: rect.left + p.x, y: rect.top + p.y };
-  });
+  }, LFRS);
   await page.mouse.click(pt.x, pt.y);
 
   const popup = page.getByTestId('airport-popup');
@@ -138,12 +168,18 @@ test('wheel zoom is clamped between min and max zoom', async ({ page }) => {
   await waitForStableZoom();
   expect(await getZoom()).toBeCloseTo(MAX_ZOOM);
 
-  // Zoom out well below MIN_ZOOM with several large deltas.
+  // Zoom out to the effective minimum. MapLibre won't zoom out past the point where
-  await jumpTo(MIN_ZOOM + 1);
+  // the world no longer covers the viewport height (fit floor = log2(h/512)), so with
-  await wheelToLimit(600, (z) => z <= MIN_ZOOM + 1e-9);
+  // MIN_ZOOM=0 the reachable limit is max(MIN_ZOOM, fitFloor) — "just far enough to see
+  // the whole Earth", which is exactly what min zoom should give.
+  const mapBox = await page.getByTestId('map').boundingBox();
+  if (!mapBox) throw new Error('map bounding box unavailable');
+  const minLimit = Math.max(MIN_ZOOM, Math.log2(mapBox.height / 512));
+  await jumpTo(minLimit + 1);
+  await wheelToLimit(600, (z) => z <= minLimit + 1e-9);
   await waitForStableZoom();
   const zoom = await getZoom();
-  expect(zoom).toBeCloseTo(MIN_ZOOM);
+  expect(zoom).toBeCloseTo(minLimit);
   expect(zoom).toBeGreaterThanOrEqual(MIN_ZOOM);
   expect(zoom).toBeLessThanOrEqual(MAX_ZOOM);
 });
@@ -186,9 +222,12 @@ test('style switcher defaults to Fiord, switches styles, and keeps the airports
   // Regression guard for the setStyle-wipes-layers bug: map.setStyle() removes every
   // source/layer not in the new style, so the airports layer must be re-established —
   // count still shown and markers rendered again.
-  await expect(page.getByTestId('airport-count')).toContainText(/EU airports/);
+  await expect(page.getByTestId('airport-count')).toContainText(/world airports/);
   await expect.poll(renderedCircles, { timeout: 15_000 }).toBeGreaterThan(0);
 
+  // Frame LFRS at z5 first — see frameLfrs above for why the v0.70.0 default view needs this.
+  await frameLfrs(page);
+
   // Clicking a marker after the switch opens exactly one popup (the click handler is
   // re-wired idempotently — no duplicate listeners). MapLibre's diff-based setStyle removes our
   // custom source/layer before ensureAirportsLayer re-adds it on the next styledata event, so
@@ -258,12 +297,14 @@ test('falls back to remote OFM styles when the local asset pack is absent', asyn
     { timeout: 15_000 },
   ).toBeGreaterThan(0);
 
-  const pt = await page.evaluate(() => {
+  // Frame LFRS at z5 first — see frameLfrs above for why the v0.70.0 default view needs this.
+  await frameLfrs(page);
+  const pt = await page.evaluate((c) => {
     const map = (window as any).__flightMap;
-    const p = map.project([-1.61073, 47.153198]); // LFRS Nantes Atlantique — see the marker-click test above for why
+    const p = map.project(c); // LFRS Nantes Atlantique — see frameLfrs above for why it's framed at z5
     const rect = map.getContainer().getBoundingClientRect();
     return { x: rect.left + p.x, y: rect.top + p.y };
-  });
+  }, LFRS);
   await page.mouse.click(pt.x, pt.y);
 
   const popup = page.getByTestId('airport-popup');

e2e/panes.spec.ts

@@ -1,35 +1,95 @@
 import { test, expect, type Page } from '@playwright/test';
 
 // v0.9.0 — single-screen 3-pane shell + left Assets pane against the live origin.
-// The panes render from the shell's single /api/state poll (lib/useGameState.ts); time
+// The panes render from the shell's single /api/state poll (lib/useGameState.ts).
-// controls POST to /api/sim and refetch immediately, so UI assertions settle within a tick.
 
-const SCALE = 1000; // fastest sim speed — top of the v0.14.0 ladder (same convention as e2e/sim.spec.ts)
+const WORLD = 24; // the fixed world rate (ISS-117) — must match lib/worldClock.ts
-
+const SCALE = 1000; // test rate for fast-forwarding legs (self-heal only)
-interface SimState {
+const HUB = 'EDDF'; // must match HUB_ICAO in lib/game/seed.ts
-  clockMs: number;
+const STARTER = 'plane-starter';
-  timeScale: number;
-  paused: boolean;
-}
 
 interface StateBody {
   account: { cash: number; reputation: number };
-  simState: SimState;
+  simState: { clockMs: number }; // ISS-117: the snapshot carries only the game clock
   planes: Array<Record<string, unknown>>;
   packages: Array<Record<string, unknown>>;
 }
 
 async function getState(page: Page): Promise<StateBody> {
+  // ISS-127: /api/state intermittently 500s under scale-1000 dind load; a throw here would
+  // instantly fail any expect.poll callback, so retry briefly instead.
+  for (let attempt = 1; ; attempt++) {
     const res = await page.request.get('/api/state');
-  expect(res.status()).toBe(200);
+    if (res.status() === 200) return (await res.json()) as StateBody;
-  return (await res.json()) as StateBody;
+    if (attempt >= 3) throw new Error(`/api/state returned ${res.status()} after 3 attempts`);
+    await page.waitForTimeout(500);
+  }
 }
 
-// Leave the live instance in a sane state for the other specs (scale 1, running) — same
+// 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);
+}
+
+async function setHealth(page: Page, planeId: string, fields: Record<string, unknown>): Promise<void> {
+  const res = await page.request.post('/api/test/set-health', { data: { planeId, ...fields } });
+  expect(res.status()).toBe(200);
+}
+
+// A fully grounded fleet freezes the world clock (#135) — put the starter in repair so the clock
+// runs at FULL scale for tests that need fast-forwarding. The €1.5k repair cost is irrelevant to
+// every spec's relative cash assertions; deactivateWorld restores full health and no gate afterwards.
+async function activateWorld(page: Page): Promise<void> {
+  await setHealth(page, STARTER, { health: 50 });
+  expect((await page.request.post(`/api/planes/${STARTER}/repair`)).status()).toBe(200);
+}
+
+// Shorten the repair gate to "now" — the next advancing tick flips the plane back to available.
+async function deactivateWorld(page: Page): Promise<void> {
+  await setHealth(page, STARTER, { health: 100, repairUntilMs: 0 });
+  await expect
+    .poll(async () => ((await getState(page)).planes.find((p) => p.id === STARTER) as { status: string } | undefined)?.status ?? '', {
+      timeout: 30_000,
+      message: 'waiting for the starter to flip back to available',
+    })
+    .toBe('available');
+}
+
+// Self-heal helper (same pattern as e2e/actions.spec.ts): let any in-flight leg finish and
+// reposition plane-starter home via the API — an interrupted earlier run can leave it mid-flight,
+// and repairPlane 409s on non-available planes, which would break activateWorld.
+async function flyHomeViaApi(page: Page): Promise<void> {
+  // v0.39.0 (ISS-069): wear accumulates across the shared CI DB — restore full health and clear any
+  // active repair gate from an interrupted run before acting on the starter.
+  expect((await page.request.post('/api/test/set-health', { data: { planeId: STARTER, health: 100, repairUntilMs: 0 } })).status()).toBe(200);
+  let s = await getState(page); // ticks — a shortened gate flips the plane back to available here
+  let plane = (s.planes.find((p) => p.id === STARTER) ?? {}) as { status?: string; locationIcao?: string };
+  if (plane.status === 'flying' || plane.locationIcao !== HUB) {
+    // Fast-forward any leftover leg / repositioning flight (~20 s real time worst case at 1000×).
+    await setScale(page, SCALE);
+  }
+  if (plane.status === 'flying') {
+    // While flying, locationIcao stays at the DEPARTURE airport — re-read state after landing.
+    await expect.poll(async () => ((await getState(page)).planes.find((p) => p.id === STARTER)?.status ?? ''), { timeout: 240_000 }).toBe('available');
+    s = await getState(page);
+    plane = (s.planes.find((p) => p.id === STARTER) ?? {}) as { status?: string; locationIcao?: string };
+  }
+  if (plane.locationIcao !== HUB) {
+    // Make sure the world rate is back at SCALE so the return leg fast-forwards.
+    await setScale(page, SCALE);
+    const res = await page.request.post(`/api/planes/${STARTER}/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 === STARTER)?.locationIcao ?? ''), { timeout: 240_000 }).toBe(HUB);
+  }
+}
+
+// Leave the live instance in a sane state for the other specs (the fixed world rate) — same
 // pattern as e2e/sim.spec.ts.
 test.afterEach(async ({ page }) => {
-  const res = await page.request.post('/api/sim', { data: { timeScale: 1, paused: false } });
+  await setScale(page, WORLD);
-  expect(res.status()).toBe(200);
 });
 
 test('left pane renders wallet, reputation and the starter fleet at Frankfurt', async ({ page }) => {
@@ -79,26 +139,34 @@ test('left pane renders wallet, reputation and the starter fleet at Frankfurt',
   // Refuel heading or row anymore.
   await expect(page.getByTestId('left-pane').getByRole('heading', { name: 'Refuel', exact: true })).toHaveCount(0);
   await expect(page.getByTestId('right-pane').getByRole('heading', { name: 'Refuel', exact: true })).toHaveCount(0);
+
+  // ISS-117 (v0.52.0): the time controls are gone — no pause button or scale slider in the left pane.
+  await expect(page.getByTestId('pause-toggle')).toHaveCount(0);
+  await expect(page.getByTestId('time-scale-slider')).toHaveCount(0);
 });
 
-test('sim clock ticks smoothly between polls — seconds advance without waiting for a snapshot (ISS-007)', async ({ page }) => {
+test('sim clock ticks smoothly between polls at the fixed world rate (ISS-007, ISS-117)', async ({ page }) => {
+  test.setTimeout(300_000); // self-heal (worst case ~260 s at 1000×) + clock sampling
+  // Self-heal first: an interrupted earlier run can leave the starter mid-flight, and repairPlane
+  // 409s on non-available planes — it must be grounded before activateWorld.
+  await flyHomeViaApi(page);
+  await setScale(page, WORLD); // self-heal may have left the fast test rate behind
+  // A fully grounded fleet freezes the world clock (#135) — put the starter in repair for full scale.
+  await activateWorld(page);
+  try {
     await page.goto('/');
     const clock = page.getByTestId('sim-clock');
     await expect(clock).toBeVisible({ timeout: 15_000 });
 
-  // Fastest scale so game seconds move visibly inside the sampling window.
+    // "YYYY-MM-DD HH:MM:SS UTC" → epoch ms (UTC).
-  const post = await page.request.post('/api/sim', { data: { timeScale: SCALE, paused: false } });
-  expect(post.status()).toBe(200);
-
-  // "YYYY-MM-DD HH:MM:SS UTC" → epoch ms (UTC). While running there is no "(paused)" suffix.
     const sample = async () => {
       const text = ((await clock.textContent()) ?? '').trim();
       expect(text, `clock format: ${text}`).toMatch(/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} UTC$/);
       return Date.parse(text.replace(' ', 'T').replace(' UTC', 'Z'));
     };
 
-  // Three samples ~1.3 s apart real time: at scale 1000 each gap is ≈1300 game seconds, so the
+    // Three samples ~1.3 s apart real time: at the fixed 24× world rate each gap is ≈31 game seconds,
-  // displayed clock must strictly advance between CONSECUTIVE samples — with the old poll-only
+    // so the displayed clock must strictly advance between CONSECUTIVE samples — with poll-only
     // rendering a sample pair could straddle zero snapshot updates and show no change at all.
     const t0 = await sample();
     await new Promise((r) => setTimeout(r, 1_300));
@@ -108,42 +176,14 @@ test('sim clock ticks smoothly between polls — seconds advance without waiting
 
     expect(t1).toBeGreaterThan(t0);
     expect(t2).toBeGreaterThan(t1);
-  // Sanity: ~2.6 s real × 1000 ≈ 2.6 M game ms — generous bounds keep slow CI boxes safe while
+    // Sanity: ~2.6 s real × 24 ≈ 62 game seconds — generous bounds keep slow CI boxes safe while
     // still catching a frozen or wildly mis-scaled clock.
     const total = t2 - t0;
-  expect(total).toBeGreaterThanOrEqual(1_000_000);
+    expect(total).toBeGreaterThanOrEqual(50_000);
-  expect(total).toBeLessThanOrEqual(6_000_000);
+    expect(total).toBeLessThanOrEqual(200_000);
-});
+  } finally {
-
+    await deactivateWorld(page);
-test('slider commit keeps the chosen scale on screen until confirmed — no snap-back (ISS-001)', async ({ page }) => {
-  test.setTimeout(60_000);
-  await page.goto('/');
-  const slider = page.getByTestId('time-scale-slider');
-  await expect(slider).toBeVisible({ timeout: 15_000 });
-
-  // Commit to max via keyboard (input + change → immediate commitNow POST)…
-  await slider.focus();
-  await page.keyboard.press('End');
-
-  // …and sample the displayed value rapidly across the whole commit→confirm window. With the
-  // ISS-001 fix the optimistic value stays until a snapshot confirms it, so EVERY sample must
-  // be '1000×' — never snapping back to the previous scale for one poll cycle (the old bug).
-  const seen: string[] = [];
-  for (let i = 0; i < 30; i++) {
-    seen.push(((await page.getByTestId('time-scale-value').textContent()) ?? '').trim());
-    await new Promise((r) => setTimeout(r, 25));
   }
-  expect(
-    seen.every((v) => v === '1000×'),
-    `displayed scale must stay 1000× during the commit window (saw: ${[...new Set(seen)].join(', ')})`,
-  ).toBe(true);
-
-  // …and the server confirms it.
-  await expect.poll(async () => (await getState(page)).simState.timeScale, { timeout: 10_000 }).toBe(1000);
-
-  // Restore to min for later tests (afterEach restores scale anyway).
-  await page.keyboard.press('Home');
-  await expect.poll(async () => (await getState(page)).simState.timeScale, { timeout: 10_000 }).toBe(1);
 });
 
 test('right pane placeholder exists with the Jobs & Market heading', async ({ page }) => {
@@ -157,3 +197,16 @@ test('right pane placeholder exists with the Jobs & Market heading', async ({ pa
   await expect(page.getByTestId('tab-planes-market')).toBeVisible();
   await expect(page.getByTestId('tab-jobs')).toHaveAttribute('aria-selected', 'true');
 });
+
+test('favicon ships as /icon.svg (ISS-122)', async ({ page }) => {
+  await page.goto('/');
+  // App Router file convention: app/icon.svg is auto-served and injected into the head.
+  const link = page.locator('head link[rel~="icon"]');
+  await expect(link).toHaveCount(1);
+  // Production builds append a content-hash query string to the auto-injected icon href.
+  expect(await link.getAttribute('href')).toMatch(/^\/icon\.svg/);
+
+  const res = await page.request.get('/icon.svg');
+  expect(res.status()).toBe(200);
+  expect(res.headers()['content-type']).toContain('image/svg+xml');
+});

e2e/queue.spec.ts

@@ -1,4 +1,11 @@
 import { test, expect, type Page } from '@playwright/test';
+// Real helpers (v0.46.0) — the refuel expectations must match lib/ exactly; Playwright resolves
+// the repo's tsconfig paths, so importing beats mirroring a fourth copy of the formulas.
+import { loadAirportsGeoJson } from '../lib/airports';
+import { FUEL_DISCOUNT_PER_REP, FUEL_PRICE_PER_L, MAX_FUEL_DISCOUNT, PLANE_TYPES, repRate } from '../lib/game/catalog';
+import { haversineKm, initialBearingDeg } from '../lib/geo';
+import { weatherFor } from '../lib/weather';
+import { fuelAtWeighted, requiredFuelFor, windBurnFactor } from '../lib/sim/movement';
 
 // v0.26.0 — ISS-043 part 2 (UI): the flight queue. A plane's not-yet-started legs show up in a
 // Queue sub-section of its on-board block (cancel per leg; adding happens via fly-to / Relocate
@@ -7,14 +14,17 @@ import { test, expect, type Page } from '@playwright/test';
 // dest → queue[0] → … — the active leg stays in the solid `routes-legs` layer. Landing auto-starts
 // the next queued leg server-side (part 1); test 3 exercises that chain end-to-end through the API.
 
-const SCALE = 1000; // fastest sim speed (v0.14.0 ladder top) — keeps flights to seconds of real time
+const SCALE = 1000; // test rate for fast-forwarding legs — keeps flights to seconds of real time
+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)
 const QUEUE = 'EHAM'; // Amsterdam — a third airport, distinct from hub and destination
 
 interface PlaneState {
   id: string;
+  model: string;
   status: 'available' | 'flying';
+  fuel: number;
   maxFuel: number;
   locationIcao: string;
   destIcao: string | null;
@@ -31,34 +41,33 @@ interface PackageState {
 
 interface StateBody {
   account: { cash: number; reputation: number };
-  simState: { clockMs: number; timeScale: number; paused: boolean };
+  simState: { clockMs: number }; // ISS-117: the snapshot carries only the game clock
   planes: PlaneState[];
   packages: PackageState[];
 }
 
 async function getState(page: Page): Promise<StateBody> {
+  // ISS-127: /api/state intermittently 500s under scale-1000 dind load; a throw here would
+  // instantly fail any expect.poll callback, so retry briefly instead.
+  for (let attempt = 1; ; attempt++) {
     const res = await page.request.get('/api/state');
-  expect(res.status()).toBe(200);
+    if (res.status() === 200) return (await res.json()) as StateBody;
-  return (await res.json()) as StateBody;
+    if (attempt >= 3) throw new Error(`/api/state returned ${res.status()} after 3 attempts`);
+    await page.waitForTimeout(500);
+  }
 }
 
-async function postSim(page: Page, body: unknown) {
+// Test hook (FLIGHT_TEST_HOOKS=1): set the world rate and VERIFY from the response that it stuck.
-  return page.request.post('/api/sim', { data: body });
-}
-
-// Set the time scale and VERIFY from the response that it stuck. ISS-041 also clears pause: a
-// landing pauses the sim, so any fast-forward after one must resume it or the clock stays frozen.
 async function setScale(page: Page, scale: number): Promise<void> {
-  const res = await page.request.post('/api/sim', { data: { timeScale: scale, paused: false } });
+  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/sim`).toBe(scale);
+  expect(body.timeScale, `timeScale should be ${scale} after POST /api/test/set-timescale`).toBe(scale);
 }
 
-// Leave the live instance in a sane state for the other specs (scale 1, running).
+// Leave the live instance in a sane state for the other specs (the fixed world rate).
 test.afterEach(async ({ page }) => {
-  const res = await postSim(page, { timeScale: 1, paused: false });
+  await setScale(page, WORLD);
-  expect(res.status()).toBe(200);
 });
 
 // Test hook (FLIGHT_TEST_HOOKS=1): create an open package on a known route.
@@ -78,6 +87,17 @@ 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);
 }
 
+// Test hook (FLIGHT_TEST_HOOKS=1): set a plane's tank to an exact level — the engine computes the
+// landed fuel from the row value at arrival, so draining mid-flight stages a known landing state.
+async function setFuel(page: Page, planeId: string, fuel: number): Promise<void> {
+  expect((await page.request.post('/api/test/set-fuel', { data: { planeId, fuel } })).status()).toBe(200);
+}
+
+// Test hook (FLIGHT_TEST_HOOKS=1): set the account's cash to an exact value (v0.46.0).
+async function setCash(page: Page, amount: number): Promise<void> {
+  expect((await page.request.post('/api/test/set-cash', { data: { amount } })).status()).toBe(200);
+}
+
 // Self-heal: let any in-flight leg finish, reposition plane-starter home via the API, and abandon
 // leftover cargo so every test starts from the canonical state even after an interrupted run.
 async function flyHomeViaApi(page: Page): Promise<void> {
@@ -99,7 +119,7 @@ async function flyHomeViaApi(page: Page): Promise<void> {
     plane = s.planes.find((p) => p.id === 'plane-starter')!;
   }
   if (plane.locationIcao !== HUB) {
-    // ISS-041: the landing above paused the sim — setScale clears pause so the return leg fast-forwards.
+    // Make sure the world rate is back at SCALE so the return leg fast-forwards.
     await setScale(page, SCALE);
     const res = await page.request.post(`/api/planes/${plane.id}/fly`, { data: { destIcao: HUB } });
     expect(res.status()).toBe(200); // repositioning needs no package (v0.12.0 manual flight)
@@ -239,7 +259,7 @@ test('queue display + cancel via UI (ISS-043 part 2)', async ({ page }) => {
     const p = (await getState(page)).planes.find((x) => x.id === 'plane-starter');
     return !!p && p.status === 'flying' && p.destIcao === DEST;
   }, { timeout: 15_000, message: 'waiting for the fly click to take effect (status "flying" + dest set)' }).toBe(true);
-  await postSim(page, { paused: true }); // pause-sim pattern: deterministic window for UI clicks
+  await setScale(page, 1); // scale-1 freeze pattern: deterministic window for UI clicks
 
   // ISS-065: re-queuing the CURRENT leg's destination while flying must be rejected with 409.
   const dupQueue = await page.request.post('/api/planes/plane-starter/queue', { data: { destIcao: DEST } });
@@ -266,7 +286,7 @@ test('queue display + cancel via UI (ISS-043 part 2)', async ({ page }) => {
     return !!p && p.status === 'available' && p.locationIcao === DEST;
   }, { timeout: 120_000, message: `waiting for plane-starter to land at ${DEST}` }).toBe(true);
 
-  // ISS-041: the arrival above paused the sim — setScale clears pause for the return leg.
+  // Re-set SCALE for the return leg.
   await setScale(page, SCALE);
   const home = await page.request.post('/api/planes/plane-starter/fly', { data: { destIcao: HUB } });
   expect(home.status()).toBe(200);
@@ -296,8 +316,8 @@ test('dotted queue line renders the queued path on the map (ISS-043 part 2)', as
   const flyBody = (await flyRes.json()) as StateBody;
   expect(flyBody.planes.find((p) => p.id === 'plane-starter')?.status).toBe('flying');
 
-  // Freeze mid-flight so the ~10 s leg can't land under us while we assert.
+  // Freeze mid-flight (scale 1) so the ~10 s leg can't land under us while we assert.
-  await postSim(page, { paused: true });
+  await setScale(page, 1);
 
   await page.goto('/');
   await waitForAirportCount(page);
@@ -347,7 +367,7 @@ test('dotted queue line renders the queued path on the map (ISS-043 part 2)', as
     return !!p && p.status === 'available' && p.locationIcao === DEST;
   }, { timeout: 120_000, message: `waiting for plane-starter to land at ${DEST}` }).toBe(true);
 
-  // ISS-041: the arrival above paused the sim — setScale clears pause for the return leg.
+  // Re-set SCALE for the return leg.
   await setScale(page, SCALE);
   const home = await page.request.post('/api/planes/plane-starter/fly', { data: { destIcao: HUB } });
   expect(home.status()).toBe(200);
@@ -450,3 +470,141 @@ test('landing auto-starts the next queued leg (ISS-043 chain end-to-end)', async
     return !!p && p.status === 'available' && p.locationIcao === HUB;
   }, { timeout: 120_000, message: `waiting for the chained leg to land back at ${HUB}` }).toBe(true);
 });
+
+// --- v0.46.0 (ISS-088): queue consumption on dispatch + refuel between legs ---
+
+test('three queued legs fly in FIFO order across landings (v0.46.0)', async ({ page }) => {
+  test.setTimeout(300_000); // self-heal + three chained legs at scale 1000
+  await flyHomeViaApi(page);
+
+  await setFuelFull(page, 'plane-starter');
+
+  // Pre-build a 3-leg route while grounded: LEMD → EHAM → back to the hub.
+  for (const icao of [DEST, QUEUE, HUB]) {
+    expect((await page.request.post('/api/planes/plane-starter/queue', { data: { destIcao: icao } })).status()).toBe(200);
+  }
+
+  // Start leg 1 — the response snapshot must show queue[0] CONSUMED (v0.46.0): no phantom self-hop on landing.
+  const flyRes = await page.request.post('/api/planes/plane-starter/fly', { data: { destIcao: DEST } });
+  expect(flyRes.status()).toBe(200);
+  const p0 = ((await flyRes.json()) as StateBody).planes.find((x) => x.id === 'plane-starter')!;
+  expect(p0.status).toBe('flying');
+  expect(p0.destIcao).toBe(DEST);
+  expect(p0.queue, 'queue[0] consumed on dispatch — the rest stays in order').toEqual([QUEUE, HUB]);
+
+  // Landing at DEST auto-chains EHAM (leg 2)…
+  await setScale(page, SCALE);
+  await expect.poll(async () => {
+    const x = (await getState(page)).planes.find((y) => y.id === 'plane-starter');
+    return !!x && x.status === 'flying' && x.destIcao === QUEUE;
+  }, { timeout: 120_000, message: `waiting for the auto-chained leg ${DEST} → ${QUEUE}` }).toBe(true);
+
+  // …and landing at EHAM chains the return to HUB (leg 3).
+  await expect.poll(async () => {
+    const x = (await getState(page)).planes.find((y) => y.id === 'plane-starter');
+    return !!x && x.status === 'flying' && x.destIcao === HUB;
+  }, { timeout: 120_000, message: `waiting for the auto-chained leg ${QUEUE} → ${HUB}` }).toBe(true);
+
+  await expect.poll(async () => {
+    const x = (await getState(page)).planes.find((y) => y.id === 'plane-starter');
+    return !!x && x.status === 'available' && x.locationIcao === HUB;
+  }, { timeout: 120_000, message: `waiting for the chained leg to land back at ${HUB}` }).toBe(true);
+
+  expect((await getState(page)).planes.find((x) => x.id === 'plane-starter')!.queue).toEqual([]); // all three consumed in order
+});
+
+test('a drained tank is topped up before a chained leg at exactly the rep-discounted cost (v0.46.0)', async ({ page }) => {
+  test.setTimeout(300_000); // self-heal + two legs at scale 1000
+  await flyHomeViaApi(page);
+
+  const s0 = await getState(page);
+  const type = PLANE_TYPES.atr72; // the starter model (STARTER_MODEL)
+  expect(s0.planes.find((x) => x.id === 'plane-starter')!.model).toBe('atr72'); // sanity: the catalog mirror is valid
+
+  // Full tank → leg 1 dispatch is a free no-op top-up, so only the CHAIN refuel moves cash. Stage an
+  // exact balance (v0.46.0 hook) so the expectation holds regardless of what earlier tests earned.
+  await setFuelFull(page, 'plane-starter');
+  const STAGED_CASH = 20_000;
+  await setCash(page, STAGED_CASH);
+  const q = await page.request.post('/api/planes/plane-starter/queue', { data: { destIcao: QUEUE } });
+  expect(q.status()).toBe(200);
+
+  const flyRes = await page.request.post('/api/planes/plane-starter/fly', { data: { destIcao: DEST } });
+  expect(flyRes.status()).toBe(200);
+  const cashBeforeChain = ((await flyRes.json()) as StateBody).account.cash;
+  expect(cashBeforeChain).toBe(STAGED_CASH); // dispatch was a free no-op — the staged balance is intact
+
+  // Drain the tank mid-flight — the engine computes the landed fuel from this row value at arrival.
+  await setFuel(page, 'plane-starter', 0);
+
+  // Expected chain refuel from the SAME helpers the engine uses (wind-adjusted, v0.36.0): leg 1 lands
+  // empty; leg DEST→QUEUE needs a top-up to min(maxFuel, max(landed, 1.5 × required)).
+  const fc = await loadAirportsGeoJson();
+  const hubP = fc.features.find((f) => f.properties.icao === HUB)!.properties;
+  const destP = fc.features.find((f) => f.properties.icao === DEST)!.properties;
+  const queueP = fc.features.find((f) => f.properties.icao === QUEUE)!.properties;
+
+  const km1 = haversineKm(hubP.lat, hubP.lon, destP.lat, destP.lon);
+  const wHub = weatherFor(HUB);
+  const burn1 = type.burnPerKm * windBurnFactor(wHub.windKt, wHub.windDirDeg, initialBearingDeg(hubP.lat, hubP.lon, destP.lat, destP.lon));
+  const landedFuel = fuelAtWeighted(0, burn1, type.emptyWeightKg, type.maxFuel, km1, 1); // drained → lands empty
+  expect(landedFuel).toBeCloseTo(0, 6);
+
+  const km2 = haversineKm(destP.lat, destP.lon, queueP.lat, queueP.lon);
+  const wDest = weatherFor(DEST); // the chained leg departs from the arrival airport
+  const burn2 = type.burnPerKm * windBurnFactor(wDest.windKt, wDest.windDirDeg, initialBearingDeg(destP.lat, destP.lon, queueP.lat, queueP.lon));
+  const required2 = requiredFuelFor(burn2, type.emptyWeightKg, type.maxFuel, km2);
+  expect(required2).toBeGreaterThan(landedFuel); // the top-up path genuinely runs
+
+  const target = Math.min(type.maxFuel, Math.max(landedFuel, required2 * 1.5));
+  const liters = Math.max(0, target - landedFuel);
+  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…
+  await setScale(page, SCALE);
+  await expect.poll(async () => {
+    const x = (await getState(page)).planes.find((y) => y.id === 'plane-starter');
+    return !!x && x.status === 'flying' && x.destIcao === QUEUE;
+  }, { timeout: 120_000, message: `waiting for the auto-chained leg ${DEST} → ${QUEUE}` }).toBe(true);
+
+  const s = await getState(page);
+  // 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;
+  // a wrong top-up level (≤ required2, or none at all) still lands far below this bound.
+  expect(fuel).toBeGreaterThan(1.3 * 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.
+  await expect.poll(async () => {
+    const x = (await getState(page)).planes.find((y) => y.id === 'plane-starter');
+    return !!x && x.status === 'available' && x.locationIcao === QUEUE;
+  }, { timeout: 120_000, message: `waiting for the chained leg to land at ${QUEUE}` }).toBe(true);
+});
+
+test('cancelling the only queued leg mid-flight leaves a plain landing (v0.46.0)', async ({ page }) => {
+  test.setTimeout(300_000); // self-heal + one leg at scale 1000
+  await flyHomeViaApi(page);
+
+  await setFuelFull(page, 'plane-starter');
+  const q = await page.request.post('/api/planes/plane-starter/queue', { data: { destIcao: QUEUE } });
+  expect(q.status()).toBe(200);
+  const flyRes = await page.request.post('/api/planes/plane-starter/fly', { data: { destIcao: DEST } });
+  expect(flyRes.status()).toBe(200);
+
+  // Cancel the queued leg while airborne — landing at DEST must be a plain grounding, no auto-chain.
+  const cancel = await page.request.post('/api/planes/plane-starter/queue/cancel', { data: { index: 0 } });
+  expect(cancel.status()).toBe(200);
+
+  await setScale(page, SCALE);
+  await expect.poll(async () => {
+    const x = (await getState(page)).planes.find((y) => y.id === 'plane-starter');
+    return !!x && x.status === 'available' && x.locationIcao === DEST;
+  }, { timeout: 120_000, message: `waiting for plane-starter to land at ${DEST}` }).toBe(true);
+
+  const p = (await getState(page)).planes.find((x) => x.id === 'plane-starter')!;
+  expect(p.destIcao).toBeNull(); // no chained leg started…
+  expect(p.queue).toEqual([]); // …and the queue is empty
+});

e2e/relocation.spec.ts

@@ -5,23 +5,47 @@ import { expect, test } from '@playwright/test';
 // Two UI surfaces drive the EXISTING POST /api/planes/{id}/fly endpoint (pure repositioning has
 // been allowed since v0.12.0 — no API change): the left-pane Relocate section (ISS-023, v0.21.0)
 // (relocate-plane / relocate-dest / relocate-go) and the Relocate row inside the airport popup on
-// the map (airport-popup-plane / airport-popup-relocate). Marker-size regression is covered by
+// the map (airport-popup-plane / airport-popup-relocate). Since v0.49.0 (ISS-096) the popup row also
-// the existing e2e/map.spec.ts click tests, not here.
+// 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; // fastest sim speed (v0.14.0 ladder top) — keeps cleanup flights to seconds of real time
+const SCALE = 1000; // test rate for fast-forwarding legs — keeps cleanup flights to seconds of real time
+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: its nearest neighbour is ~78 px
+// LFRS Nantes Atlantique — same isolated marker as e2e/map.spec.ts. The v0.70.0 default view ([0,0] z2)
-// away at the initial zoom, so a click on its projected center cannot hit another circle.
+// shows both Africa + Europe with overlapping markers (LFRS's nearest neighbour LFRB Brest is only
+// ~13–19 px away at z2), so framePopupAirport below frames it at z5 first — its nearest marker is then
+// ~104 px away and a click on the projected center cannot hit another circle.
 const POPUP_AIRPORT = { icao: 'LFRS', lon: -1.61073, lat: 47.153198 };
 
+async function framePopupAirport(page: Page): Promise<void> {
+  await page.evaluate((a) => (window as any).__flightMap.jumpTo({ center: [a.lon, a.lat], zoom: 5 }), POPUP_AIRPORT);
+  // Wait until the marker is actually rendered at the new camera before clicking it. The airport is
+  // passed AS AN ARGUMENT — evaluate callbacks run in the browser, where Node-scope values don't exist.
+  await expect.poll(async () =>
+    page.evaluate((a) => {
+      const map = (window as any).__flightMap;
+      const p = map.project([a.lon, a.lat]);
+      return (map.queryRenderedFeatures([p.x, p.y], { layers: ['airports-circles'] }) as Array<{ properties?: Record<string, unknown> }>)
+        .some((f) => f.properties?.icao === a.icao);
+    }, POPUP_AIRPORT),
+    { timeout: 15_000 },
+  ).toBe(true);
+}
+
 interface StateBody {
-  planes: Array<{ id: string; status: string; maxFuel: number; locationIcao: string; destIcao: string | null }>;
+  planes: Array<{ id: string; status: string; maxFuel: number; locationIcao: string; destIcao: string | null; queue: string[] }>;
 }
 
 async function getState(page: Page): Promise<StateBody> {
+  // ISS-127: /api/state intermittently 500s under scale-1000 dind load; a throw here would
+  // instantly fail any expect.poll callback, so retry briefly instead.
+  for (let attempt = 1; ; attempt++) {
     const res = await page.request.get('/api/state');
-  expect(res.ok()).toBeTruthy();
+    if (res.status() === 200) return (await res.json()) as StateBody;
-  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): top the starter's tank back to full — replaces the removed /refuel
@@ -32,20 +56,13 @@ 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);
 }
 
-async function postSim(page: Page, body: Record<string, unknown>): Promise<void> {
+// Test hook (FLIGHT_TEST_HOOKS=1): set the world rate and VERIFY from the response that it stuck —
-  const res = await page.request.post('/api/sim', { data: body });
+// if something external ever resets the live instance's controls mid-test, fail loudly here instead of timing out later.
-  expect(res.ok()).toBeTruthy();
-}
-
-// Set the time scale and VERIFY from the response that it stuck — if something external ever
-// resets the live instance's controls mid-test, fail loudly here instead of timing out later.
-// ISS-041 also clears pause: a landing pauses the sim, so any fast-forward after one must
-// resume it or the clock stays frozen and the next wait hangs.
 async function setScale(page: Page, scale: number): Promise<void> {
-  const res = await page.request.post('/api/sim', { data: { timeScale: scale, paused: false } });
+  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/sim`).toBe(scale);
+  expect(body.timeScale, `timeScale should be ${scale} after POST /api/test/set-timescale`).toBe(scale);
 }
 
 // Closest airport to the hub from /api/airports → shortest possible leg (fuel trivial).
@@ -82,8 +99,7 @@ async function flyHomeViaApi(page: Page): Promise<void> {
     plane = s.planes.find((p) => p.id === 'plane-starter')!;
   }
   if (plane.locationIcao !== HUB) {
-    // ISS-041: the landing above paused the sim — setScale clears pause so the return leg
+    // Make sure the world rate is back at SCALE so the return leg fast-forwards.
-    // fast-forwards instead of taking real-time hours.
     await setScale(page, SCALE);
     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)
@@ -92,10 +108,10 @@ async function flyHomeViaApi(page: Page): Promise<void> {
 }
 
 // Self-heal in CLEANUP (afterEach): the tests deliberately leave plane-starter mid-flight, so
-// fast-forward + reposition home here; then restore scale=1 / unpaused for later specs.
+// fast-forward + reposition home here; then restore the fixed world rate for later specs.
 test.afterEach(async ({ page }) => {
   await flyHomeViaApi(page);
-  await postSim(page, { timeScale: 1, paused: false });
+  await setScale(page, WORLD);
 });
 
 test.describe.configure({ mode: 'serial' }); // shared live DB — order matters within this file
@@ -162,6 +178,9 @@ test('airport popup offers Relocate options for grounded planes', async ({ page
     { timeout: 15_000 },
   ).toBe(true);
 
+  // Frame the popup airport at z5 first — see framePopupAirport above for why the v0.70.0 default view needs this.
+  await framePopupAirport(page);
+
   // Click the LFRS marker (projected center — same pattern as e2e/map.spec.ts). The constant is
   // passed AS AN ARGUMENT: the evaluate callback runs in the browser, where Node-scope values don't exist.
   const pt = await page.evaluate(({ lon, lat }) => {
@@ -195,3 +214,85 @@ test('airport popup offers Relocate options for grounded planes', async ({ page
     return p.status === 'flying' && p.destIcao === POPUP_AIRPORT.icao;
   }, { timeout: 15_000, message: 'waiting for the popup relocate click to take effect (status "flying" + dest set)' }).toBe(true);
 });
+
+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
+  await flyHomeViaApi(page);
+
+  // Full tank before departure — deterministic baseline (ISS-082 hook; dispatch would auto-refuel anyway).
+  await setFuelFull(page, 'plane-starter');
+
+  // ISS-096: the popup must offer Relocate for a FLYING plane too. Dispatch the starter on a leg via
+  // the API, then slow the sim to 1x so the leg cannot land during the UI steps (at 1x even the
+  // shortest leg takes minutes of real time) — "still flying its original destination" below is
+  // deterministic regardless of how fast the UI moves.
+  const nearest = await nearestToHub(page);
+  expect(nearest.icao).not.toBe(POPUP_AIRPORT.icao); // popup click target must differ from the active leg
+  await setScale(page, 1);
+
+  const flyRes = await page.request.post('/api/planes/plane-starter/fly', { data: { destIcao: nearest.icao } });
+  expect(flyRes.ok()).toBeTruthy();
+  await expect.poll(async () => {
+    const b = await getState(page);
+    const p = b.planes.find((x) => x.id === 'plane-starter')!;
+    return p.status === 'flying' && p.destIcao === nearest.icao;
+  }, { timeout: 15_000, message: 'waiting for the API dispatch to take effect (status "flying" + dest set)' }).toBe(true);
+
+  await page.goto('/');
+
+  // Same map-ready waits as the grounded popup test above: airport count rendered + a snapshot with
+  // the plane in the planes source — the popup's Relocate row is built from that same latest snapshot.
+  const countEl = page.getByTestId('airport-count');
+  await expect.poll(async () => {
+    const text = (await countEl.textContent()) ?? '';
+    const m = text.match(/(\d+)/);
+    return m ? parseInt(m[1], 10) : -1;
+  }, { timeout: 15_000 }).toBeGreaterThan(0);
+  await expect.poll(async () =>
+    page.evaluate(() => {
+      const m = (window as any).__flightMap;
+      if (!m || !m.getSource('planes')) return false;
+      try {
+        return m.querySourceFeatures('planes').some((f: { properties?: Record<string, unknown> }) => f.properties?.id === 'plane-starter');
+      } catch {
+        return false; // source not ready yet — keep polling
+      }
+    }),
+    { timeout: 15_000 },
+  ).toBe(true);
+
+  // Frame the popup airport at z5 first — see framePopupAirport above for why the v0.70.0 default view needs this.
+  await framePopupAirport(page);
+
+  const pt = await page.evaluate(({ lon, lat }) => {
+    const map = (window as any).__flightMap;
+    const p = map.project([lon, lat]);
+    const rect = map.getContainer().getBoundingClientRect();
+    return { x: rect.left + p.x, y: rect.top + p.y };
+  }, POPUP_AIRPORT);
+  await page.mouse.click(pt.x, pt.y);
+
+  const popup = page.getByTestId('airport-popup');
+  await expect(popup).toBeVisible();
+  await expect(popup).toContainText(POPUP_AIRPORT.icao);
+
+  // The Relocate row now lists ALL planes (ISS-096) — the flying starter is selectable even though it
+  // is not grounded; while flying its option shows the DEPARTURE airport.
+  const planeSel = page.getByTestId('airport-popup-plane');
+  await expect(planeSel).toBeVisible();
+  await expect(planeSel.locator('option[value="plane-starter"]')).toHaveText(/ATR 72-600 — EDDF/);
+  const goBtn = page.getByTestId('airport-popup-relocate');
+  await expect(goBtn).toBeDisabled(); // placeholder selected
+
+  await planeSel.selectOption('plane-starter');
+  await expect(goBtn).toBeEnabled();
+  await goBtn.click();
+
+  // The click fires the queue POST asynchronously — poll until it took effect: the leg is APPENDED to
+  // the flight queue while the plane keeps flying its original destination.
+  await expect.poll(async () => {
+    const b = await getState(page);
+    const p = b.planes.find((x) => x.id === 'plane-starter')!;
+    return p.status === 'flying' && p.destIcao === nearest.icao && p.queue.includes(POPUP_AIRPORT.icao);
+  }, { timeout: 15_000, message: 'waiting for the popup relocate click to take effect (queue contains LFRS, still flying original dest)' }).toBe(true);
+});

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 { fuelAtWeighted, windBurnFactor } from '../lib/sim/movement';
+import { fuelAtWeighted, guaranteedRangeKm, 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 { conditionBurnMultiplier, FUEL_DISCOUNT_PER_REP, MAX_FUEL_DISCOUNT, MAX_PLANE_DISCOUNT, PLANE_DISCOUNT_PER_REP, repRate } from '../lib/game/catalog';
+import { 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
@@ -18,7 +18,8 @@ import { STARTING_REPUTATION } from '../lib/game/seed';
 // 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
+const SCALE = 1000; // test rate for fast-forwarding legs — keeps flights to seconds of real time
+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
 
 interface PlaneState {
@@ -27,17 +28,19 @@ interface PlaneState {
   status: 'available' | 'flying';
   fuel: number;
   maxFuel: number;
-  health: number; // v0.39.0 (ISS-069) — feeds conditionBurnMultiplier in the auto-refuel math
+  health: number; // v0.39.0 (ISS-069) — structural health; flyHomeViaApi restores it to 100 before each test
   locationIcao: string;
   destIcao: string | null;
 }
 
 interface PackageState {
   id: string;
+  originIcao: string; // v0.65.0 — pool visibility assertions need the origin
+  destIcao: string;
   originName: string;
   destName: string;
   reward: number;
-  status: 'open' | 'loaded' | 'delivered' | 'expired' | 'abandoned' | 'ignored'; // v0.29.0 (ISS-047 part B)
+  status: 'open' | 'loaded' | 'delivered' | 'expired' | 'abandoned';
   planeId: string | null;
   createdSimTime: number;
   deadlineSimTime: number;
@@ -57,7 +60,7 @@ interface CatalogEntry {
 
 interface StateBody {
   account: { cash: number; reputation: number };
-  simState: { clockMs: number; timeScale: number; paused: boolean };
+  simState: { clockMs: number }; // ISS-117: the snapshot carries only the game clock
   planes: PlaneState[];
   packages: PackageState[];
   catalog: CatalogEntry[];
@@ -69,29 +72,28 @@ interface StateBody {
 const eur = (v: number) => new Intl.NumberFormat('en-US', { style: 'currency', currency: 'EUR' }).format(v);
 
 async function getState(page: Page): Promise<StateBody> {
+  // ISS-127: /api/state intermittently 500s under scale-1000 dind load; a throw here would
+  // instantly fail any expect.poll callback, so retry briefly instead.
+  for (let attempt = 1; ; attempt++) {
     const res = await page.request.get('/api/state');
-  expect(res.status()).toBe(200);
+    if (res.status() === 200) return (await res.json()) as StateBody;
-  return (await res.json()) as StateBody;
+    if (attempt >= 3) throw new Error(`/api/state returned ${res.status()} after 3 attempts`);
+    await page.waitForTimeout(500);
+  }
 }
 
-async function postSim(page: Page, body: unknown) {
+// Test hook (FLIGHT_TEST_HOOKS=1): set the world rate and VERIFY from the response that it stuck —
-  return page.request.post('/api/sim', { data: body });
+// a silent reset would otherwise surface as an unexplained landing-wait timeout.
-}
-
-// Set the time scale and VERIFY from the response that it stuck — a silent reset would
-// otherwise surface as an unexplained landing-wait timeout. ISS-041 also clears pause: a
-// landing pauses the sim, so any fast-forward after one must resume it or the clock stays frozen.
 async function setScale(page: Page, scale: number): Promise<void> {
-  const res = await page.request.post('/api/sim', { data: { timeScale: scale, paused: false } });
+  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/sim`).toBe(scale);
+  expect(body.timeScale, `timeScale should be ${scale} after POST /api/test/set-timescale`).toBe(scale);
 }
 
-// Leave the live instance in a sane state for the other specs (scale 1, running).
+// Leave the live instance in a sane state for the other specs (the fixed world rate).
 test.afterEach(async ({ page }) => {
-  const res = await postSim(page, { timeScale: 1, paused: false });
+  await setScale(page, WORLD);
-  expect(res.status()).toBe(200);
 });
 
 // Mirrors haversineKm in lib/geo.ts (same formula → identical floats).
@@ -137,12 +139,6 @@ function requiredFuelFor(burnPerKm: number, emptyWeightKg: number, maxFuel: numb
   return (emptyWeightKg / FUEL_DENSITY_KG_PER_L) * (Math.exp(k * FUEL_DENSITY_KG_PER_L * distanceKm) - 1);
 }
 
-// Mirrors maxRangeKm in lib/sim/movement.ts (v0.28.0): full-tank range under the weighted model.
-function maxRangeKm(burnPerKm: number, emptyWeightKg: number, maxFuel: number): number {
-  const rho = FUEL_DENSITY_KG_PER_L;
-  return Math.log(1 + (rho * maxFuel) / emptyWeightKg) * ((emptyWeightKg + rho * maxFuel) / (rho * burnPerKm));
-}
-
 // Test hook (FLIGHT_TEST_HOOKS=1): create an open package on a known route. Omitting `special`
 // makes the hook force null (no roll), so existing specs' exact reward/rep assertions stay deterministic.
 async function createPackage(page: Page, fromIcao: string, toIcao: string, deadlineOffsetMs?: number, weightKg?: number, special?: string | null): Promise<PackageState> {
@@ -174,9 +170,8 @@ async function flyHomeViaApi(page: Page): Promise<void> {
       .toBe(true);
   }
   if (starter.locationIcao !== HUB) {
-    // ISS-041: the landing above paused the sim — setScale clears pause so the return leg
+    // Make sure the world rate is back at SCALE so the return leg fast-forwards. ISS-082: dispatch
-    // fast-forwards instead of taking real-time hours. ISS-082: dispatch auto-refuels, so a
+    // auto-refuels, so a grounded plane can always start any full-tank-flyable leg when cash allows — no top-up retry needed.
-    // grounded plane can always start any full-tank-flyable leg when cash allows — no top-up retry needed.
     await setScale(page, SCALE);
     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)
@@ -210,6 +205,8 @@ test('open packages render with names, reward and deadline; Load is enabled at a
   await expect(rows.first(), 'an open package row appears').toBeVisible({ timeout: 15_000 });
   await expect(rows.first()).toContainText(/→/);
   await expect(page.locator('[data-testid^="open-package-reward-"]').first()).toContainText('€');
+  // v0.48.0 (ISS-095): leg distance on the job row — integer km, no space before "km".
+  await expect(page.locator('[data-testid^="open-package-distance-"]').first()).toHaveText(/^\d+km$/);
 
   // Deterministic target: a hook-created EDDF package — Load is enabled (starter at origin, free slot).
   const nearest = await nearestToHub(page);
@@ -220,6 +217,8 @@ test('open packages render with names, reward and deadline; Load is enabled at a
   // 4 t is within the starter ATR's 4.8 t maxPayloadKg, so Load stays enabled below.
   await expect(page.getByTestId(`open-package-cargo-${pkg.id}`)).toContainText('4.0t');
   await expect(page.getByTestId(`open-package-reward-${pkg.id}`)).toContainText(eur(pkg.reward));
+  // v0.48.0 (ISS-095): the hook-created package's row shows its leg distance too.
+  await expect(page.getByTestId(`open-package-distance-${pkg.id}`)).toHaveText(/^\d+km$/);
   const loadBtn = page.getByTestId(`load-${pkg.id}`);
   await expect(loadBtn).toBeEnabled();
 
@@ -251,15 +250,19 @@ test('a priority package shows its special badge on the open-package row', async
   await expect(badge).toHaveText('Priority');
 });
 
-test('Load is disabled when no plane sits at the package origin', async ({ page }) => {
+test('open jobs only appear where a plane can take them — foreign-origin jobs are hidden', async ({ page }) => {
   test.setTimeout(300_000); // self-heal can take minutes after an interrupted run
-  await flyHomeViaApi(page); // starter at EDDF — a Madrid-origin package cannot be loaded here
+  await flyHomeViaApi(page); // starter at EDDF — the pool is just {EDDF}
 
   const pkg = await createPackage(page, 'LEMD', HUB);
+  expect(pkg.originIcao).toBe('LEMD');
+  // v0.65.0: open jobs are only visible from airports where a plane can take them (the pool). LEMD is
+  // not in the pool while the starter sits at EDDF, so the job exists server-side but never reaches
+  // /api/state — no row and no disabled Load button to speak of.
+  expect((await getState(page)).packages.some((p) => p.id === pkg.id), 'a non-pool-origin open job must not appear in /api/state').toBe(false);
+
   await page.goto('/');
-  const row = page.locator(`li[data-testid="open-package-${pkg.id}"]`);
+  await expect(page.locator(`li[data-testid="open-package-${pkg.id}"]`)).toHaveCount(0, { timeout: 15_000 });
-  await expect(row).toBeVisible({ timeout: 15_000 });
-  await expect(page.getByTestId(`load-${pkg.id}`)).toBeDisabled();
 });
 
 test('on-board list: fly-to-destination + abandon with penalty preview; flying planes show their leg', async ({ page }) => {
@@ -275,13 +278,19 @@ test('on-board list: fly-to-destination + abandon with penalty preview; flying p
   const onboardRow = page.getByTestId(`onboard-package-${pkg.id}`);
   await expect(onboardRow, 'loaded package appears in the on-board list').toBeVisible({ timeout: 15_000 });
 
-  // The abandon button previews the exact penalty at the snapshot's clock (same formula as the server).
+  // The abandon button previews the penalty at its snapshot's clock (same formula as the server).
-  // Freeze the clock first so every snapshot — mine and the UI's last poll — shares one clock value,
+  // The fleet is grounded here (the starter just loaded; workers:1 and every spec's cleanup leave no
-  // making the preview deterministic instead of racing the 1 s poll loop.
+  // other planes), so the world clock is FROZEN (#135) — verify it actually is, then the preview must
-  await postSim(page, { paused: true });
+  // match the server exactly: a frozen clock means zero drift between any two snapshots.
+  const c0 = (await getState(page)).simState.clockMs;
+  await new Promise((r) => setTimeout(r, 1_500)); // > one background-tick interval
   const state = await getState(page);
+  expect(state.simState.clockMs - c0, 'the grounded clock must stay frozen (#135)').toBe(0);
+
+  const penaltyText = ((await page.getByTestId(`abandon-penalty-${pkg.id}`).textContent()) ?? '').replace(/[^0-9.]/g, '');
+  expect(Number.isFinite(Number(penaltyText)), `penalty text: ${penaltyText}`).toBe(true);
   const expectedPenalty = penaltyFor(pkg.reward, pkg.createdSimTime, pkg.deadlineSimTime, state.simState.clockMs);
-  await expect(page.getByTestId(`abandon-penalty-${pkg.id}`)).toContainText(eur(expectedPenalty));
+  expect(Number(penaltyText), 'frozen clock → the preview matches the server exactly').toBe(expectedPenalty);
 
   // Fly to the destination through the UI — the button is the destination's name.
   const flyBtn = page.getByTestId(`fly-to-${pkg.id}`);
@@ -299,8 +308,7 @@ test('on-board list: fly-to-destination + abandon with penalty preview; flying p
   expect(body.planes.find((p) => p.id === 'plane-starter')!.status).toBe('flying');
   expect(body.planes.find((p) => p.id === 'plane-starter')!.destIcao).toBe(nearest.icao);
 
-  // Resume and fast-forward to arrival (poll the authoritative state).
+  // Fast-forward to arrival (poll the authoritative state) — the takeoff above unfroze the world.
-  await postSim(page, { paused: false });
   await setScale(page, SCALE);
   await expect
     .poll(async () => {
@@ -315,8 +323,7 @@ test('on-board list: fly-to-destination + abandon with penalty preview; flying p
   expect(body.packages.find((p) => p.id === pkg.id)?.status).toBe('delivered');
   await expect(onboardRow).not.toBeVisible({ timeout: 15_000 });
 
-  // Restore: fly home so the live instance stays in its onboarding state for the next run.
+  // Restore: fly home at SCALE so the live instance stays in its onboarding state for the next run.
-  // ISS-041: the arrival above paused the sim, so re-set SCALE for this leg (setScale clears pause).
   await setScale(page, SCALE);
   const homeRes = await page.request.post('/api/planes/plane-starter/fly', { data: { destIcao: HUB } });
   expect(homeRes.status()).toBe(200);
@@ -389,11 +396,11 @@ test('dispatch auto-refuels: a low tank tops up to 150% of the leg requirement a
   expect(starter.fuel).toBe(LOW_FUEL); // the hook stuck
 
   // 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.
+  // wind-adjusted requirement, 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.burnPerKm * windBurnFactor(wHub.windKt, wHub.windDirDeg, initialBearingDeg(nearest.hubLat, nearest.hubLon, nearest.lat, nearest.lon)),
     entry.emptyWeightKg,
     entry.maxFuel,
     km,
@@ -424,7 +431,7 @@ test('dispatch auto-refuels: a low tank tops up to 150% of the leg requirement a
 
   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),
+    fuelAtWeighted(target, entry.burnPerKm * windBurnFactor(wHub.windKt, wHub.windDirDeg, initialBearingDeg(nearest.hubLat, nearest.hubLon, nearest.lat, nearest.lon)), entry.emptyWeightKg, entry.maxFuel, km, 1),
     6,
   );
 
@@ -440,38 +447,6 @@ test('dispatch auto-refuels: a low tank tops up to 150% of the leg requirement a
   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 }) => {
-  test.setTimeout(300_000); // self-heal can take minutes after an interrupted run
-  await flyHomeViaApi(page); // deterministic: the starter sits at EDDF
-
-  const nearest = await nearestToHub(page);
-  const pkg = await createPackage(page, HUB, nearest.icao, 24 * 3_600_000);
-
-  await page.goto('/');
-  const row = page.locator(`li[data-testid="open-package-${pkg.id}"]`);
-  await expect(row, 'the hook-created package appears in the list').toBeVisible({ timeout: 15_000 });
-
-  // Ignore through the UI — the post-action snapshot lands immediately (no poll wait).
-  const ignoreBtn = page.getByTestId(`ignore-${pkg.id}`);
-  await expect(ignoreBtn, 'the row has an Ignore button').toBeEnabled();
-  await ignoreBtn.click();
-
-  // Server truth: the package is 'ignored'…
-  await expect
-    .poll(async () => (await getState(page)).packages.find((p) => p.id === pkg.id)?.status, {
-      timeout: 15_000,
-      message: 'waiting for the ignored status in /api/state',
-    })
-    .toBe('ignored');
-
-  // …and the row is gone from the open list (the section filters status==='open').
-  await expect(row).not.toBeVisible({ timeout: 15_000 });
-
-  // A second ignore attempt on the same id is a 409 — 'ignored' is terminal.
-  const again = await page.request.post(`/api/packages/${pkg.id}/ignore`);
-  expect(again.status()).toBe(409);
-});
-
 test('Planes market tab lists all plane types with tech specs', async ({ page }) => {
   await page.goto('/');
   const body = await getState(page); // authoritative catalog — v0.28.0 ships six types
@@ -479,11 +454,11 @@ test('Planes market tab lists all plane types with tech specs', async ({ page })
 
   await page.getByTestId('tab-planes-market').click();
 
-  // ATR card: name + full-tank range from the same closed form as lib/sim/movement.ts (v0.28.0).
+  // ATR card: name + guaranteed full-tank range (worst-case headwind) from lib/sim/movement.ts (v0.51.0).
   const atr = body.catalog.find((e) => e.model === 'atr72')!;
   await expect(page.getByTestId('plane-type-atr72'), 'the ATR card appears').toBeVisible({ timeout: 15_000 });
   await expect(page.getByTestId('plane-type-atr72')).toContainText(atr.label);
-  const atrRange = Math.round(maxRangeKm(atr.burnPerKm, atr.emptyWeightKg, atr.maxFuel));
+  const atrRange = Math.round(guaranteedRangeKm(atr.burnPerKm, atr.emptyWeightKg, atr.maxFuel));
   await expect(page.getByTestId('plane-type-range-atr72')).toContainText(`${atrRange} km`);
 
   // Ladder sanity: the most expensive type (Boeing 777-300ER) is present with its €9M price.

e2e/sim.spec.ts

@@ -1,157 +1,216 @@
 import { test, expect, type Page } from '@playwright/test';
+// v0.65.0: the open-package count one pool airport keeps — imported (like expiry.spec.ts does) so it
+// can never drift from lib/game/seed.ts. With a single grounded starter plane there is exactly one
+// pool, at EDDF.
+import { POOL_TARGET_PER_AIRPORT as POOL_TARGET } from '../lib/game/seed';
 
-// v0.7.0 sim engine against the live origin: tick-on-read clock advance at a
+// v0.52.0 (ISS-117), finalized in #135: fixed world clock against the live origin — a fully
-// raised time scale, pause freezing, package expiry (via the FLIGHT_TEST_HOOKS
+// grounded fleet freezes the clock, background-tick advance at a raised rate while something is
-// hook enabled in docker-compose.yml), and market top-up.
+// active, package expiry via the FLIGHT_TEST_HOOKS hooks (enabled in docker-compose.yml), and
+// market top-up.
 
 // Must match lib/sim/engine.ts — kept in sync manually (same pattern as MIN_ZOOM/MAX_ZOOM in map.spec.ts).
 const MAX_TICK_ELAPSED_MS = 2_000;
-const SCALE = 1000; // fastest sim speed — top of the v0.14.0 ladder
+const SCALE = 1000; // test rate for fast-forwarding legs
+const WORLD = 24; // the fixed world rate (ISS-117) — must match lib/worldClock.ts
 const MAX_DELTA_PER_TICK = MAX_TICK_ELAPSED_MS * SCALE; // 2_000_000 game ms per tick at scale 1000
-// Must match MARKET_TARGET_OPEN_PACKAGES in lib/game/seed.ts.
+const STARTER = 'plane-starter';
-const MARKET_TARGET = 10;
-
-interface SimState {
-  clockMs: number;
-  timeScale: number;
-  paused: boolean;
-}
 
 interface StateBody {
   account: { cash: number; reputation: number };
-  simState: SimState;
+  simState: { clockMs: number }; // ISS-117: the snapshot carries only the game clock
-  planes: Array<Record<string, unknown>>;
+  planes: Array<{ id: string; status: string }>;
   packages: Array<{ id: string; status: string; deadlineSimTime: number }>;
 }
 
 const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));
 
-async function postSim(page: Page, body: unknown) {
-  return page.request.post('/api/sim', { data: body });
-}
-
 async function getState(page: Page): Promise<StateBody> {
+  // ISS-127: /api/state intermittently 500s under scale-1000 dind load; a throw here would
+  // instantly fail any expect.poll callback, so retry briefly instead.
+  for (let attempt = 1; ; attempt++) {
     const res = await page.request.get('/api/state');
-  expect(res.status()).toBe(200);
+    if (res.status() === 200) return (await res.json()) as StateBody;
-  return (await res.json()) as StateBody;
+    if (attempt >= 3) throw new Error(`/api/state returned ${res.status()} after 3 attempts`);
+    await page.waitForTimeout(500);
+  }
 }
 
-// Leave the live instance in a sane state for the other specs (scale 1, running).
+// Test hook (FLIGHT_TEST_HOOKS=1): set the world rate and VERIFY from the response that it stuck.
-test.afterEach(async ({ page }) => {
+async function setScale(page: Page, scale: number): Promise<void> {
-  const res = await postSim(page, { timeScale: 1, paused: false });
+  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);
+}
+
+async function setHealth(page: Page, planeId: string, fields: Record<string, unknown>): Promise<void> {
+  const res = await page.request.post('/api/test/set-health', { data: { planeId, ...fields } });
+  expect(res.status()).toBe(200);
+}
+
+// A fully grounded fleet freezes the world clock (#135) — put the starter in repair so the clock
+// runs at FULL scale for tests that need fast-forwarding. The €1.5k repair cost is irrelevant to
+// every spec's relative cash assertions; deactivateWorld restores full health and no gate afterwards.
+async function activateWorld(page: Page): Promise<void> {
+  await setHealth(page, STARTER, { health: 50 });
+  expect((await page.request.post(`/api/planes/${STARTER}/repair`)).status()).toBe(200);
+}
+
+// Shorten the repair gate to "now" — the next advancing tick flips the plane back to available.
+async function deactivateWorld(page: Page): Promise<void> {
+  await setHealth(page, STARTER, { health: 100, repairUntilMs: 0 });
+  await expect
+    .poll(async () => (await getState(page)).planes.find((p) => p.id === STARTER)?.status ?? '', {
+      timeout: 30_000,
+      message: 'waiting for the starter to flip back to available',
+    })
+    .toBe('available');
+}
+
+// Leave the live instance in a sane state for the other specs (the fixed world rate).
+test.afterEach(async ({ page }) => {
+  await setScale(page, WORLD);
+});
+
+test('a fully grounded fleet freezes the world clock (#135)', async ({ page }) => {
+  const s = await getState(page);
+  expect(s.planes.every((p) => p.status === 'available'), 'fleet should be grounded at spec start').toBe(true);
+
+  const c0 = s.simState.clockMs;
+  await sleep(2_500); // ~2.5 s of real idleness — several background ticks plus the reads below
+  const after = await getState(page);
+
+  expect(after.simState.clockMs - c0, 'the grounded clock must stay frozen').toBe(0);
+});
+
+test('a grounded fleet never starves: draining 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: expire every open package via the test hook (FLIGHT_TEST_HOOKS=1), pass after pass —
+  // ignore was removed in v0.69.0 and loading can't drain a pool either (the starter's payload fits
+  // only the lightest band). 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 around
+  // 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). Expired slots carry no refill cooldown, so the
+  // board comes back on the very next tick.
+  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/test/expire-package', { data: { packageId: p.id } })).status()).toBe(200);
+    }
+  }
+
+  // Expired slots respawn immediately (no cooldown), so the ~1 s background tick must refill the
+  // pool right away — within ~15 s of real time, with headroom for dind slowness…
+  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: 15_000, message: 'waiting for the pool 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 }) => {
-  const post = await postSim(page, { timeScale: SCALE });
+  await activateWorld(page);
-  expect(post.status()).toBe(200);
+  try {
-  const s1 = (await post.json()) as SimState;
+    await setScale(page, SCALE);
-  expect(s1.timeScale).toBe(SCALE);
-  expect(s1.paused).toBe(false);
 
-  let prev = s1.clockMs;
+    let prev = (await getState(page)).simState.clockMs;
     for (let i = 0; i < 3; i++) {
       await sleep(1_000); // one real second ≈ 1000 game seconds at scale 1000 — well under the clamp
-    const body = await getState(page);
+      const now = (await getState(page)).simState.clockMs;
-    const now = body.simState.clockMs;
+      expect(now).toBeGreaterThan(prev); // strictly advances while something is active
-    expect(now).toBeGreaterThan(prev); // strictly advances while actively polled
       expect(now - prev).toBeGreaterThanOrEqual(500_000); // ≥ ~500 ms real × 1000
       expect(now - prev).toBeLessThanOrEqual(MAX_DELTA_PER_TICK + 60); // clamp bounds each tick
       prev = now;
     }
-});
+  } finally {
-
+    await deactivateWorld(page);
-test('paused freezes the clock exactly across polls', async ({ page }) => {
-  const post = await postSim(page, { timeScale: SCALE, paused: true });
-  expect(post.status()).toBe(200);
-  const s1 = (await post.json()) as SimState;
-  expect(s1.paused).toBe(true);
-
-  for (let i = 0; i < 3; i++) {
-    await sleep(500);
-    const body = await getState(page);
-    expect(body.simState.clockMs).toBe(s1.clockMs); // frozen — no advance while paused
   }
 });
 
-test('an open package past its short deadline expires and the market stays topped up', async ({ page }) => {
+test('an open job past its wall-clock lifetime expires and its pool slot refills', async ({ page }) => {
-  test.setTimeout(60_000);
-
   const before = await getState(page);
   const victim = before.packages.find((p) => p.status === 'open');
   expect(victim).toBeDefined(); // steady state always has open packages
 
-  // Test-only hook (FLIGHT_TEST_HOOKS=1 in docker-compose): move an existing open
+  // Test-only hook (FLIGHT_TEST_HOOKS=1 in docker-compose): ages the job's createdRealMs past its
-  // package's deadline ~10 game-seconds out so expiry is observable at scale 1000.
+  // lifetime and runs a tick, so it comes back already expired — v0.65.0 expiry is wall-clock, no
+  // scale or clock activation needed.
   const hook = await page.request.post('/api/test/expire-package', { data: { packageId: victim!.id } });
   expect(hook.status()).toBe(200);
-  const moved = (await hook.json()) as { id: string; deadlineSimTime: number };
+  const moved = (await hook.json()) as { id: string; status: string };
   expect(moved.id).toBe(victim!.id);
+  expect(moved.status, 'the aged job should be expired by the tick the hook runs').toBe('expired');
 
-  await postSim(page, { timeScale: SCALE });
+  // Expired jobs leave the market…
-
+  let after: StateBody | undefined;
-  let expiredBody: StateBody | undefined;
   await expect
     .poll(async () => {
       const body = await getState(page);
-      if (body.packages.find((p) => p.id === moved.id)?.status === 'expired') expiredBody = body;
+      if (body.packages.filter((p) => p.status === 'open').length >= POOL_TARGET) after = body;
-      return !!expiredBody;
+      return !!after;
-    }, { timeout: 30_000, message: 'waiting for the short-deadline package to expire' })
+    }, { timeout: 15_000, message: 'waiting for the pool to refill after expiry' })
     .toBe(true);
-
+  // …and the spawner refills the pool back up — never below its target.
-  const after = expiredBody!;
+  expect(after!.packages.filter((p) => p.status === 'open').length).toBeGreaterThanOrEqual(POOL_TARGET);
-  expect(after.packages.find((p) => p.id === moved.id)?.status).toBe('expired');
+  expect(after!.packages.some((p) => p.id === moved.id && p.status === 'open')).toBe(false); // expired stays out of the market
-  // Expired packages leave the available set…
-  expect(after.packages.filter((p) => p.status === 'open').some((c) => c.id === moved.id)).toBe(false);
-  // …and spawn tops the market back up to the target — never below it.
-  const openCount = after.packages.filter((p) => p.status === 'open').length;
-  expect(openCount).toBeGreaterThanOrEqual(MARKET_TARGET);
 });
 
-test('the hook can also create a fresh short-deadline package, which then expires', async ({ page }) => {
+test('the hook can also create an already-aged job, which is expired by response time', async ({ page }) => {
-  test.setTimeout(60_000);
-
   const created = await page.request.post('/api/test/expire-package');
   expect(created.status()).toBe(201);
   const c = (await created.json()) as { id: string; status: string };
-  expect(c.status).toBe('open');
+  // The hook ages the job before its final tick, so it never even appears open in /api/state.
+  expect(c.status).toBe('expired');
 
-  await postSim(page, { timeScale: SCALE });
+  let after: StateBody | undefined;
-
-  let expiredBody: StateBody | undefined;
   await expect
     .poll(async () => {
       const body = await getState(page);
-      if (body.packages.find((p) => p.id === c.id)?.status === 'expired') expiredBody = body;
+      if (body.packages.filter((p) => p.status === 'open').length >= POOL_TARGET) after = body;
-      return !!expiredBody;
+      return !!after;
-    }, { timeout: 30_000, message: 'waiting for the hook-created package to expire' })
+    }, { timeout: 15_000, message: 'waiting for the pool to refill after the hook-created job expired' })
     .toBe(true);
-
+  expect(after!.packages.filter((p) => p.status === 'open').length).toBeGreaterThanOrEqual(POOL_TARGET); // top-up held after this expiry too
-  const openCount = expiredBody!.packages.filter((p) => p.status === 'open').length;
-  expect(openCount).toBeGreaterThanOrEqual(MARKET_TARGET); // top-up held after this expiry too
 });
 
-test('POST /api/sim validates and clamps its input', async ({ page }) => {
+test('POST /api/test/set-timescale validates its input', async ({ page }) => {
-  const clampHigh = await postSim(page, { timeScale: 2000 });
+  const ok = await page.request.post('/api/test/set-timescale', { data: { timeScale: 500 } });
-  expect(clampHigh.status()).toBe(200);
+  expect(ok.status()).toBe(200);
-  expect(((await clampHigh.json()) as SimState).timeScale).toBe(1000); // top of the ladder (v0.14.0)
+  expect(((await ok.json()) as { timeScale: number }).timeScale).toBe(500); // echoed back for assertions
 
-  const inRange = await postSim(page, { timeScale: 500 });
+  for (const body of [{ timeScale: 'fast' }, { timeScale: 1e9 }, { bogus: 1 }]) {
-  expect(inRange.status()).toBe(200);
+    const res = await page.request.post('/api/test/set-timescale', { data: body });
-  expect(((await inRange.json()) as SimState).timeScale).toBe(500); // ladder value passes through unclamped
-
-  const clampLow = await postSim(page, { timeScale: 0.1 });
-  expect(clampLow.status()).toBe(200);
-  expect(((await clampLow.json()) as SimState).timeScale).toBe(1);
-
-  for (const body of [{ timeScale: 'fast' }, { paused: 'yes' }, { bogus: 1 }]) {
-    const res = await postSim(page, body);
     expect(res.status()).toBe(400);
   }
-  const notJson = await page.request.post('/api/sim', { data: 'nope{' });
+  const notJson = await page.request.post('/api/test/set-timescale', { data: 'nope{' });
   expect(notJson.status()).toBe(400);
 
-  // Empty body is a valid no-op (just ticks + returns current state).
+  // Empty body is a 400 — the hook requires an explicit rate (unlike the old /api/sim no-op).
-  const empty = await postSim(page, {});
+  const empty = await page.request.post('/api/test/set-timescale', { data: {} });
-  expect(empty.status()).toBe(200);
+  expect(empty.status()).toBe(400);
 });

e2e/slow-on-landing.spec.ts

@@ -1,141 +0,0 @@
-import type { Page } from '@playwright/test';
-import { expect, test } from '@playwright/test';
-
-// v0.30.0 — ISS-057: when a landing leaves any plane on the ground the sim slows to 1× server-side
-// WITHOUT pausing (pause is manual-only now), and starting a flight (POST /api/planes/{id}/fly)
-// restores the last MANUALLY selected speed once no plane remains grounded. The cycle: dispatch at
-// 1000× → landing slows to 1× → next dispatch (last grounded plane airborne) resumes 1000×.
-
-const SCALE = 1000; // fastest sim speed — top of the v0.14.0 ladder (same convention as e2e/sim.spec.ts)
-const HUB = 'EDDF'; // Frankfurt Main — the seeded starter plane's home base (lib/game/seed.ts)
-
-interface SimState {
-  clockMs: number;
-  timeScale: number;
-  paused: boolean;
-}
-
-interface StateBody {
-  simState: SimState;
-  planes: Array<{ id: string; status: string; locationIcao: string; destIcao: string | null }>;
-}
-
-async function getState(page: Page): Promise<StateBody> {
-  const res = await page.request.get('/api/state');
-  expect(res.ok()).toBeTruthy();
-  return (await res.json()) as StateBody;
-}
-
-async function postSim(page: Page, body: Record<string, unknown>): Promise<void> {
-  const res = await page.request.post('/api/sim', { data: body });
-  expect(res.status()).toBe(200);
-}
-
-// Set the time scale and VERIFY from the response that it stuck — if something external ever
-// resets the live instance's controls mid-test, fail loudly here instead of timing out later.
-// ISS-057 also records this as lastSelectedTimeScale (the resume target) and clears pause, so any
-// fast-forward after a manual pause or a slowed-to-1× landing proceeds at full speed.
-async function setScale(page: Page, scale: number): Promise<void> {
-  const res = await page.request.post('/api/sim', { data: { timeScale: scale, paused: false } });
-  expect(res.status()).toBe(200);
-  const body = (await res.json()) as SimState;
-  expect(body.timeScale, `timeScale should be ${scale} after POST /api/sim`).toBe(scale);
-}
-
-// Closest airport to the hub from /api/airports → shortest possible leg (fastest e2e flight).
-async function nearestToHub(page: Page): Promise<{ icao: string }> {
-  const res = await page.request.get('/api/airports');
-  expect(res.ok()).toBeTruthy();
-  const fc = (await res.json()) as { features: Array<{ properties: { icao: string; lat: number; lon: number } }> };
-  const hub = fc.features.find((f) => f.properties.icao === HUB)!.properties;
-  let nearest = fc.features.filter((f) => f.properties.icao !== HUB)[0].properties;
-  for (const f of fc.features) {
-    if (f.properties.icao === HUB) continue;
-    const d = Math.hypot(f.properties.lat - hub.lat, f.properties.lon - hub.lon);
-    const dn = Math.hypot(nearest.lat - hub.lat, nearest.lon - hub.lon);
-    if (d < dn) nearest = f.properties;
-  }
-  return { icao: nearest.icao };
-}
-
-// Self-heal helper (same pattern as e2e/relocation.spec.ts): let any in-flight leg finish and
-// reposition plane-starter home via the API so every test starts from the canonical state even
-// after an interrupted previous run.
-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×).
-    await setScale(page, SCALE);
-  }
-  if (plane.status === 'flying') {
-    // Let the in-flight leg finish before repositioning. While flying, locationIcao stays at the
-    // DEPARTURE airport — re-read state after landing before deciding whether a repositioning
-    // flight is needed.
-    await expect.poll(async () => ((await getState(page)).planes.find((p) => p.id === 'plane-starter')!.status), { timeout: 240_000 }).toBe('available');
-    s = await getState(page);
-    plane = s.planes.find((p) => p.id === 'plane-starter')!;
-  }
-  if (plane.locationIcao !== HUB) {
-    // ISS-057: the landing above slowed the sim to 1× — setScale restores 1000× (and records it as
-    // lastSelectedTimeScale) so the return leg fast-forwards instead of taking real-time hours.
-    await setScale(page, SCALE);
-    // 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.
-    const flyHome = await page.request.post(`/api/planes/${plane.id}/fly`, { data: { destIcao: HUB } });
-    expect(flyHome.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);
-  }
-}
-
-// Self-heal in CLEANUP (afterEach): the test deliberately leaves plane-starter at the far end, so
-// fast-forward + reposition home here; then restore scale=1 / unpaused for later specs.
-test.afterEach(async ({ page }) => {
-  await flyHomeViaApi(page);
-  await postSim(page, { timeScale: 1, paused: false });
-});
-
-test.describe.configure({ mode: 'serial' }); // shared live DB — order matters within this file
-
-test('landing slows the sim to 1× without pausing; dispatch restores the last selected speed (ISS-057)', async ({ page }) => {
-  test.setTimeout(300_000); // self-heal (worst case ~20 s at 1000×) + two short legs
-  await flyHomeViaApi(page); // deterministic: the starter sits grounded at EDDF
-
-  const nearest = await nearestToHub(page);
-
-  // Set 1000× via the API and verify it stuck (also records lastSelectedTimeScale=1000).
-  await setScale(page, SCALE);
-
-  // Dispatch plane-starter on the shortest leg from its hub (repositioning — no package needed).
-  const flyRes = await page.request.post('/api/planes/plane-starter/fly', { data: { destIcao: nearest.icao } });
-  expect(flyRes.status()).toBe(200);
-
-  // Wait for the landing…
-  let landedBody: StateBody | undefined;
-  await expect
-    .poll(async () => {
-      const b = await getState(page);
-      const p = b.planes.find((x) => x.id === 'plane-starter')!;
-      if (p.status === 'available' && p.locationIcao === nearest.icao) landedBody = b;
-      return !!landedBody;
-    }, { timeout: 120_000, message: `waiting for plane-starter to land at ${nearest.icao}` })
-    .toBe(true);
-
-  // …and the server slowed the sim to 1× WITHOUT pausing — persisted on sim_state, so this very
-  // snapshot shows it (the just-landed plane is on ground → slow; ISS-057).
-  expect(landedBody!.simState.paused).toBe(false);
-  expect(landedBody!.simState.timeScale).toBe(1);
-
-  // A subsequent /fly dispatch restores the last selected speed — asserted on the endpoint's OWN
-  // full post-action snapshot, so no poll race with the client's next tick. setScale posted 1000
-  // above, so lastSelectedTimeScale is 1000 and this dispatch (sole grounded plane → airborne)
-  // resumes it.
-  const fly2 = await page.request.post('/api/planes/plane-starter/fly', { data: { destIcao: HUB } });
-  expect(fly2.status()).toBe(200);
-  const resumedBody = (await fly2.json()) as StateBody;
-  expect(resumedBody.simState.paused).toBe(false); // dispatch still clears a manual pause…
-  expect(resumedBody.simState.timeScale).toBe(SCALE); // …and restores the last selected speed
-
-  // Let the return leg finish so cleanup starts from a grounded plane.
-  await expect.poll(async () => ((await getState(page)).planes.find((p) => p.id === 'plane-starter')!.status), { timeout: 120_000 }).toBe('available');
-});

e2e/state.spec.ts

@@ -10,7 +10,7 @@ const composeArgs = process.env.E2E_COMPOSE_ARGS ?? '';
 
 interface StateBody {
   account: { cash: number; reputation: number };
-  simState: { clockMs: number; timeScale: number; paused: boolean };
+  simState: { clockMs: number }; // ISS-117: the snapshot carries only the game clock
   planes: Array<Record<string, unknown>>;
   packages: Array<Record<string, unknown>>;
 }
@@ -24,9 +24,7 @@ test('GET /api/state returns a seeded snapshot', async ({ page }) => {
   expect(typeof body.account.cash).toBe('number');
   expect(typeof body.account.reputation).toBe('number');
 
-  expect(typeof body.simState.clockMs).toBe('number');
+  expect(typeof body.simState.clockMs).toBe('number'); // ISS-117: time controls are gone — clock only
-  expect(typeof body.simState.timeScale).toBe('number');
-  expect(body.simState.paused).toBe(false);
 
   expect(Array.isArray(body.planes)).toBe(true);
   expect(body.planes.length).toBeGreaterThanOrEqual(1);
@@ -44,6 +42,17 @@ test('GET /api/state returns a seeded snapshot', async ({ page }) => {
 test('state survives a container restart (sim clock + account persisted)', async ({ page }) => {
   test.setTimeout(180_000);
 
+  // Self-heal to a fully grounded fleet first — a grounded fleet freezes the world clock (#135),
+  // so no tick advances it across the restart and the post-restart clock is exactly unchanged.
+  await expect
+    .poll(async () => {
+      const res = await page.request.get('/api/state');
+      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 resBefore = await page.request.get('/api/state');
   expect(resBefore.status()).toBe(200);
   const before = (await resBefore.json()) as StateBody;
@@ -67,18 +76,59 @@ test('state survives a container restart (sim clock + account persisted)', async
   expect(after).toBeDefined();
   const a = after!;
 
-  // The DB file on the volume must be loaded, not re-seeded (PLAN.md: "sim clock
+  // The DB file on the volume must be loaded, not re-seeded (PLAN.md: "sim clock persisted across
-  // persisted across sessions"): account and entity ids are byte-identical.
+  // sessions"): account and entity ids are byte-identical. With the fleet grounded above, the world
-  // v0.7.0 tick-on-read caveat: every GET advances the clock by at most one
+  // clock is FROZEN (#135) — no tick advances it while the container is down or after restart, so
-  // clamped tick (MAX_TICK_ELAPSED_MS × timeScale, see lib/sim/engine.ts), so the
+  // the post-restart clock is EXACTLY unchanged; a re-seed would reset clockMs backwards instead.
-  // post-restart clock may be ahead — but never by more than that bound.
+  expect(a.simState.clockMs - before.simState.clockMs).toBe(0);
-  expect(a.simState.clockMs).toBeGreaterThanOrEqual(before.simState.clockMs);
-  const MAX_TICK_ELAPSED_MS = 2_000; // must match lib/sim/engine.ts
-  expect(a.simState.clockMs - before.simState.clockMs).toBeLessThanOrEqual(
-    MAX_TICK_ELAPSED_MS * a.simState.timeScale,
-  );
   expect(a.account.cash).toBe(before.account.cash);
   expect(a.account.reputation).toBe(before.account.reputation);
   expect(a.planes.map((p) => p.id).sort()).toEqual(before.planes.map((p) => p.id).sort());
   expect(a.packages.map((p) => p.id).sort()).toEqual(before.packages.map((p) => p.id).sort());
 });
+
+test('queued legs survive a container restart (v0.46.0)', async ({ page }) => {
+  test.setTimeout(180_000);
+
+  // Self-heal: the suite runs serially and every spec leaves plane-starter grounded, but an
+  // interrupted run may not — wait it out before staging a queue (queueLeg works while flying too).
+  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 String(body.planes.find((p) => p.id === 'plane-starter')?.status ?? 'missing');
+    }, { timeout: 120_000, message: 'waiting for plane-starter to be grounded' })
+    .toBe('available');
+
+  // Stage a two-leg queue on the starter…
+  const q1 = await page.request.post('/api/planes/plane-starter/queue', { data: { destIcao: 'LEMD' } });
+  expect(q1.status()).toBe(200);
+  const q2 = await page.request.post('/api/planes/plane-starter/queue', { data: { destIcao: 'EHAM' } });
+  expect(q2.status()).toBe(200);
+
+  execSync(`docker compose ${composeArgs} restart flight`, { cwd: repoRoot, stdio: 'pipe' });
+
+  // Wait for the app to come back, capturing the post-restart snapshot.
+  let after: StateBody | undefined;
+  await expect
+    .poll(async () => {
+      try {
+        const res = await page.request.get('/api/state');
+        if (res.status() === 200) after = (await res.json()) as StateBody;
+        return !!after;
+      } catch {
+        return false; // connection refused / 502 while the container starts
+      }
+    }, { timeout: 120_000, message: 'waiting for /api/state after docker compose restart' })
+    .toBe(true);
+
+  const p = after!.planes.find((x) => x.id === 'plane-starter')!;
+  expect(p.queue).toEqual(['LEMD', 'EHAM']); // the queue persisted byte-identical, in order…
+
+  // Cleanup: cancel both legs so the starter is left with an empty queue.
+  for (let i = 0; i < 2; i++) {
+    const c = await page.request.post('/api/planes/plane-starter/queue/cancel', { data: { index: 0 } });
+    expect(c.status()).toBe(200);
+  }
+});

e2e/toasts.spec.ts

@@ -18,9 +18,14 @@ interface StateBody {
 }
 
 async function getState(page: Page): Promise<StateBody> {
+  // ISS-127: /api/state intermittently 500s under scale-1000 dind load; a throw here would
+  // instantly fail any expect.poll callback, so retry briefly instead.
+  for (let attempt = 1; ; attempt++) {
     const res = await page.request.get('/api/state');
-  expect(res.status()).toBe(200);
+    if (res.status() === 200) return (await res.json()) as StateBody;
-  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('failed actions toast at the map right edge, clear of the right pane (inline error stays), and the Time section offers a notifications opt-in', async ({ page }) => {

e2e/two-planes.spec.ts

@@ -10,14 +10,15 @@ import { windBurnFactor } from '../lib/sim/movement';
 // if both planes are on the same airport") was UX-only: LoadControls' multi-plane path rendered a
 // greyed-out Load button until a plane was picked from the dropdown, while the single-plane path
 // is one-click. v0.31.0 preselects the first eligible plane (components/RightPane.tsx), and this
-// spec covers every two-plane flow: load (preselect + picker), parallel flights with the ISS-057
+// spec covers every two-plane flow: load (preselect + picker), parallel flights, relocate,
-// slow/resume semantics, relocate, per-plane queues (scoped testids) and sell.
+// per-plane queues (scoped testids) and sell.
 //
 // Each test buys its own second plane via the UI (after a cash grant from the new
 // POST /api/test/add-cash hook — ATR €200k vs the €20k starting balance); beforeEach/afterEach
 // guarantee the fleet is exactly one plane (the starter, grounded at EDDF) before and after.
 
-const SCALE = 1000; // fastest sim speed (v0.14.0 ladder top) — keeps flights to seconds of real time
+const SCALE = 1000; // test rate for fast-forwarding legs — keeps flights to seconds of real time
+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)
 const BUY_MODEL = 'atr72'; // cheapest catalog entry — the second plane every test buys
@@ -37,7 +38,7 @@ interface PackageState {
   id: string;
   originIcao: string;
   destIcao: string;
-  status: 'open' | 'loaded' | 'delivered' | 'expired' | 'abandoned' | 'ignored';
+  status: 'open' | 'loaded' | 'delivered' | 'expired' | 'abandoned';
   planeId: string | null;
 }
 
@@ -54,7 +55,7 @@ interface CatalogEntry {
 
 interface StateBody {
   account: { cash: number; reputation: number };
-  simState: { clockMs: number; timeScale: number; paused: boolean };
+  simState: { clockMs: number }; // ISS-117: the snapshot carries only the game clock
   planes: PlaneState[];
   packages: PackageState[];
   catalog: CatalogEntry[];
@@ -66,23 +67,22 @@ interface StateBody {
 const eur = (v: number) => new Intl.NumberFormat('en-US', { style: 'currency', currency: 'EUR' }).format(v);
 
 async function getState(page: Page): Promise<StateBody> {
+  // ISS-127: /api/state intermittently 500s under scale-1000 dind load; a throw here would
+  // instantly fail any expect.poll callback, so retry briefly instead.
+  for (let attempt = 1; ; attempt++) {
     const res = await page.request.get('/api/state');
-  expect(res.status()).toBe(200);
+    if (res.status() === 200) return (await res.json()) as StateBody;
-  return (await res.json()) as StateBody;
+    if (attempt >= 3) throw new Error(`/api/state returned ${res.status()} after 3 attempts`);
+    await page.waitForTimeout(500);
+  }
 }
 
-async function postSim(page: Page, body: unknown) {
+// Test hook (FLIGHT_TEST_HOOKS=1): set the world rate and VERIFY from the response that it stuck.
-  return page.request.post('/api/sim', { data: body });
-}
-
-// Set the time scale and VERIFY from the response that it stuck. Also records lastSelectedTimeScale
-// (the ISS-057 resume target) and clears pause — so any fast-forward after a slowed-to-1× landing
-// proceeds at full speed.
 async function setScale(page: Page, scale: number): Promise<void> {
-  const res = await page.request.post('/api/sim', { data: { timeScale: scale, paused: false } });
+  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/sim`).toBe(scale);
+  expect(body.timeScale, `timeScale should be ${scale} after POST /api/test/set-timescale`).toBe(scale);
 }
 
 // Mirrors haversineKm in lib/geo.ts (same formula → identical floats).
@@ -230,17 +230,14 @@ async function healPlaneHome(page: Page, planeId: string): Promise<void> {
   await clearQueueViaApi(page, planeId);
   let p = (await getState(page)).planes.find((x) => x.id === planeId);
   if (!p) return; // already sold — nothing to heal
-  // ISS-057: a prior landing may have slowed the sim to 1× — restore 1000× first so any in-flight leg
+  // Make sure the world rate is at SCALE so any in-flight leg completes fast.
-  // completes fast. Re-applied inside the poll below, since a sibling's landing mid-wait slows it again.
   await setScale(page, SCALE);
   if (p.status === 'flying') {
     // While flying, locationIcao stays at the DEPARTURE airport — re-read state after landing.
     await expect
       .poll(async () => {
         const s = await getState(page);
-        const plane = s.planes.find((x) => x.id === planeId);
+        return s.planes.find((x) => x.id === planeId)?.status ?? '';
-        if (plane?.status === 'flying' && s.simState.timeScale !== SCALE) await setScale(page, SCALE); // sibling landing re-slowed to 1×
-        return plane?.status ?? '';
       }, {
         timeout: 240_000,
         message: `waiting for an in-flight ${planeId} to land`,
@@ -249,9 +246,8 @@ async function healPlaneHome(page: Page, planeId: string): Promise<void> {
     p = (await getState(page)).planes.find((x) => x.id === planeId)!;
   }
   if (p.locationIcao !== HUB) {
-    // ISS-057: the landing above slowed the sim to 1× — setScale restores 1000× for the return leg.
+    // Make sure the world rate is back at SCALE for the return leg. ISS-082: dispatch auto-refuels,
-    // ISS-082: dispatch auto-refuels, so a grounded plane can always start any full-tank-flyable
+    // so a grounded plane can always start any full-tank-flyable leg when cash allows — no top-up retry needed.
-    // leg when cash allows — no top-up retry needed.
     await setScale(page, SCALE);
     const flyHome = await page.request.post(`/api/planes/${planeId}/fly`, { data: { destIcao: HUB } });
     expect(flyHome.status()).toBe(200);
@@ -295,8 +291,7 @@ test.beforeEach(async ({ page }) => {
 
 test.afterEach(async ({ page }) => {
   await sellNonStarters(page); // a failure mid-test may have left the second plane behind (even in flight)
-  const res = await postSim(page, { timeScale: 1, paused: false });
+  await setScale(page, WORLD);
-  expect(res.status()).toBe(200);
 });
 
 test('two grounded planes: Load is one-click with a preselected plane; the picker routes to the other', async ({ page }) => {
@@ -348,7 +343,7 @@ test('two grounded planes: Load is one-click with a preselected plane; the picke
   await expect(page.getByTestId(`plane-${secondId}`), 'the second plane row renders').toBeVisible({ timeout: 15_000 });
 });
 
-test('two planes fly in parallel; the last landing slows to 1× and the next dispatch resumes', async ({ page }) => {
+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
   const secondId = await buySecondPlaneViaUi(page);
 
@@ -358,7 +353,7 @@ test('two planes fly in parallel; the last landing slows to 1× and the next dis
 
   // Two very different leg lengths: the starter takes the SHORTEST hop, the second plane the longest
   // full-tank-flyable one — their landings are separated by hours of game time and can never fall on
-  // the same tick (ISS-057 slows to 1× on ANY landing, so a shared-tick arrival would race the asserts).
+  // the same tick (a shared-tick arrival would race the first-landing assert).
   const [nearest] = await twoNearestToHub(page);
   const farthest = await farthestFlyableToHub(page);
 
@@ -388,8 +383,6 @@ test('two planes fly in parallel; the last landing slows to 1× and the next dis
     })
     .toBe(true);
 
-  // …restore speed (that landing slowed the sim to 1× — ISS-057) so the long leg fast-forwards too.
-  await setScale(page, SCALE);
   await expect
     .poll(async () => ((await getState(page)).planes.every((p) => p.status === 'available')), {
       timeout: 240_000,
@@ -397,10 +390,7 @@ test('two planes fly in parallel; the last landing slows to 1× and the next dis
     })
     .toBe(true);
 
-  // ISS-057: the LAST landing left a grounded plane → the sim slowed to 1× WITHOUT pausing.
   const landed = await getState(page);
-  expect(landed.simState.paused).toBe(false);
-  expect(landed.simState.timeScale).toBe(1);
   // Both packages delivered on arrival (in deadline — 24h window vs hours of flight time).
   expect(landed.packages.find((p) => p.id === pkgA.id)?.status).toBe('delivered');
   expect(landed.packages.find((p) => p.id === pkgB.id)?.status).toBe('delivered');
@@ -408,17 +398,9 @@ test('two planes fly in parallel; the last landing slows to 1× and the next dis
   // The outbound to the range edge left the tank nearly empty — top it back up (ISS-082 hook).
   await setFuelFull(page, secondId);
 
-  // Resume semantics: with the starter still grounded, dispatching the second plane does NOT resume…
+  // Cleanup: fly both home so the live instance stays in its onboarding state for later specs.
-  const flyB2 = await page.request.post(`/api/planes/${secondId}/fly`, { data: { destIcao: HUB } });
+  expect((await page.request.post(`/api/planes/${secondId}/fly`, { data: { destIcao: HUB } })).status()).toBe(200);
-  expect(flyB2.status()).toBe(200);
+  expect((await page.request.post(`/api/planes/${STARTER}/fly`, { data: { destIcao: HUB } })).status()).toBe(200);
-  let body = (await flyB2.json()) as StateBody;
-  expect(body.simState.timeScale, 'another plane still grounded → stays at 1×').toBe(1);
-
-  // …but dispatching the LAST grounded plane restores the last manually selected speed.
-  const flyA2 = await page.request.post(`/api/planes/${STARTER}/fly`, { data: { destIcao: HUB } });
-  expect(flyA2.status()).toBe(200);
-  body = (await flyA2.json()) as StateBody;
-  expect(body.simState.timeScale, 'the last grounded plane resumes lastSelectedTimeScale').toBe(SCALE); // setScale posted 1000
 });
 
 // ISS-082 (v0.42.0): the "refuel section lists both planes" test is gone with the manual refuel UI —
@@ -495,21 +477,30 @@ test('per-plane queues are independent; landing auto-chains the next queued leg'
   await expect(page.getByTestId(`queue-leg-${secondId}-0`), 'the cancelled leg is gone').toHaveCount(0, { timeout: 15_000 });
   await expect(starterLeg0, 'the starter queue is untouched by the other plane cancel').toContainText(a.icao);
 
-  // Fly the STARTER to its first queued destination…
+  // Fly the STARTER to its first queued destination — v0.46.0 consumes queue[0] on dispatch, so the
+  // response snapshot must already show only [b] left (previously the leg stayed queued and the
+  // landing chained a zero-distance self-hop a→a before reaching b).
   const flyRes = await page.request.post(`/api/planes/${STARTER}/fly`, { data: { destIcao: a.icao } });
   expect(flyRes.status()).toBe(200);
+  const flyBody = (await flyRes.json()) as StateBody;
+  expect(flyBody.planes.find((x) => x.id === STARTER)!.queue, 'queue[0] consumed on dispatch').toEqual([b.icao]);
 
-  // …fast-forward; on landing at a the server AUTO-CHAINS queue[0] (b) in the same tick — but with
+  // …the outbound leg flies at the fixed world rate (24×) — slow enough that polls can observe the
-  // the second plane still grounded, ISS-057 slows the sim to 1× on that landing. Wait for the chain…
+  // landing and the server's AUTO-CHAIN of queue[0] (b) in the same tick. Wait for the chain…
-  await setScale(page, SCALE);
+  const seen: Array<{ locationIcao: string; destIcao: string | null }> = [];
   await expect
     .poll(async () => {
       const p = (await getState(page)).planes.find((x) => x.id === STARTER);
+      if (p && p.status === 'flying') seen.push({ locationIcao: p.locationIcao, destIcao: p.destIcao });
       return !!p && p.status === 'flying' && p.destIcao === b.icao;
-    }, { timeout: 240_000, message: `waiting for the auto-chained leg ${a} → ${b} to start` })
+    }, { timeout: 120_000, message: `waiting for the auto-chained leg ${a} → ${b} to start` })
     .toBe(true);
 
-  // …then restore speed so the chained leg fast-forwards too.
+  // …and NO snapshot may show the phantom self-hop (location a with dest a) — every observed state
+  // is either the outbound leg (HUB→a) or the chained leg (a→b).
+  expect(seen.filter((s) => s.locationIcao === a.icao && s.destIcao === a.icao), 'phantom self-hop a → a').toEqual([]);
+
+  // …fast-forward the chained leg to its landing.
   await setScale(page, SCALE);
   await expect
     .poll(async () => {

instrumentation.ts

@@ -0,0 +1,9 @@
+import { startBackgroundTick } from '@/lib/sim/engine';
+
+// ISS-117 (v0.52.0): the world clock advances on a ~1 s background tick even with nobody polling —
+// started once at server boot (Next ≥15 instrumentation hook; runs under `next dev` and `next start`).
+export function register() {
+  if (process.env.NEXT_RUNTIME === 'nodejs') {
+    startBackgroundTick();
+  }
+}

lib/airports.test.ts

@@ -1,5 +1,8 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
 import { describe, expect, it } from 'vitest';
-import { parseCsv, filterEuAirports, toGeoJson, airportsHandler } from './airports';
+import { assertUniqueIcaos, filterWorldAirports, isRemote, parseCsv, toGeoJson, airportsHandler, REMOTE_RADIUS_KM } from './airports';
+import { haversineKm } from './geo';
 
 const HEADER =
   '"id","ident","type","name","latitude_deg","longitude_deg","elevation_ft","continent","iso_country","iso_region","municipality","scheduled_service","icao_code","iata_code","gps_code","local_code","home_link","wikipedia_link","keywords"';
@@ -53,25 +56,34 @@ describe('parseCsv', () => {
   });
 });
 
-describe('filterEuAirports', () => {
+describe('filterWorldAirports (v0.44.0 — world dataset, no continent check)', () => {
-  it('keeps EU fixed-wing airports and seaplane bases, drops the rest', () => {
+  it('keeps fixed-wing airports and seaplane bases from every continent, drops the rest by type', () => {
     const rows = parseCsv(
       [
         HEADER,
         row({ ident: 'EU-SMALL', type: 'small_airport' }),
-        row({ ident: 'EU-MED', type: 'medium_airport' }),
+        row({ ident: 'NA-LRG', continent: 'NA', type: 'large_airport' }),
-        row({ ident: 'EU-LRG', type: 'large_airport' }),
+        row({ ident: 'AS-LRG', continent: 'AS', type: 'large_airport' }),
         row({ ident: 'EU-SEA', type: 'seaplane_base' }),
         row({ ident: 'EU-LEGACY', type: 'airport' }),
-        row({ ident: 'EU-Helio', type: 'heliport' }),
+        row({ ident: 'NA-Helio', continent: 'NA', type: 'heliport' }),
-        row({ ident: 'EU-CLOSED', type: 'closed' }),
+        row({ ident: 'AS-CLOSED', continent: 'AS', type: 'closed' }),
-        row({ ident: 'EU-BALLOON', type: 'balloonport' }),
-        row({ ident: 'NA-SMALL', continent: 'NA' }),
-        row({ ident: 'AS-LRG', continent: 'AS', type: 'large_airport' }),
       ].join('\n'),
     );
-    const kept = filterEuAirports(rows).map((r) => r.ident);
+    const kept = filterWorldAirports(rows).map((r) => r.ident);
-    expect(kept.sort()).toEqual(['EU-LEGACY', 'EU-LRG', 'EU-MED', 'EU-SEA', 'EU-SMALL']);
+    expect(kept.sort()).toEqual(['AS-LRG', 'EU-LEGACY', 'EU-SEA', 'EU-SMALL', 'NA-LRG']);
+  });
+});
+
+describe('assertUniqueIcaos (v0.44.0 load-time guard)', () => {
+  it('passes a collection with unique ICACOs and throws on the first duplicate', () => {
+    const ok = toGeoJson(parseCsv([HEADER, row({ ident: 'AAAA', icao_code: 'AAAA' }), row({ ident: 'BBBB', icao_code: 'BBBB' })].join('\n')));
+    expect(() => assertUniqueIcaos(ok)).not.toThrow();
+
+    // icao_code empty → the effective key is the ident fallback (toGeoJson), so a duplicate
+    // ident must trip the guard too.
+    const dup = toGeoJson(parseCsv([HEADER, row({ ident: 'CCCC', icao_code: '' }), row({ ident: 'CCCC', icao_code: '', latitude_deg: '51.0' })].join('\n')));
+    expect(() => assertUniqueIcaos(dup)).toThrow(/duplicate ICAO.*CCCC/);
   });
 });
 
@@ -102,7 +114,7 @@ describe('toGeoJson', () => {
 });
 
 describe('/api/airports handler', () => {
-  it('returns a valid GeoJSON FeatureCollection of EU airports', async () => {
+  it('returns a valid GeoJSON FeatureCollection of world airports', async () => {
     const res = await airportsHandler();
     expect(res.status).toBe(200);
     expect(res.headers.get('content-type')).toContain('application/json');
@@ -123,3 +135,77 @@ describe('/api/airports handler', () => {
     expect(await a.json()).toEqual(await b.json());
   });
 });
+
+describe('isRemote (v0.61.0 — ISS-097 special remote airports)', () => {
+  it('synthetic: an isolated point is remote; a neighbour inside the radius is not', () => {
+    // Equator pair: Δlon 8.5° ≈ 945 km (inside REMOTE_RADIUS_KM) vs Δlon 9.5° ≈ 1052 km (outside).
+    const near = [
+      { icao: 'AAA', lat: 0, lon: 0 },
+      { icao: 'BBB', lat: 0, lon: 8.5 },
+    ];
+    expect(isRemote(near, 'AAA')).toBe(false);
+    expect(isRemote(near, 'BBB')).toBe(false);
+
+    const far = [
+      { icao: 'AAA', lat: 0, lon: 0 },
+      { icao: 'CCC', lat: 0, lon: 9.5 },
+    ];
+    expect(isRemote(far, 'AAA')).toBe(true);
+    expect(isRemote(far, 'CCC')).toBe(true);
+
+    // A lone airport has no other member to be near — remote by definition.
+    expect(isRemote([{ icao: 'SOLO', lat: -77.84, lon: 166.91 }], 'SOLO')).toBe(true);
+  });
+
+  it('real coords: Frankfurt↔Amsterdam (~370 km) is not remote; McMurdo vs Christchurch (~3800 km) is', () => {
+    const eu = [
+      { icao: 'EDDF', lat: 50.0376, lon: 8.5622 }, // Frankfurt Main
+      { icao: 'EHAM', lat: 52.3093, lon: 13.3698 }, // Amsterdam Schiphol
+    ];
+    expect(isRemote(eu, 'EDDF')).toBe(false);
+
+    const pacific = [
+      { icao: 'MCDD', lat: -77.8425, lon: 166.9133 }, // McMurdo Station (Antarctica)
+      { icao: 'NZCH', lat: -43.4893, lon: 172.5308 }, // Christchurch
+    ];
+    expect(isRemote(pacific, 'MCDD')).toBe(true);
+    expect(REMOTE_RADIUS_KM).toBe(1000);
+  });
+
+  it('an unknown ICAO is not remote', () => {
+    expect(isRemote([{ icao: 'AAA', lat: 0, lon: 0 }], 'ZZZ')).toBe(false);
+  });
+
+  it('committed dataset curation rule: every non-large row has no large airport within REMOTE_RADIUS_KM', async () => {
+    const text = await fs.readFile(path.join(process.cwd(), 'data', 'airports_world.csv'), 'utf8');
+    const rows = filterWorldAirports(parseCsv(text));
+    expect(rows.length).toBeGreaterThan(0);
+
+    const large = rows.filter((r) => r.type === 'large_airport').map((r) => ({ icao: r.icao_code || r.ident, lat: +r.latitude_deg, lon: +r.longitude_deg }));
+    const nonLarge = rows.filter((r) => r.type !== 'large_airport');
+    // The dataset must actually carry the "special" airports — not just large ones.
+    expect(nonLarge.length).toBeGreaterThan(0);
+
+    for (const r of nonLarge) {
+      const self = { icao: r.icao_code || r.ident, lat: +r.latitude_deg, lon: +r.longitude_deg };
+      // Remote against the kept set: no LARGE airport within REMOTE_RADIUS_KM (the curation rule).
+      expect(isRemote([...large, self], self.icao), `${self.icao} (${r.name}) must be remote`).toBe(true);
+    }
+  });
+
+  it('committed dataset sparsity rule: every pair of non-large rows is at least REMOTE_RADIUS_KM apart', async () => {
+    const text = await fs.readFile(path.join(process.cwd(), 'data', 'airports_world.csv'), 'utf8');
+    const rows = filterWorldAirports(parseCsv(text));
+    // v0.68.0 (ISS-144): specials are greedily thinned to one per ~REMOTE_RADIUS_KM region, so no
+    // two non-large rows may sit closer than the radius. n≈dozens makes O(n²) trivial.
+    const nonLarge = rows.filter((r) => r.type !== 'large_airport').map((r) => ({ icao: r.icao_code || r.ident, lat: +r.latitude_deg, lon: +r.longitude_deg }));
+    expect(nonLarge.length).toBeGreaterThan(0);
+
+    for (let i = 0; i < nonLarge.length; i++) {
+      for (let j = i + 1; j < nonLarge.length; j++) {
+        const d = haversineKm(nonLarge[i].lat, nonLarge[i].lon, nonLarge[j].lat, nonLarge[j].lon);
+        expect(d, `${nonLarge[i].icao} ↔ ${nonLarge[j].icao}: ${d.toFixed(1)} km < ${REMOTE_RADIUS_KM}`).toBeGreaterThanOrEqual(REMOTE_RADIUS_KM);
+      }
+    }
+  });
+});

lib/airports.ts

@@ -1,5 +1,6 @@
 import { promises as fs } from 'node:fs';
 import path from 'node:path';
+import { haversineKm } from './geo';
 
 export type CsvRow = Record<string, string>;
 
@@ -52,11 +53,36 @@ export function parseCsv(text: string): CsvRow[] {
 // The 2026 schema splits "airport" into small/medium/large_airport (older dumps used a
 // single "airport" type + category column) — both spellings are accepted. Heliports are
 // excluded — no fixed-wing transport ops; other types (closed, balloonport, ...) are
-// irrelevant to an airline-ops game.
+// irrelevant to an airline-ops game. The committed dataset is pre-curated by
+// scripts/build-world-airports.mjs: every large_airport plus the small/medium/seaplane rows
+// that are REMOTE (see isRemote) — this check stays as a cheap guard against an uncurated
+// dump being swapped in.
 const INCLUDED_TYPES = new Set(['airport', 'small_airport', 'medium_airport', 'large_airport', 'seaplane_base']);
 
-export function filterEuAirports(rows: CsvRow[]): CsvRow[] {
+export function filterWorldAirports(rows: CsvRow[]): CsvRow[] {
-  return rows.filter((r) => r.continent === 'EU' && INCLUDED_TYPES.has(r.type));
+  return rows.filter((r) => INCLUDED_TYPES.has(r.type));
+}
+
+// v0.61.0 (ISS-097): "special" remote airports — the issue's loneliness test: an airport is
+// remote when no other member of `airports` sits within this radius, so it stands alone in a
+// genuinely empty region (Antarctica, high Arctic, far islands) rather than being one of many.
+export const REMOTE_RADIUS_KM = 1000;
+
+export interface RemoteAirport {
+  icao: string;
+  lat: number;
+  lon: number;
+}
+
+// True when the airport with this ICAO has no OTHER member of `airports` within REMOTE_RADIUS_KM
+// (haversine). Unknown ICACOs are not remote — callers only pass rows they intend to include.
+export function isRemote(airports: readonly RemoteAirport[], icao: string): boolean {
+  const a = airports.find((x) => x.icao === icao);
+  if (!a) return false;
+  for (const b of airports) {
+    if (b.icao !== a.icao && haversineKm(a.lat, a.lon, b.lat, b.lon) <= REMOTE_RADIUS_KM) return false;
+  }
+  return true;
 }
 
 export interface AirportProperties {
@@ -93,13 +119,26 @@ export function toGeoJson(rows: CsvRow[]): GeoJsonFeatureCollection {
   return { type: 'FeatureCollection', features };
 }
 
+// Three consumers key features by ICAO with silent-overwrite semantics (the map's airport
+// index, the route/queue GeoJSON builders and the sim's airport lookups) — a duplicate would
+// corrupt state without any error, so fail loud at load instead.
+export function assertUniqueIcaos(fc: GeoJsonFeatureCollection): void {
+  const seen = new Set<string>();
+  for (const f of fc.features) {
+    if (seen.has(f.properties.icao)) throw new Error(`duplicate ICAO in airport dataset: ${f.properties.icao}`);
+    seen.add(f.properties.icao);
+  }
+}
+
 let cached: GeoJsonFeatureCollection | null = null;
 
 export async function loadAirportsGeoJson(): Promise<GeoJsonFeatureCollection> {
   if (cached) return cached;
-  const file = path.join(process.cwd(), 'data', 'airports_eu.csv');
+  const file = path.join(process.cwd(), 'data', 'airports_world.csv');
   const text = await fs.readFile(file, 'utf8');
-  cached = toGeoJson(filterEuAirports(parseCsv(text)));
+  const fc = toGeoJson(filterWorldAirports(parseCsv(text)));
+  assertUniqueIcaos(fc);
+  cached = fc;
   return cached;
 }
 

lib/auth.ts

@@ -0,0 +1,74 @@
+import { randomUUID, scryptSync, timingSafeEqual } from 'node:crypto';
+import { getGameDb, persist, type GameDb } from '@/lib/db/client';
+
+// v0.71.0 — session auth for the admin panel (and later multiplayer). Sessions are opaque
+// UUIDs in a DB table; the client stores one in localStorage ('flight.session') and sends it
+// as the X-Flight-Session header on every authenticated request. No JWT, no cookies: this is
+// a single-origin dev tool surface, not a public auth system.
+
+export const SESSION_HEADER = 'x-flight-session';
+export const SESSION_TTL_MS = 7 * 24 * 60 * 60 * 1000; // 7 days from creation
+
+// Fixed digest compared against when the username is unknown, so every failed login runs one
+// full scrypt and the timing shape stays uniform (no user-existence oracle).
+export const DUMMY_HASH_FOR_UNKNOWN_USER = '0123456789abcdef0123456789abcdef$b9813a9a95c67878bd5b2c703bce6d57416b5d7e48496dfbf603bc4c6d59137f';
+
+export interface AuthUser {
+  id: string;
+  username: string;
+  admin: boolean;
+}
+
+// Verify a plaintext password against a stored "salt$hex" scrypt digest (16-byte hex salt,
+// 32-byte hash). Malformed digests never match.
+export function verifyPassword(password: string, storedHash: string): boolean {
+  const [saltHex, hashHex] = storedHash.split('$');
+  if (!saltHex || !hashHex || hashHex.length !== 64) return false;
+  const computed = scryptSync(password, saltHex, 32).toString('hex');
+  try {
+    return timingSafeEqual(Buffer.from(computed, 'hex'), Buffer.from(hashHex, 'hex'));
+  } catch {
+    return false;
+  }
+}
+
+// Mint a session row for the user and lazily prune expired sessions. Persists so a restart
+// doesn't silently log everyone out mid-session.
+export async function createSession(inst: GameDb, userId: string): Promise<string> {
+  const id = randomUUID();
+  inst.raw.run('DELETE FROM sessions WHERE expires_at < ?', [Date.now()]);
+  inst.raw.run('INSERT INTO sessions (id, user_id, expires_at) VALUES (?, ?, ?)', [
+    id,
+    userId,
+    Date.now() + SESSION_TTL_MS,
+  ]);
+  await persist(inst);
+  return id;
+}
+
+// Resolve the X-Flight-Session header to a live (non-expired) user, or null.
+export async function currentUser(req: Request): Promise<AuthUser | null> {
+  const sessionId = req.headers.get(SESSION_HEADER);
+  if (!sessionId) return null;
+  const inst = await getGameDb();
+  const res = inst.raw.exec(
+    'SELECT u.id, u.username, u.admin FROM sessions s JOIN users u ON u.id = s.user_id WHERE s.id = ? AND s.expires_at > ?',
+    [sessionId, Date.now()],
+  );
+  const row = res[0]?.values?.[0];
+  if (!row) return null;
+  return { id: String(row[0]), username: String(row[1]), admin: Number(row[2]) === 1 };
+}
+
+export type AdminGuard = { ok: true; inst: GameDb; user: AuthUser } | { ok: false; response: Response };
+
+// Guard for every /api/admin/* route — runs BEFORE any user input is touched.
+// No/expired session → 401, valid non-admin session → 403.
+export async function requireAdmin(req: Request): Promise<AdminGuard> {
+  const user = await currentUser(req);
+  if (!user) return { ok: false, response: Response.json({ error: 'authentication required' }, { status: 401 }) };
+  if (!user.admin) {
+    return { ok: false, response: Response.json({ error: 'admin access required' }, { status: 403 }) };
+  }
+  return { ok: true, inst: await getGameDb(), user };
+}

lib/db/client.test.ts

@@ -3,6 +3,8 @@ import os from 'node:os';
 import path from 'node:path';
 import initSqlJs from 'sql.js';
 import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+import { WORLD_TIME_SCALE } from '@/lib/worldClock';
+import { STARTING_CLOCK_MS } from '@/lib/game/seed';
 import { openGameDb, persist } from './client';
 import * as schema from './schema';
 
@@ -111,8 +113,9 @@ describe('openGameDb', () => {
     const account = (await inst.db.select().from(schema.account))[0];
     expect(account?.cash).toBeGreaterThan(0);
     const sim = (await inst.db.select().from(schema.simState))[0];
-    expect(sim?.paused).toBe(false);
+    // ISS-117: fresh worlds start at the year-2000 game clock with the fixed world rate.
-    expect(sim?.timeScale).toBe(1);
+    expect(sim?.clockMs).toBe(STARTING_CLOCK_MS);
+    expect(sim?.timeScale).toBe(WORLD_TIME_SCALE);
 
     // The seed was durably written: the file exists and is non-empty.
     const st = await fs.stat(file);
@@ -219,6 +222,77 @@ describe('openGameDb', () => {
     expect(cols.has('dest_icao')).toBe(true);
   });
 
+  // v0.71.0: the seeded admin row — hash-only, idempotent across every open().
+  const ADMIN_HASH = '339149a14282ff3a2ed94534f9722aa4$abaf94cf073c5aafc892b4a39dce97aaf53ab6f7c662a588815bda1bc1771caf';
+  // The v0.71.0 digest — computed with different scrypt parameters than verifyPassword(),
+  // so it never verified; production DBs seeded by that version carry exactly this value.
+  const LEGACY_HASH = '8dbed630b49a15073e8be571367c1858$0e5207dae2e3c813a7172a5f610fd47a90e8ff17513180ab1e0a7779c3766ef0';
+
+  it('seeds exactly one admin user on first open and never duplicates on reopen', async () => {
+    const file = path.join(dir, 'admin-seed.db');
+    const inst = await openGameDb(file);
+
+    let rows = inst.raw.exec("SELECT id, username, password_hash, admin FROM users WHERE username = 'kamilkrzywda'");
+    expect(rows[0].values).toHaveLength(1);
+    expect(rows[0].values[0]).toEqual(['admin-kamilkrzywda', 'kamilkrzywda', ADMIN_HASH, 1]);
+
+    // Simulate a process restart: brand-new instance over the same file.
+    const second = await openGameDb(file);
+    rows = second.raw.exec('SELECT COUNT(*) FROM users');
+    expect(Number(rows[0].values[0][0])).toBe(1);
+  });
+
+  it('seeds the admin into a legacy DB that predates the users table', async () => {
+    // A pre-v0.71.0 file: no users/sessions tables at all (the v0.6.0 DDL has none).
+    const SQL = await initSqlJs();
+    const raw = new SQL.Database();
+    raw.exec(LEGACY_DDL);
+    raw.exec(`INSERT INTO planes VALUES ('plane-starter', 'atr72', 'available', 6300, 6300, 'EDDF', NULL, 50.03, 8.57)`);
+    raw.exec(`INSERT INTO account VALUES (20000, 10)`);
+    raw.exec('INSERT INTO sim_state VALUES (1750000000000, 50, 0)');
+    const file = path.join(dir, 'legacy-admin.db');
+    await fs.writeFile(file, Buffer.from(raw.export()));
+
+    const inst = await openGameDb(file);
+    const rows = inst.raw.exec("SELECT id, username, admin FROM users WHERE username = 'kamilkrzywda'");
+    expect(rows[0].values).toHaveLength(1);
+    expect(rows[0].values[0]).toEqual(['admin-kamilkrzywda', 'kamilkrzywda', 1]);
+    // The game world is untouched by the seed.
+    expect((await inst.db.select().from(schema.account))[0]?.cash).toBe(20000);
+  });
+
+  it('rotates a v0.71.0 legacy admin digest on open (idempotent)', async () => {
+    // A file exactly as v0.71.0 left production: an admin row carrying the old, incompatible digest.
+    const SQL = await initSqlJs();
+    const raw = new SQL.Database();
+    raw.exec(`CREATE TABLE users (
+      id TEXT PRIMARY KEY NOT NULL,
+      username TEXT NOT NULL UNIQUE,
+      password_hash TEXT NOT NULL,
+      admin INTEGER NOT NULL DEFAULT 0,
+      created_at INTEGER NOT NULL
+    )`);
+    raw.run('INSERT INTO users VALUES (?, ?, ?, 1, ?)', [
+      'admin-kamilkrzywda',
+      'kamilkrzywda',
+      LEGACY_HASH,
+      Date.now(),
+    ]);
+    const file = path.join(dir, 'admin-rotate.db');
+    await fs.writeFile(file, Buffer.from(raw.export()));
+
+    // First open heals the row to the current digest…
+    const first = await openGameDb(file);
+    let rows = first.raw.exec("SELECT password_hash FROM users WHERE id = 'admin-kamilkrzywda'");
+    expect(rows[0].values).toHaveLength(1);
+    expect(rows[0].values[0][0]).toBe(ADMIN_HASH);
+
+    // …and a second open is a no-op (idempotent rotation).
+    const second = await openGameDb(file);
+    rows = second.raw.exec("SELECT password_hash FROM users WHERE id = 'admin-kamilkrzywda'");
+    expect(rows[0].values[0][0]).toBe(ADMIN_HASH);
+  });
+
   it('does not re-run the v0.12 plane reset on later opens (migration is one-shot)', async () => {
     const file = path.join(dir, 'pre-v12-reopen.db');
     const SQL = await initSqlJs();

lib/db/client.ts

@@ -47,7 +47,9 @@ CREATE TABLE IF NOT EXISTS packages (
   deadline_sim_time INTEGER NOT NULL,
   status TEXT NOT NULL,
   plane_id TEXT,
-  created_sim_time INTEGER NOT NULL
+  created_sim_time INTEGER NOT NULL,
+  created_real_ms INTEGER NOT NULL DEFAULT 0,
+  slot_free_at_real_ms INTEGER
 );
 CREATE TABLE IF NOT EXISTS account (
   cash REAL NOT NULL,
@@ -60,8 +62,46 @@ CREATE TABLE IF NOT EXISTS sim_state (
   last_real_tick_ms INTEGER NOT NULL DEFAULT 0,
   last_selected_time_scale REAL NOT NULL DEFAULT 1
 );
+-- v0.71.0: accounts + login sessions for the admin panel (and later multiplayer auth).
+CREATE TABLE IF NOT EXISTS users (
+  id TEXT PRIMARY KEY NOT NULL,
+  username TEXT NOT NULL UNIQUE,
+  password_hash TEXT NOT NULL,
+  admin INTEGER NOT NULL DEFAULT 0,
+  created_at INTEGER NOT NULL
+);
+CREATE TABLE IF NOT EXISTS sessions (
+  id TEXT PRIMARY KEY NOT NULL,
+  user_id TEXT NOT NULL,
+  expires_at INTEGER NOT NULL
+);
 `;
 
+// v0.71.0: the seeded admin's scrypt hash (salt$hex). The plaintext exists only in the
+// operator's head — never in code, tests or comments; login verifies against this string.
+// v0.72.0: recomputed with exactly the same call as verifyPassword() — salt passed as a
+// plain string, scryptSync(pw, saltHex, 32) — because the v0.71.0 digest used different
+// parameters and real logins failed with 401.
+const ADMIN_SEED_HASH = '339149a14282ff3a2ed94534f9722aa4$abaf94cf073c5aafc892b4a39dce97aaf53ab6f7c662a588815bda1bc1771caf';
+
+// v0.71.0: idempotent admin seed — runs on every open(), no-ops when the row exists, so
+// pre-existing production DBs gain exactly one admin row and never a duplicate.
+function seedAdminUser(raw: RawSqlJsDatabase): void {
+  raw.run(
+    `INSERT INTO users (id, username, password_hash, admin, created_at)
+     SELECT 'admin-kamilkrzywda', 'kamilkrzywda', ?, 1, ?
+     WHERE NOT EXISTS (SELECT 1 FROM users WHERE username = 'kamilkrzywda')`,
+    [ADMIN_SEED_HASH, Date.now()],
+  );
+  // v0.72.0: v0.71.0 seeded an incompatible digest into production DBs and the INSERT above
+  // can't overwrite them (WHERE NOT EXISTS), so rotate any legacy row to the current digest
+  // at boot — a no-op once healed, durable on the next persist().
+  raw.run(
+    `UPDATE users SET password_hash = ? WHERE id = 'admin-kamilkrzywda' AND password_hash != ?`,
+    [ADMIN_SEED_HASH, ADMIN_SEED_HASH],
+  );
+}
+
 // v0.7.0: DBs created by earlier versions lack the new columns; CREATE TABLE IF
 // NOT EXISTS won't add them, so ALTER (guarded by PRAGMA table_info). Fresh DBs
 // already have everything from DDL above and this is a no-op for them.
@@ -98,6 +138,15 @@ function migrateColumns(raw: RawSqlJsDatabase): void {
   if (!cols('planes').has('repair_until_sim_time')) {
     raw.exec('ALTER TABLE planes ADD COLUMN repair_until_sim_time INTEGER');
   }
+  // v0.65.0: real-time creation stamp — legacy rows backfill to NOW so they get a fresh full lifetime
+  // instead of expiring on the first tick (created_real_ms = 0 is far in the past).
+  if (!cols('packages').has('created_real_ms')) {
+    raw.exec(`ALTER TABLE packages ADD COLUMN created_real_ms INTEGER NOT NULL DEFAULT ${Date.now()}`);
+  }
+  // v0.65.0: per-(origin, band) refill cooldown — nullable; legacy rows stay NULL = no cooldown.
+  if (!cols('packages').has('slot_free_at_real_ms')) {
+    raw.exec('ALTER TABLE packages ADD COLUMN slot_free_at_real_ms INTEGER');
+  }
   // v0.30.0 (ISS-057): last-selected speed — pre-existing rows backfill to the row's OWN
   // current time_scale so a legacy DB resumes at the speed it was running, not the default.
   if (!cols('sim_state').has('last_selected_time_scale')) {
@@ -150,6 +199,7 @@ async function open(file: string): Promise<GameDb> {
   const raw = bytes ? new SQL.Database(new Uint8Array(bytes)) : new SQL.Database();
   raw.exec(DDL); // no-op for tables that already exist in an older file
   migrateColumns(raw);
+  seedAdminUser(raw); // v0.71.0 — idempotent; safe on pre-existing production DBs
 
   // v0.12.0: run BEFORE the seed check — a pre-v0.12.0 file has account rows, so
   // without this it would keep the dead contracts table forever.
@@ -165,6 +215,7 @@ async function open(file: string): Promise<GameDb> {
   // First-run seed: only when the DB is empty (no account row yet).
   const res = raw.exec('SELECT COUNT(*) FROM account');
   if (Number(res[0]?.values?.[0]?.[0] ?? 0) === 0) {
+    console.warn(`flight db: no existing world at ${file} — seeding a fresh one`);
     await seedEmpty(instance);
   }
 
@@ -210,12 +261,14 @@ export async function persist(instance: GameDb): Promise<void> {
   await fs.rename(tmp, instance.file);
 }
 
-// Singleton for the app process; openGameDb() is the uncached variant (tests).
+// Singleton for the app process; openGameDb() is the uncached variant (tests). ISS-129 (v0.57.0):
-let ready: Promise<GameDb> | null = null;
+// lives on globalThis because Next.js can load this module more than once per process —
+// instrumentation.ts and route handlers get separate module instances, so a plain `let` would give
+// each its own in-memory sql.js DB (both persisting to the same file). One world per process.
+const g = globalThis as unknown as { __flightGameDb?: Promise<GameDb> };
 
 export function getGameDb(): Promise<GameDb> {
-  if (!ready) ready = open(defaultDbPath());
+  return (g.__flightGameDb ??= open(defaultDbPath()));
-  return ready;
 }
 
 export async function openGameDb(file: string): Promise<GameDb> {

lib/db/schema.ts

@@ -27,7 +27,7 @@ export const planes = sqliteTable('planes', {
   // departureSimTime; on landing the engine auto-chains queue[0] if fuel covers it.
   queue: text('queue').notNull().default('[]'),
   // Structural health in [0, 100] (v0.39.0, ISS-069) — wears down by WEAR_PER_KM per km of
-  // landed legs; at 0 the plane is broken and burns BROKEN_BURN_MULTIPLIER × more fuel.
+  // landed legs; at 0 the plane is broken and cannot fly until repaired (v0.45.0, ISS-089).
   health: real('health').notNull().default(100),
   // Sim-clock epoch ms when an active repair finishes (v0.39.0, ISS-069) — set with status
   // 'repairing', cleared by the engine's flip-back pass; NULL = not in repair.
@@ -53,10 +53,17 @@ export const packages = sqliteTable('packages', {
   deadlineSimTime: integer('deadline_sim_time').notNull(),
   // 'expired' = an open OR loaded package whose deadline passed on a tick. Loaded
   // expired packages keep occupying their slot, deliver no reward, and abandon free.
-  // 'ignored' (v0.29.0, ISS-047 part B) = a dismissed open job — terminal, leaves the market.
+  status: text('status', { enum: ['open', 'loaded', 'delivered', 'expired', 'abandoned'] }).notNull(),
-  status: text('status', { enum: ['open', 'loaded', 'delivered', 'expired', 'abandoned', 'ignored'] }).notNull(),
   planeId: text('plane_id'),
   createdSimTime: integer('created_sim_time').notNull(),
+  // Real-time (Date.now()) epoch ms of creation (v0.65.0) — open jobs live on the WALL clock, not the sim
+  // clock: they expire JOB_LIFETIME_MS after this regardless of time scale or fleet state. Legacy rows
+  // backfill to seed time so they get a fresh full lifetime instead of expiring on the first tick.
+  createdRealMs: integer('created_real_ms').notNull().default(0),
+  // Real-time epoch ms when this (origin, band) slot was last taken — loaded (v0.65.0). The pool
+  // spawner holds that slot for the band's refill delay after; NULL = never taken / no cooldown. Expired open
+  // jobs set nothing: an untaken job's slot respawns immediately.
+  slotFreeAtRealMs: integer('slot_free_at_real_ms'),
 });
 
 export const account = sqliteTable('account', {
@@ -77,7 +84,27 @@ export const simState = sqliteTable('sim_state', {
   lastSelectedTimeScale: real('last_selected_time_scale').notNull().default(1),
 });
 
+// v0.71.0: accounts + login sessions for the admin panel (and later multiplayer auth).
+// The seeded admin row is inserted by lib/db/client.ts on every open() — hash-only, see there.
+export const users = sqliteTable('users', {
+  id: text('id').primaryKey().notNull(),
+  username: text('username').notNull().unique(),
+  // scrypt digest as "salt$hex" (16-byte hex salt, 32-byte hex hash) — verified with node:crypto.
+  passwordHash: text('password_hash').notNull(),
+  admin: integer('admin', { mode: 'boolean' }).notNull().default(false),
+  createdAt: integer('created_at').notNull(),
+});
+
+export const sessions = sqliteTable('sessions', {
+  id: text('id').primaryKey().notNull(),
+  userId: text('user_id').notNull(),
+  // Real-time (Date.now()) epoch ms — 7 days from creation; expired rows are pruned lazily on login.
+  expiresAt: integer('expires_at').notNull(),
+});
+
 export type PlaneRow = typeof planes.$inferSelect;
 export type PackageRow = typeof packages.$inferSelect;
 export type AccountRow = typeof account.$inferSelect;
 export type SimStateRow = typeof simState.$inferSelect;
+export type UserRow = typeof users.$inferSelect;
+export type SessionRow = typeof sessions.$inferSelect;

lib/deriveEvents.test.ts

@@ -38,6 +38,8 @@ const basePackage = (id: string): PackageState => ({
   cargoCount: 2,
     weightKg: 600,
     special: null, // v0.37.0 (ISS-073) — no special status by default in fixtures
+    expiresRealMs: null, // v0.65.0 — wall-clock expiry; not exercised here
+    distanceKm: 1839, // v0.48.0 (ISS-095) — EDDF→LEMD great-circle distance
     deadlineSimTime: 0,
   status: 'open',
   planeId: null,
@@ -46,7 +48,7 @@ const basePackage = (id: string): PackageState => ({
 
 const snapshot = (over: Partial<StateSnapshot> = {}): StateSnapshot => ({
   account: { cash: 20_000, reputation: 10 },
-  simState: { clockMs: 0, timeScale: 1, paused: false },
+  simState: { clockMs: 0 },
   planes: [basePlane('plane-starter')],
   packages: [],
   catalog: CATALOG,
@@ -58,7 +60,7 @@ const snapshot = (over: Partial<StateSnapshot> = {}): StateSnapshot => ({
 describe('diffSnapshots', () => {
   it('returns [] for identical snapshots (only clock/cash drift)', () => {
     const prev = snapshot();
-    const next = snapshot({ account: { cash: 21_000, reputation: 11 }, simState: { clockMs: 60_000, timeScale: 1, paused: false } });
+    const next = snapshot({ account: { cash: 21_000, reputation: 11 }, simState: { clockMs: 60_000 } });
     expect(diffSnapshots(prev, next)).toEqual([]);
   });
 

lib/format.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest';
-import { formatCargo, formatCash, formatDeadlineRelative, formatDuration, formatFuel, formatSimClock } from './format';
+import { formatCargo, formatCash, formatDeadlineRelative, formatDuration, formatFuel, formatKm, formatSimClock } from './format';
 
 describe('formatCash', () => {
   it('formats EUR with thousands separators and two decimals', () => {
@@ -30,6 +30,14 @@ describe('formatCargo', () => {
   });
 });
 
+describe('formatKm', () => {
+  it('rounds to integer km with no space before "km" (v0.48.0, ISS-095)', () => {
+    expect(formatKm(554)).toBe('554km');
+    expect(formatKm(214.6)).toBe('215km');
+    expect(formatKm(0)).toBe('0km');
+  });
+});
+
 describe('formatSimClock', () => {
   it('formats epoch ms as a UTC wall-clock string with seconds (deterministic across timezones)', () => {
     expect(formatSimClock(Date.UTC(2026, 8, 17, 14, 5))).toBe('2026-09-17 14:05:00 UTC');

lib/format.ts

@@ -16,6 +16,11 @@ export function formatCargo(cargoType: string, weightKg: number): string {
   return `${cargoType} ${(weightKg / 1000).toFixed(1)}t`;
 }
 
+// Leg distance for contract rows (v0.48.0, ISS-095): "554km" — integer km, no space before "km".
+export function formatKm(km: number): string {
+  return `${Math.round(km)}km`;
+}
+
 // Special-status badge label (v0.37.0, ISS-073): "priority" → "Priority".
 export function formatSpecialLabel(special: string): string {
   return special.charAt(0).toUpperCase() + special.slice(1);

lib/game/actions.test.ts

@@ -10,7 +10,6 @@ import { haversineKm, initialBearingDeg } from '@/lib/geo';
 import { weatherFor } from '@/lib/weather';
 import { requiredFuelFor, windBurnFactor } from '@/lib/sim/movement';
 import {
-  BROKEN_BURN_MULTIPLIER,
   FUEL_DISCOUNT_PER_REP,
   FUEL_PRICE_PER_L,
   MAX_FUEL_DISCOUNT,
@@ -22,14 +21,13 @@ import {
   repRate,
   SELL_FRACTION,
 } from './catalog';
-import { HUB_ICAO } from './seed';
+import { HUB_ICAO, STARTING_CLOCK_MS } from './seed';
 import {
   abandonPackage,
   buyPlane,
   cancelQueuedLeg,
   flyPlane,
   GameActionError,
-  ignorePackage,
   loadPackage,
   queueLeg,
   repairPlane,
@@ -174,7 +172,7 @@ describe('flyPlane', () => {
     const plane = (await inst.db.select().from(schema.planes))[0];
     expect(plane.status).toBe('flying');
     expect(plane.destIcao).toBe('LEMD');
-    expect(plane.departureSimTime).toBe(T0); // seeded clock, no tick in direct calls
+    expect(plane.departureSimTime).toBe(STARTING_CLOCK_MS); // seeded game clock (ISS-117), no tick in direct calls
     const fc = await loadAirportsGeoJson();
     const origin = fc.features.find((f) => f.properties.icao === HUB_ICAO)!.properties;
     expect(plane.lat).toBe(origin.lat);
@@ -183,34 +181,6 @@ describe('flyPlane', () => {
     expect(plane.fuel).toBe(PLANE_TYPES.atr72.maxFuel);
   });
 
-  it('resumes a manual pause and restores lastSelectedTimeScale when the last grounded plane takes off (ISS-057)', async () => {
-    const inst = await freshDb('fly-resume.db');
-    // A landing slowed the sim to 1×; the player's last manually selected speed was 250.
-    await inst.db.update(schema.simState).set({ paused: true, timeScale: 1, lastSelectedTimeScale: 250 });
-
-    await flyPlane(inst, 'plane-starter', 'LEMD'); // sole grounded plane → airborne
-
-    const sim = (await inst.db.select().from(schema.simState))[0];
-    expect(sim.paused).toBe(false); // dispatch still resumes a manual pause…
-    expect(sim.timeScale).toBe(250); // …and restores the last selected speed
-  });
-
-  it('keeps 1× when another plane is still grounded after dispatch (ISS-057)', async () => {
-    const inst = await freshDb('fly-stayslow.db');
-    await inst.db.update(schema.simState).set({ timeScale: 1, lastSelectedTimeScale: 250 });
-    // A second grounded plane — the starter taking off leaves it on the ground.
-    await inst.db.insert(schema.planes).values({
-      id: 'plane-extra', model: 'atr72', status: 'available', fuel: 100, maxFuel: PLANE_TYPES.atr72.maxFuel,
-      locationIcao: HUB_ICAO, destIcao: null, lat: 50, lon: 8, departureSimTime: null,
-    });
-
-    await flyPlane(inst, 'plane-starter', 'LEMD');
-
-    const sim = (await inst.db.select().from(schema.simState))[0];
-    expect(sim.paused).toBe(false);
-    expect(sim.timeScale).toBe(1); // another plane on ground → stays slowed
-  });
-
   it('rejects a flying plane with 409', async () => {
     const inst = await freshDb('fly-flying.db');
     await inst.db.update(schema.planes)
@@ -230,36 +200,28 @@ describe('flyPlane', () => {
     await expectActionError(flyPlane(inst, 'plane-starter', 'ZZZZ'), 400, /unknown airport/);
   });
 
-  it('uses the ×1.5 broken burn for the dispatch auto-top-up when health is 0 (v0.39.0, ISS-069)', async () => {
+  it('rejects a broken plane (health 0) with 409 and mutates nothing (v0.45.0, ISS-089)', async () => {
     const inst = await freshDb('fly-broken.db'); // EDDF → LEMD
-    const fc = await loadAirportsGeoJson();
+    const fuelBefore = PLANE_TYPES.atr72.maxFuel; // seeded full tank
-    const from = fc.features.find((f) => f.properties.icao === HUB_ICAO)!.properties;
+    await inst.db.update(schema.planes).set({ health: 0 }).where(eq(schema.planes.id, 'plane-starter'));
-    const to = fc.features.find((f) => f.properties.icao === 'LEMD')!.properties;
+    const cashBefore = (await inst.db.select().from(schema.account))[0].cash;
-    const km = haversineKm(from.lat, from.lon, to.lat, to.lon);
-    const type = PLANE_TYPES.atr72;
-    const w = weatherFor(HUB_ICAO);
-    const f = windBurnFactor(w.windKt, w.windDirDeg, initialBearingDeg(from.lat, from.lon, to.lat, to.lon));
-    // The tank holds EXACTLY the healthy requirement — a broken plane's 150% top-up target is higher.
-    const healthyRequired = requiredFuelFor(type.burnPerKm * f, type.emptyWeightKg, type.maxFuel, km);
-    await inst.db.update(schema.planes)
-      .set({ health: 0, fuel: healthyRequired })
-      .where(eq(schema.planes.id, 'plane-starter'));
 
-    await flyPlane(inst, 'plane-starter', 'LEMD'); // auto-refuel covers the extra burn — no 409
+    await expectActionError(flyPlane(inst, 'plane-starter', 'LEMD'), 409, /broken \(health 0\)/);
+
+    const plane = (await inst.db.select().from(schema.planes))[0];
+    expect(plane.status).toBe('available'); // still grounded…
+    expect(plane.fuel).toBe(fuelBefore); // …no auto-refuel ran — the tank is untouched…
+    expect((await inst.db.select().from(schema.account))[0].cash).toBe(cashBefore); // …and no cash left the account
+  });
+
+  it('still flies a worn-but-not-broken plane (health > 0) with plain burn', async () => {
+    const inst = await freshDb('fly-worn.db'); // EDDF → LEMD
+    await inst.db.update(schema.planes).set({ health: 1 }).where(eq(schema.planes.id, 'plane-starter'));
+
+    await flyPlane(inst, 'plane-starter', 'LEMD'); // no 409 — worn is not broken
 
-    const brokenRequired = requiredFuelFor(type.burnPerKm * f * BROKEN_BURN_MULTIPLIER, type.emptyWeightKg, type.maxFuel, km);
-    expect(brokenRequired).toBeGreaterThan(healthyRequired); // sanity: the multiplier genuinely raises the requirement
     const plane = (await inst.db.select().from(schema.planes))[0];
     expect(plane.status).toBe('flying');
-    expect(plane.fuel).toBeCloseTo(Math.min(type.maxFuel, Math.max(healthyRequired, brokenRequired * 1.5)), 6); // topped up for the BROKEN burn…
-
-    // …while the same tank at full health tops up to the LOWER healthy target — the multiplier is what raised it.
-    const inst2 = await freshDb('fly-broken-healthy.db');
-    await inst2.db.update(schema.planes).set({ fuel: healthyRequired }).where(eq(schema.planes.id, 'plane-starter'));
-    await flyPlane(inst2, 'plane-starter', 'LEMD'); // must not throw
-    const plane2 = (await inst2.db.select().from(schema.planes))[0];
-    expect(plane2.fuel).toBeCloseTo(Math.min(type.maxFuel, Math.max(healthyRequired, healthyRequired * 1.5)), 6);
-    expect(plane.fuel).toBeGreaterThan(plane2.fuel); // the broken plane genuinely got more fuel
   });
 
   // --- Auto-refuel on dispatch (ISS-082, v0.42.0) ---
@@ -340,6 +302,34 @@ describe('flyPlane', () => {
 
     await expectActionError(flyPlane(inst, 'plane-starter', 'LPPD'), 409, /insufficient fuel/i);
   });
+
+  // --- Queue consumption on dispatch (v0.46.0, ISS-088) ---
+
+  it('consumes queue[0] when flying to the first queued leg — no phantom self-hop on landing', async () => {
+    const inst = await freshDb('fly-consume.db');
+    await queueLeg(inst, 'plane-starter', 'LEMD');
+    await queueLeg(inst, 'plane-starter', 'EHAM');
+
+    await flyPlane(inst, 'plane-starter', 'LEMD'); // the first queued leg
+
+    const plane = (await inst.db.select().from(schema.planes))[0];
+    expect(plane.status).toBe('flying');
+    expect(plane.destIcao).toBe('LEMD');
+    expect(JSON.parse(plane.queue)).toEqual(['EHAM']); // queue[0] consumed, the rest kept in order
+  });
+
+  it('keeps the queue intact when skipping ahead to a non-first queued leg (explicit override)', async () => {
+    const inst = await freshDb('fly-skipahead.db');
+    await queueLeg(inst, 'plane-starter', 'LEMD');
+    await queueLeg(inst, 'plane-starter', 'EHAM');
+
+    await flyPlane(inst, 'plane-starter', 'EHAM'); // not the first queued leg — an override
+
+    const plane = (await inst.db.select().from(schema.planes))[0];
+    expect(plane.status).toBe('flying');
+    expect(plane.destIcao).toBe('EHAM');
+    expect(JSON.parse(plane.queue)).toEqual(['LEMD', 'EHAM']); // untouched — FIFO order preserved
+  });
 });
 
 describe('queueLeg (v0.25.0, ISS-043)', () => {
@@ -443,14 +433,14 @@ describe('cancelQueuedLeg (v0.25.0, ISS-043)', () => {
 });
 
 describe('abandonPackage', () => {
-  // A loaded package created at T0 with a 10h window; the seeded sim clock is T0.
+  // A loaded package created at the seeded game clock with a 10h window (ISS-117).
   const REWARD = 1_000;
   const WINDOW_MS = 10 * 3_600_000;
 
   async function setupLoaded(name: string, status: 'loaded' | 'expired' = 'loaded') {
     const inst = await freshDb(name);
     // Always insert OPEN and load it through the real action…
-    await insertOpenPackage(inst, 'p-ab', { reward: REWARD, createdSimTime: T0, deadlineSimTime: T0 + WINDOW_MS });
+    await insertOpenPackage(inst, 'p-ab', { reward: REWARD, createdSimTime: STARTING_CLOCK_MS, deadlineSimTime: STARTING_CLOCK_MS + WINDOW_MS });
     await loadPackage(inst, 'p-ab', 'plane-starter');
     // …then flip to expired in place (what the tick would do once the deadline passes).
     if (status === 'expired') {
@@ -475,7 +465,7 @@ describe('abandonPackage', () => {
 
   it('scales to exactly 37.5% at the midpoint of the window', async () => {
     const inst = await setupLoaded('ab-mid.db');
-    await inst.db.update(schema.simState).set({ clockMs: T0 + WINDOW_MS / 2 }); // runAction ticks first in prod
+    await inst.db.update(schema.simState).set({ clockMs: STARTING_CLOCK_MS + WINDOW_MS / 2 }); // runAction ticks first in prod
 
     const { penalty } = await abandonPackage(inst, 'p-ab');
 
@@ -484,8 +474,8 @@ describe('abandonPackage', () => {
 
   it('caps at exactly 60% at and past the deadline', async () => {
     for (const [name, clock] of [
-      ['ab-deadline.db', T0 + WINDOW_MS],
+      ['ab-deadline.db', STARTING_CLOCK_MS + WINDOW_MS],
-      ['ab-pastdeadline.db', T0 + WINDOW_MS * 2], // clamped — a not-yet-ticked loaded package past its deadline
+      ['ab-pastdeadline.db', STARTING_CLOCK_MS + WINDOW_MS * 2], // clamped — a not-yet-ticked loaded package past its deadline
     ] as const) {
       const inst = await setupLoaded(name);
       await inst.db.update(schema.simState).set({ clockMs: clock });
@@ -539,36 +529,6 @@ describe('abandonPackage', () => {
   });
 });
 
-describe('ignorePackage', () => {
-  it('flips an open package to ignored — no penalty, nothing else changes', async () => {
-    const inst = await freshDb('ig-open.db');
-    await insertOpenPackage(inst, 'p-ig');
-    const cashBefore = (await inst.db.select().from(schema.account))[0].cash;
-
-    await ignorePackage(inst, 'p-ig');
-
-    const row = (await inst.db.select().from(schema.packages).where(eq(schema.packages.id, 'p-ig')))[0];
-    expect(row.status).toBe('ignored');
-    expect(row.planeId).toBeNull(); // was never bound
-    expect((await inst.db.select().from(schema.account))[0].cash).toBe(cashBefore); // no penalty
-  });
-
-  it.each(['loaded', 'delivered', 'expired', 'abandoned', 'ignored'] as const)(
-    'rejects a %s package with 409 (must be open)',
-    async (status) => {
-      const inst = await freshDb(`ig-${status}.db`);
-      await insertOpenPackage(inst, 'p-x', { status });
-
-      await expectActionError(ignorePackage(inst, 'p-x'), 409, new RegExp(status));
-    },
-  );
-
-  it('rejects an unknown id with 404', async () => {
-    const inst = await freshDb('ig-unknown.db');
-    await expectActionError(ignorePackage(inst, 'nope'), 404);
-  });
-});
-
 describe('buyPlane', () => {
   it('deducts the full price and delivers a full-tank plane at the home base', async () => {
     const inst = await freshDb('buy-ok.db');
@@ -680,6 +640,19 @@ describe('sellPlane', () => {
     expect(ids).toContain('plane-extra'); // row untouched — the cargo stays bound to a real plane
   });
 
+  it('rejects selling a grounded plane with queued legs with 409 (v0.46.0, ISS-088)', async () => {
+    const inst = await freshDb('sell-queue.db');
+    await inst.db.insert(schema.planes).values({
+      id: 'plane-extra', model: 'atr72', status: 'available', fuel: 100, maxFuel: PLANE_TYPES.atr72.maxFuel,
+      locationIcao: HUB_ICAO, destIcao: null, lat: 50, lon: 8, departureSimTime: null,
+    });
+    await queueLeg(inst, 'plane-extra', 'LEMD');
+
+    await expectActionError(sellPlane(inst, 'plane-extra'), 409, /cancel queued legs first/);
+    const plane = (await inst.db.select().from(schema.planes).where(eq(schema.planes.id, 'plane-extra')))[0];
+    expect(JSON.parse(plane.queue)).toEqual(['LEMD']); // row untouched — the queue stays with a real plane
+  });
+
   it('rejects selling the last remaining plane with 409', async () => {
     const inst = await freshDb('sell-last.db'); // only the starter exists
     await expectActionError(sellPlane(inst, 'plane-starter'), 409, /last remaining/);
@@ -691,8 +664,8 @@ describe('sellPlane', () => {
   });
 });
 
-describe('repairPlane (v0.39.0, ISS-069)', () => {
+describe('repairPlane (v0.39.0, ISS-069; gradual since v0.45.0, ISS-089)', () => {
-  it('charges exactly REPAIR_COST, restores health to 100 and grounds the plane for REPAIR_DURATION_MS', async () => {
+  it('charges exactly REPAIR_COST and grounds the plane for REPAIR_DURATION_MS without touching health yet', async () => {
     const inst = await freshDb('repair-ok.db');
     await inst.db.update(schema.planes).set({ health: 42 }).where(eq(schema.planes.id, 'plane-starter'));
     const cashBefore = (await inst.db.select().from(schema.account))[0].cash;
@@ -702,8 +675,8 @@ describe('repairPlane (v0.39.0, ISS-069)', () => {
     expect(cost).toBe(REPAIR_COST);
     const plane = (await inst.db.select().from(schema.planes))[0];
     expect(plane.status).toBe('repairing');
-    expect(plane.health).toBe(100); // restored to full…
+    expect(plane.health).toBe(42); // NOT restored yet — the engine's finishRepairs pass heals it gradually…
-    expect(plane.repairUntilSimTime).toBe(T0 + REPAIR_DURATION_MS); // …with the gate set from the seeded clock (no tick in direct calls)
+    expect(plane.repairUntilSimTime).toBe(STARTING_CLOCK_MS + REPAIR_DURATION_MS); // …with the gate set from the seeded game clock (ISS-117; no tick in direct calls)
     const account = (await inst.db.select().from(schema.account))[0];
     expect(account.cash).toBeCloseTo(cashBefore - REPAIR_COST, 6);
   });

lib/game/actions.ts

@@ -9,7 +9,6 @@ import { requiredFuelFor, windBurnFactor } from '@/lib/sim/movement';
 import { runAction } from '@/lib/sim/engine';
 import { getStateSnapshot, parseIcaoQueue } from './state';
 import {
-  conditionBurnMultiplier,
   FUEL_DISCOUNT_PER_REP,
   FUEL_PRICE_PER_L,
   MAX_FUEL_DISCOUNT,
@@ -91,8 +90,10 @@ export async function loadPackage(inst: GameDb, packageId: string, planeId: stri
     throw new GameActionError(409, `no payload room: the ${type.name} carries ${Math.round(usedKg)}/${type.maxPayloadKg} kg`);
   }
 
+  // v0.65.0: taking the job starts its slot's refill cooldown — the pool spawner holds this
+  // (origin, band) empty for the delay after now so the board visibly refreshes.
   await inst.db.update(schema.packages)
-    .set({ status: 'loaded', planeId })
+    .set({ status: 'loaded', planeId, slotFreeAtRealMs: Date.now() })
     .where(eq(schema.packages.id, packageId));
   await persist(inst);
 }
@@ -106,7 +107,8 @@ export async function loadPackage(inst: GameDb, packageId: string, planeId: stri
 // dispatch AUTO-refuels first — the tank is topped up to min(maxFuel, max(fuel, 1.5 × required))
 // at FUEL_PRICE_PER_L per liter minus the rep-scaled discount, deducted from cash; a leg that
 // doesn't fit even a full tank still 409s (insufficient fuel), and an unaffordable top-up 409s
-// with nothing mutated.
+// with nothing mutated. v0.45.0 (ISS-089): a broken plane (health ≤ 0) cannot fly at all — it
+// 409s before any refuel math, so fuel and cash stay untouched.
 export async function flyPlane(inst: GameDb, planeId: string, destIcao: string): Promise<void> {
   const planeRows = await inst.db.select().from(schema.planes).where(eq(schema.planes.id, planeId));
   const plane = planeRows[0];
@@ -114,6 +116,9 @@ export async function flyPlane(inst: GameDb, planeId: string, destIcao: string):
   if (plane.status !== 'available') {
     throw new GameActionError(409, `plane is ${plane.status}, only grounded planes can fly`);
   }
+  if (plane.health <= 0) {
+    throw new GameActionError(409, 'the plane is broken (health 0) — repair it first');
+  }
 
   const fc = await loadAirportsGeoJson();
   const destFeature = fc.features.find((f) => f.properties.icao === destIcao);
@@ -125,9 +130,8 @@ export async function flyPlane(inst: GameDb, planeId: string, destIcao: string):
   const distanceKm = haversineKm(origin.lat, origin.lon, destFeature.properties.lat, destFeature.properties.lon);
   // Weighted burn model (v0.16.0): the leg needs enough fuel to cover it arriving empty; wind-
   // adjusted (v0.36.0) by departure weather vs route heading — every call site uses this same factor.
-  // v0.39.0 (ISS-069): a broken plane (health ≤ 0) burns BROKEN_BURN_MULTIPLIER × more per km.
   const w = weatherFor(plane.locationIcao);
-  const burnPerKm = type.burnPerKm * windBurnFactor(w.windKt, w.windDirDeg, initialBearingDeg(origin.lat, origin.lon, destFeature.properties.lat, destFeature.properties.lon)) * conditionBurnMultiplier(plane.health);
+  const burnPerKm = type.burnPerKm * windBurnFactor(w.windKt, w.windDirDeg, initialBearingDeg(origin.lat, origin.lon, destFeature.properties.lat, destFeature.properties.lon));
   const requiredL = requiredFuelFor(burnPerKm, type.emptyWeightKg, type.maxFuel, distanceKm);
 
   // ISS-082 (v0.42.0): dispatch auto-refuels — top up to 150% of the requirement (capped at tank
@@ -151,6 +155,12 @@ export async function flyPlane(inst: GameDb, planeId: string, destIcao: string):
   const sim = (await inst.db.select().from(schema.simState))[0];
   if (!sim) throw new Error('sim_state row missing');
 
+  // v0.46.0 (ISS-088): flying to the FIRST queued leg consumes it — otherwise the engine would
+  // chain a zero-distance self-hop on landing (queue[0] === the airport just reached). Skip-ahead
+  // to a non-first queued dest is an explicit override: the queue stays intact, FIFO preserved.
+  const queue = parseIcaoQueue(plane.queue);
+  if (queue.length > 0 && queue[0] === destIcao) queue.shift();
+
   await inst.db.update(schema.planes)
     .set({
       status: 'flying',
@@ -159,19 +169,12 @@ export async function flyPlane(inst: GameDb, planeId: string, destIcao: string):
       lat: origin.lat,
       lon: origin.lon,
       fuel: target, // ISS-082: the post-top-up level (unchanged when no top-up was needed)
+      queue: JSON.stringify(queue),
     })
     .where(eq(schema.planes.id, planeId));
   if (cost > 0) {
     await inst.db.update(schema.account).set({ cash: Math.round((account.cash - cost) * 100) / 100 });
   }
-  // ISS-057: dispatch still resumes a MANUALLY paused sim (pause is manual-only now — landings
-  // slow to 1× instead of pausing), and restores the last manually selected speed when this
-  // dispatch took the LAST grounded plane airborne. Runs inside runAction(), so tick + controls
-  // + dispatch are atomic under the sim lock.
-  const sets: Partial<Pick<schema.SimStateRow, 'paused' | 'timeScale'>> = { paused: false };
-  const remaining = await inst.db.select().from(schema.planes).where(eq(schema.planes.status, 'available'));
-  if (remaining.length === 0) sets.timeScale = sim.lastSelectedTimeScale;
-  await inst.db.update(schema.simState).set(sets);
   await persist(inst);
 }
 
@@ -260,23 +263,6 @@ export async function abandonPackage(inst: GameDb, packageId: string): Promise<{
   return { penalty };
 }
 
-// --- Ignore (POST /api/packages/:id/ignore) — ISS-047 part B ---
-
-// Dismiss an OPEN job so it leaves the market permanently; no penalty, nothing else
-// changes. The top-up logic (spawnOpenPackages counts 'open') refills the market with
-// a new random package on the next tick. 404 unknown id; 409 unless open.
-export async function ignorePackage(inst: GameDb, packageId: string): Promise<void> {
-  const pkgRows = await inst.db.select().from(schema.packages).where(eq(schema.packages.id, packageId));
-  const pkg = pkgRows[0];
-  if (!pkg) throw new GameActionError(404, `package ${packageId} not found`);
-  if (pkg.status !== 'open') {
-    throw new GameActionError(409, `package is ${pkg.status}, only open packages can be ignored`);
-  }
-
-  await inst.db.update(schema.packages).set({ status: 'ignored' }).where(eq(schema.packages.id, packageId));
-  await persist(inst);
-}
-
 // --- Market (POST /api/market/buy-plane {model}) ---
 
 // Buy a catalog model at its reputation-scaled price (v0.38.0, ISS-072 — discount grows with
@@ -338,6 +324,11 @@ export async function sellPlane(inst: GameDb, planeId: string): Promise<{ payout
     throw new GameActionError(409, `cannot sell a plane carrying cargo`);
   }
 
+  // v0.46.0 (ISS-088): selling a plane with queued legs would silently drop them — force an explicit cancel first.
+  if (parseIcaoQueue(plane.queue).length > 0) {
+    throw new GameActionError(409, 'the plane has queued legs — cancel queued legs first');
+  }
+
   const all = await inst.db.select().from(schema.planes);
   if (all.length <= 1) throw new GameActionError(409, 'cannot sell the last remaining plane');
 
@@ -355,10 +346,12 @@ export async function sellPlane(inst: GameDb, planeId: string): Promise<{ payout
 
 // --- Repair (POST /api/planes/:planeId/repair) — v0.39.0 (ISS-069) ---
 
-// Restore a worn-out plane to full health for the flat REPAIR_COST; it is grounded in 'repairing'
+// Ground a worn-out plane in 'repairing' status for the flat REPAIR_COST (v0.39.0, ISS-069).
-// status until sim.clockMs + REPAIR_DURATION_MS, when the engine's tick flips it back to
+// Since v0.45.0 (ISS-089) the repair is GRADUAL: health stays where it is and climbs back to 100
-// 'available'. Only GROUNDED planes can be repaired (409 otherwise); an already-full-health
+// over REPAIR_DURATION_MS of sim time — the engine's finishRepairs pass applies the curve each tick
-// repair is a free no-op. 404 unknown plane; 409 not grounded / insufficient funds.
+// and flips the plane to 'available' exactly when it reaches full health (the gate). Only GROUNDED
+// planes can be repaired (409 otherwise); an already-full-health repair is a free no-op. 404 unknown
+// plane; 409 not grounded / insufficient funds.
 export async function repairPlane(inst: GameDb, planeId: string): Promise<{ cost: number }> {
   const rows = await inst.db.select().from(schema.planes).where(eq(schema.planes.id, planeId));
   const plane = rows[0];
@@ -377,8 +370,9 @@ export async function repairPlane(inst: GameDb, planeId: string): Promise<{ cost
     throw new GameActionError(409, `insufficient funds: repair costs ${REPAIR_COST}, you have ${Math.round(account.cash)}`);
   }
 
+  // Health is NOT set here — the engine's finishRepairs pass heals it gradually along the gate.
   await inst.db.update(schema.planes)
-    .set({ health: 100, status: 'repairing', repairUntilSimTime: sim.clockMs + REPAIR_DURATION_MS })
+    .set({ status: 'repairing', repairUntilSimTime: sim.clockMs + REPAIR_DURATION_MS })
     .where(eq(schema.planes.id, planeId));
   await inst.db.update(schema.account).set({ cash: Math.round((account.cash - REPAIR_COST) * 100) / 100 });
   await persist(inst);

lib/game/catalog.test.ts

@@ -1,6 +1,7 @@
 import { describe, expect, it } from 'vitest';
-import { BROKEN_BURN_MULTIPLIER, conditionBurnMultiplier, FUEL_DISCOUNT_PER_REP, MAX_FUEL_DISCOUNT, MAX_PLANE_DISCOUNT, PLANE_DISCOUNT_PER_REP, PLANE_TYPES, repRate, STARTER_MODEL } from './catalog';
+import { FUEL_DISCOUNT_PER_REP, MAX_FUEL_DISCOUNT, MAX_PLANE_DISCOUNT, PLANE_DISCOUNT_PER_REP, PLANE_TYPES, repRate, STARTER_MODEL } from './catalog';
 import { STARTING_REPUTATION } from './seed';
+import { guaranteedRangeKm, MAX_WIND_BURN_FACTOR, maxRangeKm, requiredFuelFor } from '@/lib/sim/movement';
 
 // v0.28.0 (ISS-047) — catalog sanity: the progression ladder must stay well-formed as types are added.
 describe('PLANE_TYPES', () => {
@@ -44,20 +45,24 @@ describe('repRate', () => {
   });
 });
 
-// v0.39.0 (ISS-069) — the broken-state burn factor: ×BROKEN_BURN_MULTIPLIER at/below zero health, exactly 1 above it.
+// v0.51.0 (ISS-099) — max range consistency: for EVERY catalog type the displayed guaranteed range
-describe('conditionBurnMultiplier', () => {
+// must be flyable on a full tank under worst-case headwind burn (the same requiredFuelFor ≤ maxFuel
-  it('is exactly 1 for any positive health', () => {
+// rule as flyPlane's fuel guard), and tight — not padded. The closed form inverts exactly, so the
-    expect(conditionBurnMultiplier(100)).toBe(1);
+// "≤" side allows only float noise (~1e-11 L → relative 1e-9 tolerance).
-    expect(conditionBurnMultiplier(42)).toBe(1);
+describe('max range consistency (v0.51.0, ISS-099)', () => {
-    expect(conditionBurnMultiplier(0.5)).toBe(1); // worn but not broken
+  for (const t of Object.values(PLANE_TYPES)) {
+    it(`${t.id}: guaranteed range is flyable in worst-case headwind and not padded`, () => {
+      const r = guaranteedRangeKm(t.burnPerKm, t.emptyWeightKg, t.maxFuel);
+      expect(requiredFuelFor(t.burnPerKm * MAX_WIND_BURN_FACTOR, t.emptyWeightKg, t.maxFuel, r))
+        .toBeLessThanOrEqual(t.maxFuel * (1 + 1e-9));
+      // Tight: 5% beyond the displayed range no longer fits a full tank.
+      expect(requiredFuelFor(t.burnPerKm * MAX_WIND_BURN_FACTOR, t.emptyWeightKg, t.maxFuel, 1.05 * r))
+        .toBeGreaterThan(t.maxFuel);
     });
 
-  it('is exactly BROKEN_BURN_MULTIPLIER at and below zero health', () => {
+    it(`${t.id}: the no-wind closed form inverts requiredFuelFor exactly`, () => {
-    expect(conditionBurnMultiplier(0)).toBe(BROKEN_BURN_MULTIPLIER);
+      const r = maxRangeKm(t.burnPerKm, t.emptyWeightKg, t.maxFuel);
-    expect(conditionBurnMultiplier(-3)).toBe(BROKEN_BURN_MULTIPLIER); // defensive — wear clamps at 0, but the gate is <= 0
+      expect(requiredFuelFor(t.burnPerKm, t.emptyWeightKg, t.maxFuel, r)).toBeLessThanOrEqual(t.maxFuel * (1 + 1e-9));
-  });
-
-  it('pins the broken multiplier at ×1.5', () => {
-    expect(BROKEN_BURN_MULTIPLIER).toBe(1.5);
     });
+  }
 });

lib/game/catalog.ts

@@ -97,6 +97,11 @@ export const PLANE_TYPES: Record<string, PlaneType> = {
   },
 };
 
+// v0.54.0 (ISS-119): fastest cruise speed in the catalog — a generated job must be finishable by
+// the best available aircraft, so seed's expiry floor references this, not the starter's 510 km/h
+// (that would wreck long-job economics). Data-driven: adding a faster plane tightens the floor.
+export const FASTEST_CATALOG_SPEED_KMH = Math.max(...Object.values(PLANE_TYPES).map((t) => t.speedKmh));
+
 // The plane the player starts with.
 export const STARTER_MODEL = 'atr72';
 
@@ -128,15 +133,6 @@ export const MAX_FUEL_DISCOUNT = 0.2;
 // ponytail: balance-tunable — health lost per km of landed legs (~130 mid-range EDDF↔LEMD hops to break from full; 1/10× slower since v0.43.0, ISS-085).
 export const WEAR_PER_KM = 0.0005;
 
-// ponytail: balance-tunable — burn multiplier for a broken plane (health ≤ 0): it still flies, just thirsty.
-export const BROKEN_BURN_MULTIPLIER = 1.5;
-
-// Broken-state burn factor for one plane's health — the third multiplicative term alongside wind at every
-// per-plane burn site (flyPlane dispatch top-up + backstop, engine landed fuel + auto-chain, live display).
-export function conditionBurnMultiplier(health: number): number {
-  return health <= 0 ? BROKEN_BURN_MULTIPLIER : 1;
-}
-
 // ponytail: balance-tunable — flat repair cost in € (per-type if balance demands it).
 export const REPAIR_COST = 1_500;
 // ponytail: balance-tunable — how long a repair grounds the plane, sim ms (3 game days).

lib/game/seed.test.ts

@@ -1,22 +1,31 @@
 import { describe, expect, it } from 'vitest';
+import { WORLD_TIME_SCALE } from '@/lib/worldClock';
 import { haversineKm } from '@/lib/geo';
-import { PLANE_TYPES, repRate, STARTER_MODEL } from './catalog';
+import { travelDurationMs } from '@/lib/sim/movement';
+import { FASTEST_CATALOG_SPEED_KMH, PLANE_TYPES, repRate, STARTER_MODEL } from './catalog';
 import { SPECIALS } from './specials';
 import {
   BASE_REWARD,
   buildSeed,
+  EXPIRY_BUFFER_MS,
   JOB_BONUS_PER_REP,
   MAX_JOB_BONUS,
-  PACKAGE_COUNT_MAX,
-  PACKAGE_COUNT_MIN,
   generatePackage,
+  generatePoolPackage,
   HUB_ICAO,
+  MAX_JOB_LEG_KM,
+  pickDestWithinCap,
+  POOL_BANDS,
+  poolBandOf,
+  POOL_TARGET_PER_AIRPORT,
   mulberry32,
   REWARD_PER_KG,
   REWARD_PER_KM,
   rewardFor,
   STARTING_CASH,
+  STARTING_CLOCK_MS,
   STARTING_REPUTATION,
+  type Rng,
   type SeedAirport,
 } from './seed';
 
@@ -58,24 +67,30 @@ describe('buildSeed', () => {
     expect(seed.plane.locationIcao).toBe(AIRPORTS[1].icao);
   });
 
-  it('seeds 8–12 open packages between distinct fixture airports', () => {
+  it('seeds a full pool of POOL_TARGET_PER_AIRPORT open packages at the hub (v0.65.0)', () => {
     const seed = seedWith(42);
-    expect(seed.packages.length).toBeGreaterThanOrEqual(PACKAGE_COUNT_MIN);
+    expect(seed.packages.length).toBe(POOL_TARGET_PER_AIRPORT);
-    expect(seed.packages.length).toBeLessThanOrEqual(PACKAGE_COUNT_MAX);
 
     const icaoSet = new Set(AIRPORTS.map((a) => a.icao));
+    const byBand = [0, 0, 0, 0];
     for (const c of seed.packages) {
-      expect(icaoSet.has(c.originIcao)).toBe(true);
+      expect(c.originIcao).toBe(HUB_ICAO); // the starter's home hub — its only pool airport
+      const band = POOL_BANDS[poolBandOf(c.weightKg)];
+      byBand[poolBandOf(c.weightKg)]++;
+      expect(c.weightKg).toBeGreaterThanOrEqual(band.minKg); // weight stays in its band…
+      expect(c.weightKg).toBeLessThanOrEqual(band.maxKg); // …on both ends
       expect(icaoSet.has(c.destIcao)).toBe(true);
-      expect(c.originIcao).not.toBe(c.destIcao);
+      expect(c.destIcao).not.toBe(HUB_ICAO);
       expect(c.status).toBe('open');
       expect(c.planeId).toBeNull();
-      expect(c.createdSimTime).toBe(NOW);
+      expect(c.createdSimTime).toBe(STARTING_CLOCK_MS); // game-clock origin, not wall time (ISS-117)
+      expect(c.createdRealMs).toBe(NOW); // …but a fresh real-time lifetime from the seed moment
     }
+    expect(byBand).toEqual(POOL_BANDS.map((b) => b.count));
     expect(new Set(seed.packages.map((c) => c.id)).size).toBe(seed.packages.length);
   });
 
-  it('applies the reward formula: round(500 + 2.5 * km + 0.5 * weightKg), × special multiplier', () => {
+  it('applies the reward formula (BASE_REWARD + REWARD_PER_KM * km + REWARD_PER_KG * weightKg) × special multiplier', () => {
     const seed = seedWith(42);
     for (const c of seed.packages) {
       const o = AIRPORTS.find((a) => a.icao === c.originIcao)!;
@@ -86,34 +101,36 @@ describe('buildSeed', () => {
     }
   });
 
-  it('gives every package a positive integer weight that fits the starter plane alone (balance constraint)', () => {
+  it('gives every package a positive integer weight, and the board always offers jobs beyond the starter', () => {
     const maxPayload = PLANE_TYPES[STARTER_MODEL].maxPayloadKg;
     for (const seed of [seedWith(42), seedWith(7)]) {
       for (const c of seed.packages) {
         expect(Number.isInteger(c.weightKg)).toBe(true);
         expect(c.weightKg).toBeGreaterThan(0);
-        // max count × max jitter (1.3×) must still fit the ATR alone — see UNIT_WEIGHT_KG.
-        expect(c.weightKg).toBeLessThanOrEqual(maxPayload);
       }
+      // v0.65.0: the heavy bands (18–80 t) deliberately exceed the starter's payload — bigger jobs are
+      // what you buy better planes for, so the board must always show work it can't yet do alone.
+      expect(seed.packages.some((c) => c.weightKg > maxPayload)).toBe(true);
     }
   });
 
-  it('sets deadlines inside the 6–72h game-time window after now (scaled by any special status)', () => {
+  it('sets deadlines inside the 6–72h game-time window after the game-clock origin (scaled by any special status)', () => {
     const seed = seedWith(42);
     for (const c of seed.packages) {
       // v0.37.0 (ISS-073): a special's deadlineScale tightens the drawn window (e.g. priority → 3–36h).
+      // ISS-117: the window is anchored at STARTING_CLOCK_MS, not wall time.
       const scale = c.special ? SPECIALS[c.special]?.deadlineScale ?? 1 : 1;
-      expect(c.deadlineSimTime).toBeGreaterThan(NOW + 6 * 3_600_000 * scale - 1);
+      expect(c.deadlineSimTime).toBeGreaterThan(STARTING_CLOCK_MS + 6 * 3_600_000 * scale - 1);
-      expect(c.deadlineSimTime).toBeLessThanOrEqual(NOW + 72 * 3_600_000 * scale);
+      expect(c.deadlineSimTime).toBeLessThanOrEqual(STARTING_CLOCK_MS + 72 * 3_600_000 * scale);
     }
   });
 
   it('seeds the starting account and sim state', () => {
     const seed = seedWith(42);
     expect(seed.account).toEqual({ cash: STARTING_CASH, reputation: STARTING_REPUTATION });
-    // lastRealTickMs starts at the seed moment so the first tick-on-read advances ~0;
+    // ISS-117 (v0.52.0): game clock starts at year 2000 with the fixed world rate; lastRealTickMs is
-    // lastSelectedTimeScale mirrors the seeded speed (v0.30.0, ISS-057).
+    // the REAL seed moment so the first tick-on-read advances ~0. paused/lastSelectedTimeScale are legacy columns.
-    expect(seed.simState).toEqual({ clockMs: NOW, timeScale: 1, paused: false, lastRealTickMs: NOW, lastSelectedTimeScale: 1 });
+    expect(seed.simState).toEqual({ clockMs: STARTING_CLOCK_MS, timeScale: WORLD_TIME_SCALE, paused: false, lastRealTickMs: NOW, lastSelectedTimeScale: WORLD_TIME_SCALE });
   });
 
   it('is fully deterministic for a fixed RNG and inputs', () => {
@@ -131,6 +148,9 @@ describe('buildSeed', () => {
   it('rewardFor applies the documented formula', () => {
     expect(rewardFor(0, 0)).toBe(BASE_REWARD);
     expect(rewardFor(1000, 2_000)).toBe(Math.round(BASE_REWARD + REWARD_PER_KM * 1000 + REWARD_PER_KG * 2_000));
+    // v0.47.0 (ISS-090): literal pins so future retunes are deliberate — weight must dominate payoff.
+    expect(rewardFor(1000, 500)).toBe(4_000);
+    expect(rewardFor(1000, 4_000)).toBe(11_000);
   });
 });
 
@@ -160,8 +180,8 @@ describe('generatePackage (shared seed/spawn builder)', () => {
   });
 
   it('is deterministic for a fixed RNG and honors the id/nowMs inputs', () => {
-    const a = generatePackage({ id: 'c-1', airports: AIRPORTS, rng: mulberry32(7), nowMs: NOW });
+    const a = generatePackage({ id: 'c-1', airports: AIRPORTS, rng: mulberry32(7), nowMs: NOW, createdRealMs: NOW });
-    const b = generatePackage({ id: 'c-1', airports: AIRPORTS, rng: mulberry32(7), nowMs: NOW });
+    const b = generatePackage({ id: 'c-1', airports: AIRPORTS, rng: mulberry32(7), nowMs: NOW, createdRealMs: NOW });
     expect(a).toEqual(b);
 
     const c = generatePackage({ id: 'c-2', airports: AIRPORTS, rng: mulberry32(8), nowMs: NOW + 1000 });
@@ -175,12 +195,15 @@ describe('generatePackage (shared seed/spawn builder)', () => {
     expect(c.deadlineSimTime).toBe(NOW + 10_000);
   });
 
-  it('buildSeed packages are exactly the shared builder output (spawn matches seed)', () => {
+  it('buildSeed packages are exactly the shared pool builder output (spawn matches seed)', () => {
     const rngA = mulberry32(42);
-    const count = PACKAGE_COUNT_MIN + Math.floor(rngA() * (PACKAGE_COUNT_MAX - PACKAGE_COUNT_MIN + 1));
     const expected: string[] = [];
-    for (let i = 0; i < count; i++) {
+    let n = 1;
-      expected.push(JSON.stringify(generatePackage({ id: `package-${i + 1}`, airports: AIRPORTS, rng: rngA, nowMs: NOW })));
+    for (let bandIdx = 0; bandIdx < POOL_BANDS.length; bandIdx++) {
+      for (let i = 0; i < POOL_BANDS[bandIdx].count; i++) {
+        // ISS-117: buildSeed anchors packages at the game-clock origin, not the wall-time input.
+        expected.push(JSON.stringify(generatePoolPackage({ airports: AIRPORTS, originIcao: HUB_ICAO, bandIdx, rng: rngA, clockMs: STARTING_CLOCK_MS, id: `package-${n++}`, createdRealMs: NOW })));
+      }
     }
     const seed = buildSeed({ airports: AIRPORTS, rng: mulberry32(42), nowMs: NOW });
     expect(seed.packages.map((c) => JSON.stringify(c))).toEqual(expected);
@@ -222,8 +245,8 @@ describe('generatePackage (shared seed/spawn builder)', () => {
     });
 
     it('is deterministic for a fixed RNG with forced endpoints', () => {
-      const a = generatePackage({ id: 'c-1', airports: AIRPORTS, rng: mulberry32(7), nowMs: NOW, originIcao: 'EDDF' });
+      const a = generatePackage({ id: 'c-1', airports: AIRPORTS, rng: mulberry32(7), nowMs: NOW, originIcao: 'EDDF', createdRealMs: NOW });
-      const b = generatePackage({ id: 'c-1', airports: AIRPORTS, rng: mulberry32(7), nowMs: NOW, originIcao: 'EDDF' });
+      const b = generatePackage({ id: 'c-1', airports: AIRPORTS, rng: mulberry32(7), nowMs: NOW, originIcao: 'EDDF', createdRealMs: NOW });
       expect(a).toEqual(b);
     });
 
@@ -236,8 +259,8 @@ describe('generatePackage (shared seed/spawn builder)', () => {
     it('omitting both endpoints keeps the pre-v0.8.0 RNG call order (byte-identical output)', () => {
       // Same seed as a historical unforced call → same package, proving forced
       // endpoints consume no extra RNG draws when absent.
-      const a = generatePackage({ id: 'c-x', airports: AIRPORTS, rng: mulberry32(42), nowMs: NOW });
+      const a = generatePackage({ id: 'c-x', airports: AIRPORTS, rng: mulberry32(42), nowMs: NOW, createdRealMs: NOW });
-      const b = generatePackage({ id: 'c-x', airports: AIRPORTS, rng: mulberry32(42), nowMs: NOW, originIcao: undefined, destIcao: undefined });
+      const b = generatePackage({ id: 'c-x', airports: AIRPORTS, rng: mulberry32(42), nowMs: NOW, originIcao: undefined, destIcao: undefined, createdRealMs: NOW });
       expect(a).toEqual(b);
     });
   });
@@ -254,7 +277,7 @@ describe('generatePackage (shared seed/spawn builder)', () => {
       expect(c.reward).toBe(Math.round(rewardFor(haversineKm(o.lat, o.lon, d.lat, d.lon), 1_234) * mult));
 
       // Deterministic for a fixed RNG…
-      const again = generatePackage({ id: 'c-w', airports: AIRPORTS, rng: mulberry32(42), nowMs: NOW, weightKg: 1_234 });
+      const again = generatePackage({ id: 'c-w', airports: AIRPORTS, rng: mulberry32(42), nowMs: NOW, weightKg: 1_234, createdRealMs: c.createdRealMs });
       expect(again).toEqual(c);
       // …and the forced value consumes no RNG draw — the deadline lands where an unforced call's jitter would.
       const unforced = generatePackage({ id: 'c-u', airports: AIRPORTS, rng: mulberry32(42), nowMs: NOW });
@@ -311,8 +334,8 @@ describe('generatePackage (shared seed/spawn builder)', () => {
     });
 
     it('defaults to the starting reputation when omitted — byte-identical output', () => {
-      const a = generatePackage({ id: 'c-r0', airports: AIRPORTS, rng: mulberry32(42), nowMs: NOW });
+      const a = generatePackage({ id: 'c-r0', airports: AIRPORTS, rng: mulberry32(42), nowMs: NOW, createdRealMs: NOW });
-      const b = generatePackage({ id: 'c-r0', airports: AIRPORTS, rng: mulberry32(42), nowMs: NOW, reputation: STARTING_REPUTATION });
+      const b = generatePackage({ id: 'c-r0', airports: AIRPORTS, rng: mulberry32(42), nowMs: NOW, reputation: STARTING_REPUTATION, createdRealMs: NOW });
       expect(a).toEqual(b); // no bonus at the starting value
     });
 
@@ -336,3 +359,175 @@ describe('generatePackage (shared seed/spawn builder)', () => {
     });
   });
 });
+
+describe('distance cap (v0.44.0, ISS-079)', () => {
+  // A and B are ~90 km apart; C is ~19000 km from both — every pair touching C exceeds the cap.
+  const FAR: SeedAirport[] = [
+    { icao: 'AAAA', name: 'Close One', lat: 50, lon: 8 },
+    { icao: 'BBBB', name: 'Close Two', lat: 50.5, lon: 9 },
+    { icao: 'CCCC', name: 'Far Away', lat: -35, lon: 175 },
+  ];
+
+  // Scripted RNG: each value v yields index floor(v * FAR.length) — 0.x → AAAAA/BBBBB range.
+  const scripted = (values: number[]): { rng: Rng; draws: () => number } => {
+    let i = 0;
+    return { rng: () => values[Math.min(i++, values.length - 1)], draws: () => i };
+  };
+
+  it('re-picks an over-cap pair until the leg fits (both endpoints unforced)', () => {
+    // Attempt 1: C→A (over cap) → rejected; attempt 2: A→B (~90 km) → accepted. Exactly 4 endpoint draws.
+    const { rng, draws } = scripted([0.9, 0.1, 0.1, 0.4]);
+    const c = generatePackage({ id: 'c-cap', airports: FAR, rng, nowMs: NOW, special: null });
+    expect(c.originIcao).toBe('AAAA');
+    expect(c.destIcao).toBe('BBBB');
+    // 4 endpoint draws (origin + dest per attempt — the accepted pair stops the loop) + 4 fixed draws.
+    expect(draws()).toBe(8);
+  });
+
+  it('falls back to a within-cap pick of the last origin when attempts exhaust', () => {
+    // 24 over-cap C→A attempts, then A→C (still over cap) ends the bounded loop; the fallback keeps
+    // origin A and draws one index from its within-cap neighbours [B] → A→B. 25×2 + 1 = 51 draws.
+    const values: number[] = [];
+    for (let i = 0; i < 24; i++) values.push(0.9, 0.1); // C→A ×24
+    values.push(0.1, 0.9); // A→C — attempt 25, still over cap
+    values.push(0.5); // fallback draw → candidates[0] = B
+    const { rng, draws } = scripted(values);
+    const c = generatePackage({ id: 'c-cap-fb', airports: FAR, rng, nowMs: NOW, special: null });
+    expect(c.originIcao).toBe('AAAA');
+    expect(c.destIcao).toBe('BBBB');
+    // 51 endpoint draws (25 attempts × 2 + the fallback draw) + 4 fixed draws.
+    expect(draws()).toBe(55);
+  });
+
+  it('keeps the last over-cap pair when the origin has no within-cap neighbour (no throw mid-tick)', () => {
+    // All 25 attempts C→A; the fallback finds no airport within cap of C → -1, pair kept. No extra draw.
+    const values: number[] = [];
+    for (let i = 0; i < 25; i++) values.push(0.9, 0.1); // C→A ×25
+    const { rng, draws } = scripted(values);
+    const c = generatePackage({ id: 'c-cap-keep', airports: FAR, rng, nowMs: NOW, special: null });
+    expect(c.originIcao).toBe('CCCC');
+    expect(c.destIcao).toBe('AAAA');
+    // 50 endpoint draws (25 attempts × 2) + no fallback draw when there are no candidates + 4 fixed.
+    expect(draws()).toBe(54);
+  });
+
+  it('leaves forced endpoints uncapped and consumes no extra draws (the UNNT→LPPD backstop relies on this)', () => {
+    const c = generatePackage({ id: 'c-cap-forced', airports: FAR, rng: mulberry32(42), nowMs: NOW, originIcao: 'CCCC', destIcao: 'AAAA' });
+    expect(c.originIcao).toBe('CCCC'); // ~19000 km — forced pairs skip the cap entirely
+    expect(c.destIcao).toBe('AAAA');
+
+    const countDraws = (origin?: string, dest?: string): number => {
+      let n = 0;
+      generatePackage({ id: 'c-cap-n', airports: FAR, rng: () => { n += 1; return mulberry32(42)(); }, nowMs: NOW, originIcao: origin, destIcao: dest, special: null });
+      return n;
+    };
+    expect(countDraws('CCCC')).toBe(5); // forced origin + random (uncapped) dest → 1 endpoint draw + 4 fixed
+    expect(countDraws('CCCC', 'AAAA')).toBe(4); // both forced → no endpoint draws at all
+  });
+
+  it('pickDestWithinCap picks uniformly from within-cap neighbours, excludes the origin, and returns -1 without a draw when none fit', () => {
+    const near: SeedAirport[] = [FAR[0], FAR[1]]; // A + B only — both within cap of each other
+    let calls = 0;
+    const countingRng: Rng = () => { calls += 1; return 0.9; };
+    expect(pickDestWithinCap(near, 0, countingRng)).toBe(1); // A's only neighbour is B
+    expect(calls).toBe(1);
+
+    let farCalls = 0;
+    const farRng: Rng = () => { farCalls += 1; return 0.9; };
+    expect(pickDestWithinCap(FAR, 2, farRng)).toBe(-1); // C has no neighbour within the cap
+    expect(farCalls).toBe(0); // -1 path consumes no draw
+  });
+
+  it('every generated leg on the real dataset stays under the cap', async () => {
+    const { loadAirportsGeoJson } = await import('@/lib/airports');
+    const fc = await loadAirportsGeoJson();
+    const airports: SeedAirport[] = fc.features.map((f) => ({ icao: f.properties.icao, name: f.properties.name, lat: f.properties.lat, lon: f.properties.lon }));
+    for (let seed = 1; seed <= 50; seed++) {
+      const c = generatePackage({ id: `c-real-${seed}`, airports, rng: mulberry32(seed), nowMs: NOW });
+      const o = airports.find((a) => a.icao === c.originIcao)!;
+      const d = airports.find((a) => a.icao === c.destIcao)!;
+      expect(haversineKm(o.lat, o.lon, d.lat, d.lon)).toBeLessThanOrEqual(MAX_JOB_LEG_KM);
+    }
+  });
+});
+
+describe('expiry floor (v0.54.0, ISS-119)', () => {
+  // Pre-v0.54.0 deadline for a forced-endpoint + forced-special package: replays the fixed draw order
+  // (cargoType, cargoCount, weight jitter, window — forced inputs consume no draws) so short-leg
+  // packages can be pinned byte-identical to the old behavior.
+  const oldDeadlineFor = (seed: number, scale: number): number => {
+    const rng = mulberry32(seed);
+    rng(); // cargoType
+    rng(); // cargoCount
+    rng(); // weight jitter
+    const w = rng(); // deadline window
+    return Math.round(NOW + (6 + w * (72 - 6)) * 3_600_000 * scale);
+  };
+
+  it('pins the constants: fastest catalog speed (not the starter) and a flat 1 h buffer', () => {
+    expect(FASTEST_CATALOG_SPEED_KMH).toBe(Math.max(...Object.values(PLANE_TYPES).map((t) => t.speedKmh)));
+    expect(FASTEST_CATALOG_SPEED_KMH).toBeGreaterThan(PLANE_TYPES[STARTER_MODEL].speedKmh);
+    expect(EXPIRY_BUFFER_MS).toBe(3_600_000);
+  });
+
+  it('every generated package on the real dataset satisfies deadline ≥ now + travel time at max speed + buffer', async () => {
+    const { loadAirportsGeoJson } = await import('@/lib/airports');
+    const fc = await loadAirportsGeoJson();
+    const airports: SeedAirport[] = fc.features.map((f) => ({ icao: f.properties.icao, name: f.properties.name, lat: f.properties.lat, lon: f.properties.lon }));
+    for (let seed = 1; seed <= 200; seed++) {
+      const c = generatePackage({ id: `c-floor-${seed}`, airports, rng: mulberry32(seed), nowMs: NOW }); // special rolls naturally (~15% priority)
+      const o = airports.find((a) => a.icao === c.originIcao)!;
+      const d = airports.find((a) => a.icao === c.destIcao)!;
+      const floorMs = travelDurationMs(haversineKm(o.lat, o.lon, d.lat, d.lon), FASTEST_CATALOG_SPEED_KMH) + EXPIRY_BUFFER_MS;
+      expect(c.deadlineSimTime).toBeGreaterThanOrEqual(Math.round(NOW + floorMs));
+    }
+  });
+
+  it('long legs near MAX_JOB_LEG_KM are clamped up to the floor for every special (real dataset)', async () => {
+    const { loadAirportsGeoJson } = await import('@/lib/airports');
+    const fc = await loadAirportsGeoJson();
+    const airports: SeedAirport[] = fc.features.map((f) => ({ icao: f.properties.icao, name: f.properties.name, lat: f.properties.lat, lon: f.properties.lon }));
+    // Farthest pair within the cap — a leg as long as any generated job can be.
+    let bestI = -1;
+    let bestJ = -1;
+    let bestKm = 0;
+    for (let i = 0; i < airports.length; i++) {
+      for (let j = i + 1; j < airports.length; j++) {
+        const km = haversineKm(airports[i].lat, airports[i].lon, airports[j].lat, airports[j].lon);
+        if (km <= MAX_JOB_LEG_KM && km > bestKm) {
+          bestI = i;
+          bestJ = j;
+          bestKm = km;
+        }
+      }
+    }
+    expect(bestKm).toBeGreaterThan(8_000); // the dataset really spans near-cap legs
+
+    const floorMs = travelDurationMs(bestKm, FASTEST_CATALOG_SPEED_KMH) + EXPIRY_BUFFER_MS;
+    for (const special of ['priority', null] as const) {
+      let clamped = 0;
+      for (let seed = 1; seed <= 50; seed++) {
+        const c = generatePackage({ id: `c-long-${special ?? 'plain'}-${seed}`, airports, rng: mulberry32(seed), nowMs: NOW, originIcao: airports[bestI].icao, destIcao: airports[bestJ].icao, special });
+        expect(c.deadlineSimTime).toBeGreaterThanOrEqual(Math.round(NOW + floorMs)); // the invariant
+        if (c.deadlineSimTime === Math.round(NOW + floorMs)) clamped++; // landed exactly on the floor → the clamp fired
+      }
+      // Deterministic for these fixed seeds — proves the clamp actually engages, not just vacuously holds.
+      expect(clamped).toBeGreaterThan(0);
+    }
+  });
+
+  it('short legs are byte-identical to the pre-v0.54.0 draw (no economy regression)', () => {
+    // EDDF→EHAM ≈ 370 km → floor ≈ 1.4 h — below even the priority minimum window (3 h), so the clamp never fires here.
+    for (const seed of [1, 2, 3, 4, 5]) {
+      const plain = generatePackage({ id: 'c-short', airports: AIRPORTS, rng: mulberry32(seed), nowMs: NOW, originIcao: 'EDDF', destIcao: 'EHAM', special: null });
+      expect(plain.deadlineSimTime).toBe(oldDeadlineFor(seed, 1));
+      const prio = generatePackage({ id: 'c-short-p', airports: AIRPORTS, rng: mulberry32(seed), nowMs: NOW, originIcao: 'EDDF', destIcao: 'EHAM', special: 'priority' });
+      expect(prio.deadlineSimTime).toBe(oldDeadlineFor(seed, SPECIALS.priority.deadlineScale));
+    }
+  });
+
+  it('forced deadline offsets still skip the floor (e2e expiry hook)', () => {
+    const c = generatePackage({ id: 'c-floor-hook', airports: AIRPORTS, rng: mulberry32(1), nowMs: NOW, originIcao: 'EDDF', destIcao: 'EHAM', special: null, deadlineOffsetMs: 10_000 });
+    expect(c.deadlineSimTime).toBe(NOW + 10_000); // the hook's near-term expiry is untouched by the floor
+  });
+});

lib/game/seed.ts

@@ -1,5 +1,7 @@
 import { haversineKm } from '@/lib/geo';
-import { PLANE_TYPES, repRate, STARTER_MODEL } from './catalog';
+import { travelDurationMs } from '@/lib/sim/movement';
+import { WORLD_TIME_SCALE } from '@/lib/worldClock';
+import { FASTEST_CATALOG_SPEED_KMH, PLANE_TYPES, repRate, STARTER_MODEL } from './catalog';
 import { pickSpecial, SPECIALS } from './specials';
 
 // First-run seed. Everything here is a pure function of (airports, rng, nowMs)
@@ -61,6 +63,9 @@ export interface SeedPackage {
   status: 'open';
   planeId: null;
   createdSimTime: number;
+  // Real-time (Date.now()) creation stamp (v0.65.0) — open jobs expire on the wall clock, not the sim
+  // clock, so this is what their lifetime is measured from.
+  createdRealMs: number;
 }
 
 export interface SeedData {
@@ -75,24 +80,63 @@ export interface SeedData {
 export const STARTING_CASH = 20_000;
 export const STARTING_REPUTATION = 10;
 
+// ISS-117 (v0.52.0): fresh worlds start at the top of year 2000 — a fixed game-time origin so
+// every new save begins from the same moment. Existing saves keep their own clock (no migration).
+export const STARTING_CLOCK_MS = Date.UTC(2000, 0, 1);
+
 // The starter plane grounds at a large central-European hub. If the ICAO is
 // ever missing from the dataset we fall back to the first airport rather than
 // failing first run. (EDDF = Frankfurt; EDDM is Munich — don't mix them up.)
 export const HUB_ICAO = 'EDDF'; // Frankfurt Main
 
-export const PACKAGE_COUNT_MIN = 8;
+// v0.65.0: per-airport job pools replace the global market target (v0.7.0). Each airport where a
-export const PACKAGE_COUNT_MAX = 12; // inclusive
+// plane can take work keeps this fixed composition of open packages — heavier bands are rarer, so
+// big jobs feel like opportunities instead of background noise.
+export const POOL_BANDS = [
+  { minKg: 500, maxKg: 3_999, count: 2 }, // <4 t
+  { minKg: 4_000, maxKg: 17_999, count: 6 }, // 4–18 t
+  { minKg: 18_000, maxKg: 48_000, count: 1 }, // 18–48 t
+  { minKg: 48_001, maxKg: 80_000, count: 1 }, // >48 t
+] as const;
 
-// Market target (v0.7.0): the sim engine tops open packages back up to this
+// Which pool band a package's weight falls into (v0.65.0) — the spawner counts open packages per
-// count after expiries, so the job board never runs dry.
+// band and holds taken slots per band, so this must agree with POOL_BANDS' boundaries exactly.
-export const MARKET_TARGET_OPEN_PACKAGES = 10;
+export function poolBandOf(weightKg: number): number {
+  if (weightKg < 4_000) return 0;
+  if (weightKg < 18_000) return 1;
+  if (weightKg <= 48_000) return 2;
+  return 3;
+}
+
+// Total open packages per pool airport — the seed builds exactly this at the starter's home hub.
+export const POOL_TARGET_PER_AIRPORT = POOL_BANDS.reduce((sum, b) => sum + b.count, 0);
+
+// v0.65.0: open jobs live on the WALL clock, not the sim clock — they expire JOB_LIFETIME_MS after
+// creation regardless of time scale or fleet state (checked every tick), so a paused world still
+// refreshes its board. Test hooks may shorten these via env when FLIGHT_TEST_HOOKS=1 (CI sets the
+// refill delays to seconds; the lifetime stays at 1 h everywhere).
+function envMs(name: string, fallback: number): number {
+  if (process.env.FLIGHT_TEST_HOOKS !== '1') return fallback;
+  const v = Number(process.env[name]);
+  return Number.isFinite(v) && v > 0 ? Math.round(v) : fallback;
+}
+
+export const JOB_LIFETIME_MS = envMs('FLIGHT_JOB_LIFETIME_MS', 3_600_000); // 1 h wall clock
+// Refill cooldown after a job is TAKEN (loaded): the slot stays empty this long so the
+// board visibly refreshes instead of instantly refilling. Expired/delivered/abandoned never block —
+// an untaken job's slot respawns immediately. Small jobs (<4 t) refill faster; they're common.
+export const REFILL_DELAY_MS = envMs('FLIGHT_JOB_REFILL_MS', 15 * 60_000); // 15 min wall clock
+export const SMALL_REFILL_DELAY_MS = envMs('FLIGHT_JOB_SMALL_REFILL_MS', 60_000); // 1 min wall clock
 
 // Reward formula (v0.6.0 distance part, deliberately simple; real revenue/cost
 // modeling is a later increment; v0.27.0 weight part): reward = BASE_REWARD +
 // REWARD_PER_KM * great-circle km + REWARD_PER_KG * package weight kg.
+// v0.47.0 (ISS-090) retune: REWARD_PER_KG 0.5 → 2.0 so the weight term dominates
+// base+distance — heavier jobs must clearly pay more per kg to be worth taking
+// (a 1000 km leg went from €3,250 @500 kg / €5,000 @4,000 kg to €4,000 / €11,000).
 export const BASE_REWARD = 500;
 export const REWARD_PER_KM = 2.5;
-export const REWARD_PER_KG = 0.5;
+export const REWARD_PER_KG = 2.0;
 
 // Job reward bonus (v0.38.0, ISS-072): reward ×= 1 + repRate(reputation, …) — better jobs at
 // higher reputation, exactly ×1 at the starting value.
@@ -101,10 +145,24 @@ export const JOB_BONUS_PER_REP = 0.01;
 // ponytail: balance-tunable — max job reward bonus (up to ×2 at rep ≥ 110).
 export const MAX_JOB_BONUS = 1.0;
 
+// v0.44.0 (ISS-079): generated jobs are capped at this great-circle distance so every spawned
+// leg is flyable by at least one catalog plane even in worst-case headwind — the b777's full-tank
+// range is ~13045 km nominal and ~10871 km with the +20% wind factor (maxRangeKm ÷ 1.2), so 9000
+// leaves margin below it while still spanning most of a continent. ponytail: balance-tunable —
+// must stay ≤ maxRangeKm(b777) / 1.2 or some generated legs are permanently unflyable.
+export const MAX_JOB_LEG_KM = 9000;
+
+// Bounded rejection attempts in generatePackage before the within-cap fallback kicks in.
+const LEG_CAP_MAX_ATTEMPTS = 25;
+
 // Package deadlines: now + a plausible game-time window of 6–72 hours.
 const DEADLINE_MIN_HOURS = 6;
 const DEADLINE_MAX_HOURS = 72;
 
+// v0.54.0 (ISS-119): flat slack added to travel time in the expiry floor — a deadline must leave at
+// least this much after the fastest plane lands, so dispatch + landing are never instant.
+export const EXPIRY_BUFFER_MS = 3_600_000; // 1 h
+
 const CARGO_TYPES = ['Passengers', 'Mail', 'Perishables', 'Electronics', 'Auto parts'] as const;
 
 // ponytail: balance-tunable unit weights (kg per passenger/pallet). Chosen so every cargo
@@ -139,6 +197,11 @@ export function rewardFor(km: number, weightKg: number): number {
 // v0.38.0 (ISS-072): reputation optionally scales the reward (×(1 + repRate)) at the same spot
 // as the special multiplier — a pure input, it consumes NO RNG draws and defaults to the
 // starting value so seed-time behavior is byte-identical.
+// v0.54.0 (ISS-119): the drawn deadline window is clamped UP by an expiry floor (travel time at
+// FASTEST_CATALOG_SPEED_KMH + EXPIRY_BUFFER_MS) after special scaling, so every package is
+// finishable by the fastest catalog plane; short legs are byte-identical to before.
+// v0.65.0: createdRealMs optionally FORCES the wall-clock creation stamp (default Date.now()) — a pure
+// input consuming no RNG draws; the seed passes it explicitly so seeded worlds stay deterministic.
 export function generatePackage(input: {
   id: string;
   airports: SeedAirport[];
@@ -150,6 +213,7 @@ export function generatePackage(input: {
   weightKg?: number;
   special?: string | null;
   reputation?: number;
+  createdRealMs?: number;
 }): SeedPackage {
   const { airports, rng, nowMs } = input;
   if (airports.length < 2) throw new Error('package generation needs at least two airports');
@@ -171,6 +235,27 @@ export function generatePackage(input: {
   } else {
     di = Math.floor(rng() * airports.length);
     if (di === oi) di = (di + 1) % airports.length;
+    // v0.44.0 (ISS-079): cap on generated legs — when BOTH endpoints are unforced, rejection-sample
+    // the pair until it fits MAX_JOB_LEG_KM so spawned jobs stay flyable by at least one catalog plane.
+    // Forced paths keep their pre-v0.44.0 draw behavior exactly (the engine's coverage spawn caps its
+    // random dest itself via pickDestWithinCap). Under-cap pairs take just the two draws above, so the
+    // RNG stream is byte-identical to before for them.
+    if (input.originIcao === undefined) {
+      let km = haversineKm(airports[oi].lat, airports[oi].lon, airports[di].lat, airports[di].lon);
+      for (let attempt = 1; km > MAX_JOB_LEG_KM && attempt < LEG_CAP_MAX_ATTEMPTS; attempt++) {
+        oi = Math.floor(rng() * airports.length);
+        di = Math.floor(rng() * airports.length);
+        if (di === oi) di = (di + 1) % airports.length;
+        km = haversineKm(airports[oi].lat, airports[oi].lon, airports[di].lat, airports[di].lon);
+      }
+      if (km > MAX_JOB_LEG_KM) {
+        // Exhausted: keep the last origin and pick uniformly from its within-cap neighbours. If none
+        // exist (impossible in the curated dataset — every airport has a neighbour well inside the cap),
+        // keep the over-cap pair rather than throw mid-tick.
+        const fallback = pickDestWithinCap(airports, oi, rng);
+        if (fallback >= 0) di = fallback;
+      }
+    }
   }
   if (oi === di) throw new Error('origin and destination must differ'); // both forced identical
   const origin = airports[oi];
@@ -184,6 +269,9 @@ export function generatePackage(input: {
   // Weight (v0.27.0): unit weight × count with ±30% jitter, integer kg — drawn AFTER
   // cargoCount so the fixed RNG order above holds; a forced weightKg skips the draw.
   const weightKg = input.weightKg ?? Math.round(UNIT_WEIGHT_KG[cargoType] * cargoCount * (0.7 + 0.6 * rng()));
+  // v0.65.0: a FORCED weight overrides the drawn count so display/payload math agree with weightKg —
+  // pool packages carry band weights far beyond the starter's payload, where the drawn count would lie.
+  const finalCargoCount = input.weightKg !== undefined ? Math.max(1, Math.round(input.weightKg / UNIT_WEIGHT_KG[cargoType])) : cargoCount;
   // Drawn deadline window — the existing draw, position unchanged; special scaling is applied
   // below AFTER the appended special draw so the fixed order above holds.
   const drawnWindowMs = (DEADLINE_MIN_HOURS + rng() * (DEADLINE_MAX_HOURS - DEADLINE_MIN_HOURS)) * 3_600_000;
@@ -191,8 +279,15 @@ export function generatePackage(input: {
   // forced value (including explicit null) skips it, same pattern as the other overrides.
   const special = input.special !== undefined ? input.special : pickSpecial(rng);
   const mods = special !== null ? SPECIALS[special] : undefined;
-  // Forced deadlines skip the special scaling — consistent with overrides skipping draws.
+  // v0.54.0 (ISS-119): expiry floor — every package must be finishable by the fastest catalog plane:
-  const deadlineMs = input.deadlineOffsetMs ?? drawnWindowMs * (mods?.deadlineScale ?? 1);
+  // deadline ≥ now + travel time at FASTEST_CATALOG_SPEED_KMH + EXPIRY_BUFFER_MS. The drawn window is a
+  // single uniform value, so clamping it up AFTER special scaling covers both requirements: short legs
+  // (drawn × scale already above the floor) are byte-identical to before, and when the raw draw falls
+  // below the floor the deadline lands exactly on it — which stays ≤ the scaled ceiling for any pair of
+  // airports on Earth (max leg ~20000 km → floor ≈ 22.8 h < the 36 h priority ceiling), so no separate
+  // ceiling raise is needed. Forced offsets skip the floor, same as they skip the special scaling.
+  const expiryFloorMs = travelDurationMs(km, FASTEST_CATALOG_SPEED_KMH) + EXPIRY_BUFFER_MS;
+  const deadlineMs = input.deadlineOffsetMs ?? Math.max(drawnWindowMs * (mods?.deadlineScale ?? 1), expiryFloorMs);
 
   // v0.38.0 (ISS-072): reputation bonus composed with the special multiplier, single round at the end.
   const repBonus = 1 + repRate(input.reputation ?? STARTING_REPUTATION, JOB_BONUS_PER_REP, MAX_JOB_BONUS);
@@ -203,16 +298,64 @@ export function generatePackage(input: {
     destIcao: dest.icao,
     reward: Math.round(rewardFor(km, weightKg) * repBonus * (mods?.rewardMultiplier ?? 1)),
     cargoType,
-    cargoCount,
+    cargoCount: finalCargoCount,
     weightKg,
     special,
     deadlineSimTime: Math.round(nowMs + deadlineMs),
     status: 'open',
     planeId: null,
     createdSimTime: nowMs,
+    createdRealMs: input.createdRealMs ?? Date.now(),
   };
 }
 
+// v0.65.0: one pool package — a forced origin (the pool airport), a within-cap random destination
+// (same cap as generated legs, so every pool job is flyable by some catalog plane), and a weight drawn
+// uniformly from the band's range. Shared by buildSeed and the runtime spawner so seeded and spawned
+// packages are indistinguishable. RNG draws per package: dest, weight, then generatePackage's own order.
+export function generatePoolPackage(input: {
+  airports: SeedAirport[];
+  originIcao: string;
+  bandIdx: number;
+  rng: Rng;
+  clockMs: number; // game time — anchors createdSimTime/deadlineSimTime
+  id: string;
+  createdRealMs?: number; // wall-clock stamp (default Date.now())
+  reputation?: number;
+}): SeedPackage {
+  const { airports, originIcao, bandIdx, rng } = input;
+  const oi = airports.findIndex((a) => a.icao === originIcao);
+  if (oi < 0) throw new Error(`unknown pool airport ${originIcao}`);
+  const di = pickDestWithinCap(airports, oi, rng);
+  if (di < 0) throw new Error(`no within-cap destination from ${originIcao}`);
+  const band = POOL_BANDS[bandIdx];
+  const weightKg = Math.round(band.minKg + rng() * (band.maxKg - band.minKg));
+  return generatePackage({
+    id: input.id,
+    airports,
+    rng,
+    nowMs: input.clockMs,
+    originIcao,
+    destIcao: airports[di].icao,
+    weightKg,
+    createdRealMs: input.createdRealMs ?? Date.now(),
+    reputation: input.reputation,
+  });
+}
+
+// v0.44.0 (ISS-079): uniform random index of an airport within MAX_JOB_LEG_KM of airports[originIdx]
+// (excluding the origin itself) — one RNG draw, -1 when no neighbour fits. Shared by generatePackage's
+// exhaustion fallback and the engine's coverage spawn so both cap identically without duplicating the scan.
+export function pickDestWithinCap(airports: SeedAirport[], originIdx: number, rng: Rng): number {
+  const candidates: number[] = [];
+  for (let j = 0; j < airports.length; j++) {
+    if (j === originIdx) continue;
+    if (haversineKm(airports[originIdx].lat, airports[originIdx].lon, airports[j].lat, airports[j].lon) <= MAX_JOB_LEG_KM) candidates.push(j);
+  }
+  if (candidates.length === 0) return -1;
+  return candidates[Math.floor(rng() * candidates.length)];
+}
+
 function pickHub(airports: SeedAirport[]): SeedAirport {
   return airports.find((a) => a.icao === HUB_ICAO) ?? airports[0];
 }
@@ -242,22 +385,30 @@ export function buildSeed(input: {
     health: 100, // full health on first run (v0.39.0, ISS-069)
   };
 
-  const count = PACKAGE_COUNT_MIN + Math.floor(rng() * (PACKAGE_COUNT_MAX - PACKAGE_COUNT_MIN + 1));
+  // v0.65.0: the seed market is a full pool at the starter's home hub — the same per-airport
-  // Stable index-based ids for the seed set; runtime-generated entities must use
+  // composition (POOL_BANDS) the runtime spawner maintains, so first run looks like any other tick.
-  // random UUIDs to avoid colliding with these.
+  // Stable index-based ids for the seed set; runtime-generated entities must use random UUIDs to avoid
+  // colliding with these. Deadlines are drawn relative to the GAME clock origin (ISS-117), not the real
+  // wall time, so they stay meaningful at the fixed world rate; createdRealMs is the REAL seed moment
+  // (input.nowMs) so seeded jobs get a fresh full wall-clock lifetime.
   const packages: SeedPackage[] = [];
-  for (let i = 0; i < count; i++) {
+  let n = 1;
-    packages.push(generatePackage({ id: `package-${i + 1}`, airports, rng, nowMs }));
+  for (let bandIdx = 0; bandIdx < POOL_BANDS.length; bandIdx++) {
+    for (let i = 0; i < POOL_BANDS[bandIdx].count; i++) {
+      packages.push(
+        generatePoolPackage({ airports, originIcao: hub.icao, bandIdx, rng, clockMs: STARTING_CLOCK_MS, id: `package-${n++}`, createdRealMs: nowMs }),
+      );
+    }
   }
 
   return {
     plane,
     packages,
     account: { cash: STARTING_CASH, reputation: STARTING_REPUTATION },
-    // lastRealTickMs starts at the seed moment so the first tick-on-read advances
+    // ISS-117 (v0.52.0): the game clock starts at year 2000 with the fixed world rate; lastRealTickMs
-    // by ~0 instead of treating "time since install" as elapsed play time.
+    // is the REAL seed moment so the first tick advances by ~0 instead of treating "time since
-    // lastSelectedTimeScale (v0.30.0, ISS-057) mirrors the seeded speed — nothing has been
+    // install" as elapsed play time. paused/lastSelectedTimeScale are legacy columns kept for schema
-    // selected manually yet, so resume would restore 1× anyway.
+    // stability — no game code reads them anymore.
-    simState: { clockMs: nowMs, timeScale: 1, paused: false, lastRealTickMs: nowMs, lastSelectedTimeScale: 1 },
+    simState: { clockMs: STARTING_CLOCK_MS, timeScale: WORLD_TIME_SCALE, paused: false, lastRealTickMs: nowMs, lastSelectedTimeScale: WORLD_TIME_SCALE },
   };
 }

lib/game/state.test.ts

@@ -0,0 +1,61 @@
+import { describe, expect, it } from 'vitest';
+import { SSE_PACKAGE_STATUSES, sseFrame, type PackageState, type StateSnapshot } from './state';
+
+// ISS-133 (v0.59.0) — the SSE projection keeps only the package statuses any component renders.
+
+const pkg = (status: PackageState['status'], id: string): PackageState => ({
+  id,
+  originIcao: 'LEMD',
+  originName: 'Madrid–Barajas',
+  destIcao: 'EHAM',
+  destName: 'Amsterdam Schiphol',
+  reward: 1000,
+  cargoType: 'mail',
+  cargoCount: 3,
+  weightKg: 900,
+  special: null,
+  expiresRealMs: status === 'open' ? 2_000_000 : null, // v0.65.0 — open jobs carry their wall-clock expiry
+  distanceKm: 2000,
+  deadlineSimTime: 1_000_000,
+  status,
+  planeId: null,
+  createdSimTime: 0,
+});
+
+const snapshot = (packages: PackageState[]): StateSnapshot => ({
+  account: { cash: 20_000, reputation: 1 },
+  simState: { clockMs: 42 },
+  catalog: [],
+  fuelPricePerL: 0.8,
+  sellFraction: 0.5,
+  planes: [],
+  packages,
+});
+
+describe('sseFrame', () => {
+  it('keeps exactly the open/loaded/expired packages and drops terminal history', () => {
+    const all = [
+      pkg('open', 'p-open'),
+      pkg('delivered', 'p-delivered'),
+      pkg('loaded', 'p-loaded'),
+      pkg('abandoned', 'p-abandoned'),
+      pkg('expired', 'p-expired'),
+    ];
+    const frame = sseFrame(snapshot(all));
+    expect(frame.packages.map((p) => p.id)).toEqual(['p-open', 'p-loaded', 'p-expired']);
+  });
+
+  it('passes the rest of the snapshot through untouched and does not mutate its input', () => {
+    const all = [pkg('open', 'a'), pkg('delivered', 'b')];
+    const snap = snapshot(all);
+    const frame = sseFrame(snap);
+    expect(frame.account).toEqual({ cash: 20_000, reputation: 1 });
+    expect(frame.simState).toEqual({ clockMs: 42 });
+    expect(frame.planes).toEqual([]);
+    expect(all.map((p) => p.status)).toContain('delivered'); // input intact
+  });
+
+  it('SSE_PACKAGE_STATUSES matches what the client renders (open market, on-board cargo)', () => {
+    expect([...SSE_PACKAGE_STATUSES].sort()).toEqual(['expired', 'loaded', 'open']);
+  });
+});

lib/game/state.ts

@@ -3,8 +3,9 @@ import { haversineKm, initialBearingDeg } from '@/lib/geo';
 import { weatherFor } from '@/lib/weather';
 import { getGameDb } from '@/lib/db/client';
 import * as schema from '@/lib/db/schema';
-import { conditionBurnMultiplier, catalogEntries, FUEL_PRICE_PER_L, PLANE_TYPES, SELL_FRACTION, type CatalogEntry } from './catalog';
+import { catalogEntries, FUEL_PRICE_PER_L, PLANE_TYPES, SELL_FRACTION, type CatalogEntry } from './catalog';
 import { fuelAtWeighted, progressAt, positionAt, windBurnFactor } from '@/lib/sim/movement';
+import { JOB_LIFETIME_MS } from './seed';
 
 // Read-only game-state snapshot for client polling (GET /api/state).
 
@@ -30,7 +31,8 @@ export interface PlaneState {
   // leg is destIcao. The engine auto-chains queue[0] on landing when fuel covers it.
   queue: string[];
   // Structural health in [0, 100] (v0.39.0, ISS-069) — wears down with distance flown; at 0 the
-  // plane is broken and burns BROKEN_BURN_MULTIPLIER × more fuel until repaired.
+  // plane is broken and cannot fly until repaired (v0.45.0, ISS-089). While 'repairing' this is
+  // also the repair progress: it climbs back to 100 over REPAIR_DURATION_MS of sim time.
   health: number;
   // Sim-clock epoch ms when an active repair finishes (v0.39.0, ISS-069); null when not in repair.
   repairUntilSimTime: number | null;
@@ -48,6 +50,21 @@ export function parseIcaoQueue(raw: string | null): string[] {
   }
 }
 
+// v0.65.0: the airports where a plane can take work — grounded there, flying TO it (its destination
+// joins the pool while airborne), or queued for it (queued legs count even while their plane is in
+// the shop — the work will be waiting at its next stop). A fleet fully repairing with empty queues
+// has no pools until one frees up. Shared by the snapshot's visibility filter and the engine's
+// pool spawner so both agree on exactly which airports keep open jobs.
+export function poolAirports(planes: Array<{ status: string; locationIcao: string; destIcao: string | null; queue: string | null }>): Set<string> {
+  const set = new Set<string>();
+  for (const p of planes) {
+    if (p.status === 'available') set.add(p.locationIcao);
+    else if (p.status === 'flying' && p.destIcao) set.add(p.destIcao);
+    for (const icao of parseIcaoQueue(p.queue)) set.add(icao);
+  }
+  return set;
+}
+
 export interface PackageState {
   id: string;
   originIcao: string;
@@ -61,16 +78,22 @@ export interface PackageState {
   weightKg: number;
   // Special status (v0.37.0, ISS-073) — key into lib/game/specials.ts SPECIALS; null = none.
   special: string | null;
+  // Great-circle leg distance in km (v0.48.0, ISS-095) — computed from airport coords, not stored.
+  distanceKm: number;
   deadlineSimTime: number;
-  // 'ignored' (v0.29.0, ISS-047 part B) = a dismissed open job — terminal, leaves the market.
+  status: 'open' | 'loaded' | 'delivered' | 'expired' | 'abandoned';
-  status: 'open' | 'loaded' | 'delivered' | 'expired' | 'abandoned' | 'ignored';
   planeId: string | null;
   createdSimTime: number;
+  // Wall-clock expiry of an OPEN job (v0.65.0) — createdRealMs + JOB_LIFETIME_MS, shown as a live
+  // countdown in the right pane; null for every non-open status (loaded cargo still uses deadlineSimTime).
+  expiresRealMs: number | null;
 }
 
 export interface StateSnapshot {
   account: { cash: number; reputation: number };
-  simState: { clockMs: number; timeScale: number; paused: boolean };
+  // ISS-117 (v0.52.0): the world rate is a fixed constant (WORLD_TIME_SCALE), not per-save state —
+  // only the clock itself is reported here.
+  simState: { clockMs: number };
   planes: PlaneState[];
   packages: PackageState[];
   // Market reference data (v0.10.0) — static per build, sent with every snapshot so
@@ -80,6 +103,16 @@ export interface StateSnapshot {
   sellFraction: number;
 }
 
+// ISS-133 (v0.59.0): the SSE projection of a snapshot — only the package statuses any component
+// renders: open (market list), loaded + expired (on-board cargo, which keeps its payload slot).
+// Terminal history (delivered/abandoned) is unbounded in the DB and never read by the
+// client, so it stays out of every pushed frame; /api/state and action responses keep the full set.
+export const SSE_PACKAGE_STATUSES = ['open', 'loaded', 'expired'] as const;
+
+export function sseFrame(snapshot: StateSnapshot): StateSnapshot {
+  return { ...snapshot, packages: snapshot.packages.filter((p) => (SSE_PACKAGE_STATUSES as readonly string[]).includes(p.status)) };
+}
+
 export async function getStateSnapshot(): Promise<StateSnapshot> {
   const { db } = await getGameDb();
   // NOTE: use plain select(), not the relational db.query.* API — in drizzle-orm
@@ -99,6 +132,17 @@ export async function getStateSnapshot(): Promise<StateSnapshot> {
   const nameByIcao = new Map(fc.features.map((f) => [f.properties.icao, f.properties.name]));
   const nameOf = (icao: string) => nameByIcao.get(icao) ?? icao;
   const coordsByIcao = new Map(fc.features.map((f) => [f.properties.icao, f.properties]));
+  // v0.48.0 (ISS-095): leg distance for the UI — same haversine as live-plane math; 0 if a coord is missing.
+  const legDistanceKm = (originIcao: string, destIcao: string) => {
+    const from = coordsByIcao.get(originIcao);
+    const to = coordsByIcao.get(destIcao);
+    return from && to ? haversineKm(from.lat, from.lon, to.lat, to.lon) : 0;
+  };
+
+  // v0.65.0: pool visibility — open packages appear only where a plane can take work (poolAirports);
+  // every other status is always visible (on-board cargo, history). Filtered rows are absent from the
+  // body entirely, so clients never see jobs they could not dispatch.
+  const pool = poolAirports(planeRows);
 
   // Analytic movement (v0.7.0): a flying plane's stored lat/lon/fuel are its
   // departure values — live position and fuel are pure functions of the clock.
@@ -113,12 +157,10 @@ export async function getStateSnapshot(): Promise<StateSnapshot> {
     const pos = positionAt(from.lat, from.lon, to.lat, to.lon, progress);
     // Wind-adjusted burn (v0.36.0) — weather is a pure function of the departure ICAO, so this
     // recomputes exactly the factor the engine used for the leg; no stored state needed.
-    // v0.39.0 (ISS-069): broken planes burn BROKEN_BURN_MULTIPLIER × more — p.health is frozen at
-    // departure (wear lands only), so this stays bit-consistent with the engine's landed fuel.
     const w = weatherFor(p.locationIcao);
     return { ...pos, fuel: fuelAtWeighted(
       p.fuel,
-      type.burnPerKm * windBurnFactor(w.windKt, w.windDirDeg, initialBearingDeg(from.lat, from.lon, to.lat, to.lon)) * conditionBurnMultiplier(p.health),
+      type.burnPerKm * windBurnFactor(w.windKt, w.windDirDeg, initialBearingDeg(from.lat, from.lon, to.lat, to.lon)),
       type.emptyWeightKg,
       type.maxFuel,
       distanceKm,
@@ -128,7 +170,7 @@ export async function getStateSnapshot(): Promise<StateSnapshot> {
 
   return {
     account: { cash: accountRow.cash, reputation: accountRow.reputation },
-    simState: { clockMs: simRow.clockMs, timeScale: simRow.timeScale, paused: simRow.paused },
+    simState: { clockMs: simRow.clockMs },
     catalog: catalogEntries(),
     fuelPricePerL: FUEL_PRICE_PER_L,
     sellFraction: SELL_FRACTION,
@@ -152,7 +194,7 @@ export async function getStateSnapshot(): Promise<StateSnapshot> {
         repairUntilSimTime: p.repairUntilSimTime,
       };
     }),
-    packages: packageRows.map((p) => ({
+    packages: packageRows.filter((p) => p.status !== 'open' || pool.has(p.originIcao)).map((p) => ({
         id: p.id,
         originIcao: p.originIcao,
         originName: nameOf(p.originIcao),
@@ -163,10 +205,12 @@ export async function getStateSnapshot(): Promise<StateSnapshot> {
         cargoCount: p.cargoCount,
         weightKg: p.weightKg,
         special: p.special,
+        distanceKm: legDistanceKm(p.originIcao, p.destIcao), // v0.48.0 (ISS-095)
         deadlineSimTime: p.deadlineSimTime,
         status: p.status,
         planeId: p.planeId,
         createdSimTime: p.createdSimTime,
+        expiresRealMs: p.status === 'open' ? p.createdRealMs + JOB_LIFETIME_MS : null,
       })),
   };
 }

lib/mapData.test.ts

@@ -2,18 +2,39 @@ import { describe, expect, it } from 'vitest';
 import type { StateSnapshot } from './game/state';
 import { planesGeoJson, queuedRoutesGeoJson, routesGeoJson, hoverRouteGeoJson, hoverTraceGeoJson, greatCircleArc, ROUTE_ARC_SEGMENTS, type AirportCoord } from './mapData';
 import { haversineKm } from './geo';
+import { loadAirportsGeoJson } from './airports';
+import { positionAt } from './sim/movement';
+import { PLANE_TYPES } from './game/catalog';
 
 const AIRPORTS = new Map<string, AirportCoord>([
   ['EDDF', { lat: 50.03, lon: 8.56 }],
   ['EDDV', { lat: 52.46, lon: 9.68 }],
   ['EHAM', { lat: 52.31, lon: 4.76 }],
   ['LEMD', { lat: 40.47, lon: -3.56 }], // Madrid — ~1400 km from EDDF for the long-route test
+  // ISS-120 (v0.53.0): real dataset pairs whose great circle crosses the antimeridian (±180).
+  ['NZAA', { lat: -37.01199, lon: 174.786331 }], // Auckland — east of +170
+  ['NFTF', { lat: -21.241438, lon: -175.149164 }], // Fua'amotu (Tonga) — west of −175; NZAA→NFTF crosses ±180 eastward
+  ['NZCH', { lat: -43.489029, lon: 172.532065 }], // Christchurch — for the queue-chain joint test
 ]);
 
+// ISS-120: longitude difference on the circle — two lons are "equal" when they differ by a multiple of 360.
+const modDiff = (a: number, b: number): number => {
+  const d = Math.abs(a - b) % 360;
+  return Math.min(d, 360 - d);
+};
+
+// ISS-120: every consecutive pair of samples must be < 180° apart in longitude — the property that
+// keeps MapLibre from drawing a chord across the map.
+function expectContinuousLons(coords: [number, number][]): void {
+  for (let i = 1; i < coords.length; i++) {
+    expect(Math.abs(coords[i]![0] - coords[i - 1]![0]), `jump between samples ${i - 1} and ${i}`).toBeLessThan(180);
+  }
+}
+
 function snapshot(overrides: Partial<StateSnapshot> = {}): StateSnapshot {
   return {
     account: { cash: 0, reputation: 0 },
-    simState: { clockMs: 0, timeScale: 1, paused: false },
+    simState: { clockMs: 0 },
     planes: [],
     packages: [],
     catalog: [
@@ -27,7 +48,7 @@ function snapshot(overrides: Partial<StateSnapshot> = {}): StateSnapshot {
 
 describe('planesGeoJson', () => {
   it('returns an empty collection for a null snapshot', () => {
-    expect(planesGeoJson(null)).toEqual({ type: 'FeatureCollection', features: [] });
+    expect(planesGeoJson(null, AIRPORTS)).toEqual({ type: 'FeatureCollection', features: [] });
   });
 
   it('emits one Point per plane at its polled lat/lon with popup properties', () => {
@@ -38,6 +59,7 @@ describe('planesGeoJson', () => {
           { id: 'plane-2', model: 'atr72', status: 'flying', fuel: 4000, maxFuel: 6300, locationIcao: 'EDDF', locationName: 'Frankfurt Main Airport', destIcao: 'EDDV', destName: 'Hannover Airport', departureSimTime: 1000, lat: 51.2, lon: 9.1, health: 100, repairUntilSimTime: null, queue: [] },
         ],
       }),
+      AIRPORTS, // non-crossing leg — the unwrap is a no-op, positions stay as polled
     );
 
     expect(fc.features).toHaveLength(2);
@@ -64,6 +86,7 @@ describe('planesGeoJson', () => {
           { id: 'p1', model: 'mystery', status: 'available', fuel: 1, maxFuel: 2, locationIcao: 'EDDF', locationName: 'x', destIcao: null, destName: null, departureSimTime: null, lat: 0, lon: 0, health: 100, repairUntilSimTime: null, queue: [] },
         ],
       }),
+      AIRPORTS,
     );
     expect(fc.features[0].properties.modelLabel).toBe('mystery');
   });
@@ -75,11 +98,116 @@ describe('planesGeoJson', () => {
           { id: 'p1', model: 'atr72', status: 'flying', fuel: 1, maxFuel: 2, locationIcao: 'EDDF', locationName: 'x', destIcao: null, destName: null, departureSimTime: 0, lat: 0, lon: 0, health: 100, repairUntilSimTime: null, queue: [] },
         ],
       }),
+      AIRPORTS, // no destIcao — the unwrap guard skips it, position stays as polled
     );
     expect(fc.features[0].properties.routeText).toBe('');
   });
 });
 
+describe('planesGeoJson — antimeridian marker unwrap (ISS-124 v0.58.0)', () => {
+  const nzaa = AIRPORTS.get('NZAA')!; // Auckland, lon +174.8
+  const nftf = AIRPORTS.get('NFTF')!; // Fua'amotu, lon −175.1 — NZAA→NFTF crosses ±180 eastward
+
+  it('eastward crossing: a mid-leg wrapped lon is unwrapped against the origin airport', () => {
+    // positionAt wraps into [−180, 180]: past ±180 the snapshot reads −179.5 for a point at +180.5.
+    const fc = planesGeoJson(
+      snapshot({
+        planes: [
+          { id: 'p1', model: 'atr72', status: 'flying', fuel: 3000, maxFuel: 6300, locationIcao: 'NZAA', locationName: 'Auckland', destIcao: 'NFTF', destName: "Fua'amotu", departureSimTime: 0, lat: -29.5, lon: -179.5, health: 100, repairUntilSimTime: null, queue: [] },
+        ],
+      }),
+      AIRPORTS,
+    );
+    const [lon] = fc.features[0].geometry.coordinates;
+    expect(lon).toBeCloseTo(180.5, 9); // −179.5 + 360 — continuous with the origin's +174.8
+    expect(Math.abs(lon - nzaa.lon)).toBeLessThan(180); // within half a turn of the anchor
+  });
+
+  it('westward crossing (reversed pair): unwrapped below −180', () => {
+    const fc = planesGeoJson(
+      snapshot({
+        planes: [
+          { id: 'p1', model: 'atr72', status: 'flying', fuel: 3000, maxFuel: 6300, locationIcao: 'NFTF', locationName: "Fua'amotu", destIcao: 'NZAA', destName: 'Auckland', departureSimTime: 0, lat: -29.5, lon: 179.5, health: 100, repairUntilSimTime: null, queue: [] },
+        ],
+      }),
+      AIRPORTS,
+    );
+    const [lon] = fc.features[0].geometry.coordinates;
+    expect(lon).toBeCloseTo(-180.5, 9); // +179.5 − 360 — continuous with the origin's −175.1
+  });
+
+  it('marker lon equals the route line\'s own sample at every progress point (same world copy)', () => {
+    // The line is greatCircleArc(NZAA→NFTF) unwrapped from +174.8; feed each of its samples back as a
+    // WRAPPED snapshot position (what positionAt produces server-side) — the marker must land exactly
+    // on the line's sample, so marker and line agree frame to frame across the crossing.
+    const arc = greatCircleArc(nzaa, nftf);
+    for (const [uLon, uLat] of arc) {
+      let wLon = uLon; // wrap into positionAt's range as the server snapshot would carry it
+      while (wLon > 180) wLon -= 360;
+      while (wLon <= -180) wLon += 360;
+      const fc = planesGeoJson(
+        snapshot({
+          planes: [
+            { id: 'p1', model: 'atr72', status: 'flying', fuel: 1, maxFuel: 2, locationIcao: 'NZAA', locationName: 'A', destIcao: 'NFTF', destName: 'B', departureSimTime: 0, lat: uLat, lon: wLon, health: 100, repairUntilSimTime: null, queue: [] },
+          ],
+        }),
+        AIRPORTS,
+      );
+      expect(fc.features[0].geometry.coordinates[0]).toBeCloseTo(uLon, 9);
+    }
+  });
+
+  it('grounded planes keep their raw position (no unwrap without a leg)', () => {
+    const fc = planesGeoJson(
+      snapshot({
+        planes: [
+          { id: 'p1', model: 'atr72', status: 'available', fuel: 6300, maxFuel: 6300, locationIcao: 'NFTF', locationName: "Fua'amotu", destIcao: null, destName: null, departureSimTime: null, lat: nftf.lat, lon: nftf.lon, health: 100, repairUntilSimTime: null, queue: [] },
+        ],
+      }),
+      AIRPORTS,
+    );
+    expect(fc.features[0].geometry.coordinates).toEqual([nftf.lon, nftf.lat]); // raw −175.1, untouched
+  });
+
+  it('a flying plane with a missing endpoint keeps its wrapped lon (no line is drawn either)', () => {
+    const fc = planesGeoJson(
+      snapshot({
+        planes: [
+          { id: 'p1', model: 'atr72', status: 'flying', fuel: 3000, maxFuel: 6300, locationIcao: 'NZAA', locationName: 'Auckland', destIcao: 'ZZZZ', destName: '?', departureSimTime: 0, lat: -29.5, lon: -179.5, health: 100, repairUntilSimTime: null, queue: [] },
+        ],
+      }),
+      AIRPORTS,
+    );
+    expect(fc.features[0].geometry.coordinates).toEqual([-179.5, -29.5]); // wrapped — mirrors routesGeoJson's skip
+  });
+
+  it('non-crossing legs are untouched: lons stay as polled', () => {
+    const fc = planesGeoJson(
+      snapshot({
+        planes: [
+          { id: 'p1', model: 'atr72', status: 'flying', fuel: 3000, maxFuel: 6300, locationIcao: 'EDDF', locationName: 'F', destIcao: 'LEMD', destName: 'M', departureSimTime: 0, lat: 45.2, lon: -1.9, health: 100, repairUntilSimTime: null, queue: [] },
+        ],
+      }),
+      AIRPORTS,
+    );
+    expect(fc.features[0].geometry.coordinates).toEqual([-1.9, 45.2]);
+  });
+
+  it('emits the exact properties e2e starterMarker matches on: id + flying', () => {
+    const fc = planesGeoJson(
+      snapshot({
+        planes: [
+          { id: 'plane-starter', model: 'atr72', status: 'flying', fuel: 3000, maxFuel: 6300, locationIcao: 'NZAA', locationName: 'Auckland', destIcao: 'NFTF', destName: "Fua'amotu", departureSimTime: 0, lat: -29.5, lon: -179.5, health: 100, repairUntilSimTime: null, queue: [] },
+        ],
+      }),
+      AIRPORTS,
+    );
+    const props = fc.features[0].properties!;
+    expect(props.id).toBe('plane-starter'); // starterMarker's match key
+    expect(props.flying).toBe(true); // the flag the e2e poll waits on
+  });
+});
+
 describe('routesGeoJson (v0.12.0 — one line per flying plane\'s current leg)', () => {
   it('returns an empty collection for a null snapshot', () => {
     expect(routesGeoJson(null, AIRPORTS)).toEqual({ type: 'FeatureCollection', features: [] });
@@ -320,3 +448,97 @@ describe('greatCircleArc (v0.12.2 — curved route traces)', () => {
     expect(haversineKm(mid[1], mid[0], chordMid[1], chordMid[0])).toBeLessThan(5); // stays close to the chord
   });
 });
+
+describe('greatCircleArc — antimeridian crossing (ISS-120 v0.53.0)', () => {
+  const from = AIRPORTS.get('NZAA')!; // Auckland, lon +174.8
+  const to = AIRPORTS.get('NFTF')!; // Fua'amotu, lon −175.1 — the short arc crosses ±180 EASTWARD
+
+  it('eastward crossing: continuous lons (|Δlon| < 180), endpoints exact mod 360, length ≈ haversine', () => {
+    const arc = greatCircleArc(from, to);
+    expect(arc.length).toBe(ROUTE_ARC_SEGMENTS + 1);
+    expectContinuousLons(arc); // no wrapped ±180 jump anywhere — the chord bug is gone
+    expect(arc[0]).toEqual([from.lon, from.lat]); // first sample = raw origin, exact
+    const last = arc[arc.length - 1]!;
+    expect(modDiff(last[0], to.lon)).toBeLessThan(1e-9); // last ≡ dest (mod 360) — here unwrapped to +184.8
+    expect(Math.abs(last[1] - to.lat)).toBeLessThan(1e-9);
+    expect(arc.some((c) => c[0] > 180)).toBe(true); // the crossing samples sit on the east world copy
+
+    const dist = haversineKm(from.lat, from.lon, to.lat, to.lon);
+    let sum = 0;
+    for (let i = 1; i < arc.length; i++) sum += haversineKm(arc[i - 1]![1], arc[i - 1]![0], arc[i]![1], arc[i]![0]);
+    expect(Math.abs(sum - dist) / dist).toBeLessThan(0.01); // sampled chord length ≈ true great-circle distance
+  });
+
+  it('westward crossing (reversed pair): continuous lons below −180, endpoints exact mod 360', () => {
+    const arc = greatCircleArc(to, from);
+    expectContinuousLons(arc);
+    expect(arc[0]).toEqual([to.lon, to.lat]); // raw origin, exact
+    const last = arc[arc.length - 1]!;
+    expect(modDiff(last[0], from.lon)).toBeLessThan(1e-9); // ≡ +174.8 (mod 360) — here unwrapped to −185.2
+    expect(Math.abs(last[1] - from.lat)).toBeLessThan(1e-9);
+    expect(arc.some((c) => c[0] < -180)).toBe(true); // the crossing samples sit on the west world copy
+  });
+
+  it('non-crossing routes are untouched: lons stay in [−180, 180]', () => {
+    const arc = greatCircleArc(AIRPORTS.get('EDDF')!, AIRPORTS.get('LEMD')!);
+    expectContinuousLons(arc);
+    for (const c of arc) expect(c[0]).toBeGreaterThanOrEqual(-180);
+    for (const c of arc) expect(c[0]).toBeLessThanOrEqual(180);
+  });
+
+  it('queuedRoutesGeoJson: a chain crossing the antimeridian stays continuous across the joint', () => {
+    // Grounded at NZAA with queue [NFTF, NZCH]: leg 1 crosses ±180 eastward (ends unwrapped at +184.8),
+    // leg 2 restarts at the RAW −175.1 — without the global re-unwrap the joint would jump ~360°.
+    const fc = queuedRoutesGeoJson(
+      [
+        { id: 'p1', model: 'atr72', status: 'available', fuel: 1, maxFuel: 2, locationIcao: 'NZAA', locationName: 'A', destIcao: null, destName: null, departureSimTime: null, lat: -37.01, lon: 174.79, health: 100, repairUntilSimTime: null, queue: ['NFTF', 'NZCH'] },
+      ],
+      AIRPORTS,
+    );
+    expect(fc.features).toHaveLength(1);
+    const coords = fc.features[0]!.geometry.coordinates;
+    expect(coords.length).toBe(2 * ROUTE_ARC_SEGMENTS + 1); // two arcs, joint dropped once
+    expectContinuousLons(coords); // the whole chain — including across the NFTF joint
+    expect(coords[0]).toEqual([from.lon, from.lat]); // starts at the plane's airport, raw
+    const last = coords[coords.length - 1]!;
+    const nzch = AIRPORTS.get('NZCH')!;
+    expect(modDiff(last[0], nzch.lon)).toBeLessThan(1e-9); // ends ≡ NZCH (mod 360)
+    expect(Math.abs(last[1] - nzch.lat)).toBeLessThan(1e-9);
+  });
+});
+
+describe('NZAA→NFTF crossing leg — full pipeline on stored dataset coords (ISS-124)', () => {
+  // The exact production pipeline for one flying frame: the server snapshot holds positionAt's WRAPPED
+  // lat/lon (atan2 → [−180, 180]); planesGeoJson re-expresses lon against the departure airport
+  // (locationIcao is always the leg origin while flying — lib/game/state.ts). This pins what lons the
+  // e2e marker sampling can EVER see for this dataset's stored coords.
+  it('marker lons cross above +180 eastward, continuously', async () => {
+    const fc = await loadAirportsGeoJson();
+    const nzaa = fc.features.find((f) => f.properties.icao === 'NZAA')!.properties;
+    const nftf = fc.features.find((f) => f.properties.icao === 'NFTF')!.properties;
+    expect(nzaa.lon).toBeGreaterThan(170); // stored east-positive (Auckland +174.8, not −175.x)
+    expect(nftf.lon).toBeLessThan(-170);
+
+    const km = haversineKm(nzaa.lat, nzaa.lon, nftf.lat, nftf.lon);
+    const index = new Map<string, AirportCoord>([
+      ['NZAA', { lat: nzaa.lat, lon: nzaa.lon }],
+      ['NFTF', { lat: nftf.lat, lon: nftf.lon }],
+    ]);
+    const lons: number[] = [];
+    for (let i = 0; i <= 50; i++) {
+      const pos = positionAt(nzaa.lat, nzaa.lon, nftf.lat, nftf.lon, i / 50); // wrapped — exactly what the snapshot holds
+      const snap = snapshot({
+        planes: [
+          { id: 'plane-starter', model: 'atr72', status: 'flying', fuel: 1000, maxFuel: PLANE_TYPES.atr72.maxFuel, locationIcao: 'NZAA', locationName: 'Auckland International Airport', destIcao: 'NFTF', destName: "Fua'amotu International Airport", departureSimTime: 0, lat: pos.lat, lon: pos.lon, health: 100, repairUntilSimTime: null, queue: [] },
+        ],
+      });
+      lons.push(planesGeoJson(snap, index).features[0]!.geometry.coordinates[0]!);
+    }
+    console.log(`NZAA→NFTF (${km.toFixed(1)} km): sampled marker lons ${JSON.stringify(lons.map((x) => Number(x.toFixed(2))))}`);
+    for (let i = 1; i < lons.length; i++) {
+      expect(Math.abs(lons[i]! - lons[i - 1]!), `jump between samples ${i - 1} and ${i}`).toBeLessThan(180);
+    }
+    expect(Math.max(...lons)).toBeGreaterThan(180); // eastward crossing → onto the + world copy
+    expect(Math.min(...lons)).toBeGreaterThanOrEqual(nzaa.lon - 1e-9); // never wraps to the west copy
+  });
+});

lib/mapData.ts

@@ -41,15 +41,30 @@ export interface FeatureCollection<T> {
 const EMPTY_POINTS: FeatureCollection<MapPointFeature> = { type: 'FeatureCollection', features: [] };
 const EMPTY_LINES: FeatureCollection<MapLineFeature> = { type: 'FeatureCollection', features: [] };
 
-export function planesGeoJson(state: StateSnapshot | null): FeatureCollection<MapPointFeature> {
+// ISS-124 (v0.58.0): positionAt wraps each sample's longitude into [−180, 180], so a marker on a
+// leg crossing the antimeridian jumps +179.x → −179.x between polls — MapLibre draws that as a 360°
+// teleport while the route line (greatCircleArc) stays continuous. Unwrap the plane's lon against
+// its departure airport — the same anchor greatCircleArc keeps for its first sample — so marker and
+// line agree frame to frame. Only when BOTH endpoints exist, mirroring routesGeoJson's guard: a
+// flying plane with a missing endpoint draws no line either, so it stays wrapped like before.
+export function planesGeoJson(
+  state: StateSnapshot | null,
+  airportsByIcao: ReadonlyMap<string, AirportCoord>,
+): FeatureCollection<MapPointFeature> {
   if (!state) return EMPTY_POINTS;
   // Catalog display name ("ATR 72-600") for the popup — raw model id as fallback.
   const labelByModel = new Map(state.catalog.map((e) => [e.model, e.label]));
   const features: MapPointFeature[] = state.planes.map((p) => {
     const flying = p.status === 'flying';
+    let lon = p.lon;
+    if (flying && p.destIcao) {
+      const from = airportsByIcao.get(p.locationIcao);
+      const to = airportsByIcao.get(p.destIcao);
+      if (from && to) lon = unwrapLon(p.lon, from.lon);
+    }
     return {
       type: 'Feature',
-      geometry: { type: 'Point', coordinates: [p.lon, p.lat] },
+      geometry: { type: 'Point', coordinates: [lon, p.lat] },
       properties: {
         id: p.id,
         modelLabel: labelByModel.get(p.model) ?? p.model,
@@ -74,16 +89,38 @@ export interface AirportCoord {
 // curved path the plane actually flies (same slerp as lib/sim/movement.ts).
 export const ROUTE_ARC_SEGMENTS = 24;
 
+// ISS-120 (v0.53.0): positionAt wraps each sample's longitude into [−180, 180], so an arc that
+// crosses the antimeridian jumps +179.x → −179.x between consecutive samples — and MapLibre draws
+// LineStrings as-is (no ±180 splitting), rendering a chord across the whole map. Unwrap the sample
+// sequence into continuous longitudes: keep the first sample's raw lon, then shift each subsequent
+// one by ±360 relative to the previous UNWRAPPED value until |Δlon| ≤ 180. One line stays one line;
+// out-of-range values render on MapLibre's adjacent world copies (renderWorldCopies is default-on).
+function unwrapLon(lon: number, prev: number): number {
+  while (lon - prev > 180) lon -= 360;
+  while (prev - lon > 180) lon += 360;
+  return lon;
+}
+
+function unwrapLons(coords: [number, number][]): [number, number][] {
+  let prev = coords[0]![0];
+  for (let i = 1; i < coords.length; i++) {
+    const lon = unwrapLon(coords[i]![0], prev);
+    coords[i]![0] = lon;
+    prev = lon;
+  }
+  return coords;
+}
+
 // Great-circle arc between two airports as [lon, lat] coordinates: positionAt at
-// t = i/SEGMENTS for i in 0..SEGMENTS. Pure — endpoints are exactly the airport
+// t = i/SEGMENTS for i in 0..SEGMENTS. Pure — the first sample is exactly `from` and the last is
-// coords (positionAt returns them verbatim at t=0 and t=1).
+// ≡ `to` (mod 360) (positionAt returns them verbatim at t=0 and t=1, unwrapped relative to from).
 export function greatCircleArc(from: AirportCoord, to: AirportCoord): [number, number][] {
   const coords: [number, number][] = [];
   for (let i = 0; i <= ROUTE_ARC_SEGMENTS; i++) {
     const pos = positionAt(from.lat, from.lon, to.lat, to.lon, i / ROUTE_ARC_SEGMENTS);
     coords.push([pos.lon, pos.lat]);
   }
-  return coords;
+  return unwrapLons(coords);
 }
 
 // ISS-022/025/027 (v0.22.0): the hover route trace — one great-circle LineString between two
@@ -195,6 +232,9 @@ export function queuedRoutesGeoJson(
       const arc = greatCircleArc(pts[i]!, pts[i + 1]!);
       coords.push(...(i === 0 ? arc : arc.slice(1))); // drop the duplicated joint point
     }
+    // ISS-120: each leg's arc is unwrapped relative to its OWN start airport, so at a joint the
+    // sequence can jump ±360 (leg 1 ends at dest+360k, leg 2 restarts at the raw dest) — re-unify.
+    unwrapLons(coords);
     features.push({
       type: 'Feature',
       geometry: { type: 'LineString', coordinates: coords },

lib/openapi.test.ts

@@ -3,19 +3,23 @@ import { describe, expect, it } from 'vitest';
 import { openApiSpec } from './openapi';
 
 describe('OpenAPI spec', () => {
-  it('documents exactly the thirteen public endpoints (4 read + 9 player actions)', () => {
+  it('documents exactly the seventeen public endpoints (6 read + 8 player actions + 2 auth + 1 admin CRUD)', () => {
     expect(Object.keys(openApiSpec.paths).sort()).toEqual([
+      '/api/admin/tables', // v0.71.0 — admin panel
+      '/api/admin/tables/{name}/rows', // v0.71.0 — GET+PUT+POST+DELETE on one path
       '/api/airports',
+      '/api/events', // v0.57.0 (ISS-129) — SSE state stream
+      '/api/login', // v0.71.0 — admin panel auth
+      '/api/logout', // v0.71.0
       '/api/market/buy-plane',
       '/api/market/sell-plane',
+      '/api/me', // v0.71.0
       '/api/packages/{id}/abandon',
-      '/api/packages/{id}/ignore', // v0.29.0 (ISS-047 part B)
       '/api/packages/{id}/load',
       '/api/planes/{planeId}/fly',
       '/api/planes/{planeId}/queue', // v0.25.0 (ISS-043)
       '/api/planes/{planeId}/queue/cancel', // v0.25.0 (ISS-043)
       '/api/planes/{planeId}/repair', // v0.39.0 (ISS-069)
-      '/api/sim',
       '/api/state',
       '/api/version',
     ]);
@@ -136,6 +140,8 @@ describe('OpenAPI spec', () => {
       'deadlineSimTime',
       'destIcao',
       'destName',
+      'distanceKm', // v0.48.0 (ISS-095) — great-circle leg distance in km
+      'expiresRealMs', // v0.65.0 — wall-clock expiry for open jobs; null otherwise
       'id',
       'originIcao',
       'originName',
@@ -146,34 +152,12 @@ describe('OpenAPI spec', () => {
       'weightKg', // v0.27.0 (ISS-045) — package weight in kg
     ]);
 
+    // ISS-117 (v0.52.0): the snapshot carries only the game clock — time controls are gone.
     const sim = openApiSpec.components.schemas.SimState.properties;
-    expect(Object.keys(sim).sort()).toEqual(['clockMs', 'paused', 'timeScale']);
+    expect(Object.keys(sim).sort()).toEqual(['clockMs']);
 
     const packageStatus = openApiSpec.components.schemas.PackageState.properties.status;
-    expect(packageStatus.enum.sort()).toEqual(['abandoned', 'delivered', 'expired', 'ignored', 'loaded', 'open']); // v0.29.0 (ISS-047 part B)
+    expect(packageStatus.enum.sort()).toEqual(['abandoned', 'delivered', 'expired', 'loaded', 'open']);
-  });
-
-  it('describes POST /api/sim as SimControlsRequest → SimState with a 400 error shape', () => {
-    const post = openApiSpec.paths['/api/sim'].post;
-    expect(post.operationId).toBe('setSimControls');
-
-    const requestSchema = post.requestBody.content['application/json'].schema;
-    expect(requestSchema.$ref).toBe('#/components/schemas/SimControlsRequest');
-
-    const ok = post.responses[200].content['application/json'].schema;
-    expect(ok.$ref).toBe('#/components/schemas/SimState');
-    const bad = post.responses[400].content['application/json'].schema;
-    expect(bad.$ref).toBe('#/components/schemas/Error');
-
-    const controls = openApiSpec.components.schemas.SimControlsRequest.properties;
-    expect(Object.keys(controls).sort()).toEqual(['paused', 'timeScale']);
-    expect(controls.timeScale.type).toBe('number');
-    expect(controls.timeScale.minimum).toBe(1);
-    expect(controls.timeScale.maximum).toBe(1000);
-    expect(controls.paused.type).toBe('boolean');
-
-    const error = openApiSpec.components.schemas.Error.properties;
-    expect(Object.keys(error)).toEqual(['error']);
   });
 
   it('documents the eight action endpoints: snapshot on 200, Error on their 4xx paths', () => {
@@ -263,4 +247,53 @@ describe('OpenAPI spec', () => {
     expect(sell.required).toEqual(['planeId']);
     expect(sell.properties.planeId.type).toBe('string');
   });
+
+  it('documents the v0.71.0 admin-panel endpoints: auth + guarded DB CRUD', () => {
+    const paths = openApiSpec.paths as Record<string, Record<string, { responses: Record<string, unknown>; requestBody?: unknown; parameters?: Array<{ name: string }> }>>;
+
+    // Error codes per endpoint (401/403 on every admin route — the guard runs before input).
+    const codes = (p: string, m: string) => Object.keys(paths[p][m].responses).sort();
+    expect(codes('/api/login', 'post')).toEqual(['200', '400', '401']);
+    expect(codes('/api/logout', 'post')).toEqual(['200', '401']);
+    expect(codes('/api/me', 'get')).toEqual(['200', '401']);
+    expect(codes('/api/admin/tables', 'get')).toEqual(['200', '401', '403']);
+    for (const m of ['get', 'put', 'post', 'delete'] as const) {
+      expect(codes(`/api/admin/tables/{name}/rows`, m), `${m} rows`).toContain('401');
+      expect(codes(`/api/admin/tables/{name}/rows`, m), `${m} rows`).toContain('403');
+      expect(codes(`/api/admin/tables/{name}/rows`, m), `${m} rows`).toContain('404');
+    }
+
+    // Success shapes.
+    const ok = (p: string, m: string) => paths[p][m].responses['200'] as { content: Record<string, { schema: unknown }> };
+    expect((ok('/api/login', 'post').content['application/json'].schema as { $ref: string }).$ref).toBe('#/components/schemas/LoginResponse');
+    expect((ok('/api/me', 'get').content['application/json'].schema as { $ref: string }).$ref).toBe('#/components/schemas/SessionUser');
+    const tables = ok('/api/admin/tables', 'get').content['application/json'].schema as { type: string; items: { $ref: string } };
+    expect(tables.type).toBe('array');
+    expect(tables.items.$ref).toBe('#/components/schemas/AdminTable');
+    const rows = ok('/api/admin/tables/{name}/rows', 'get').content['application/json'].schema as { $ref: string };
+    expect(rows.$ref).toBe('#/components/schemas/AdminRowsResponse');
+
+    // Request bodies + path parameter.
+    const bodyRef = (p: string, m: string) =>
+      ((paths[p][m].requestBody ?? {}) as { content?: Record<string, { schema: { $ref: string } }> }).content?.['application/json']
+        ?.schema.$ref;
+    expect(bodyRef('/api/login', 'post')).toBe('#/components/schemas/LoginRequest');
+    expect(bodyRef('/api/admin/tables/{name}/rows', 'put')).toBe('#/components/schemas/UpdateRowRequest');
+    expect(bodyRef('/api/admin/tables/{name}/rows', 'post')).toBe('#/components/schemas/InsertRowRequest');
+    for (const m of ['get', 'put', 'post', 'delete'] as const) {
+      expect(paths['/api/admin/tables/{name}/rows'][m].parameters?.map((x) => x.name)).toContain('name');
+    }
+
+    // Request schema shapes.
+    const login = openApiSpec.components.schemas.LoginRequest;
+    expect(login.required).toEqual(['username', 'password']);
+    expect(login.properties.username.type).toBe('string');
+    expect(login.properties.password.type).toBe('string');
+    const sessionUser = openApiSpec.components.schemas.SessionUser;
+    expect(sessionUser.required.sort()).toEqual(['admin', 'username']);
+    expect(sessionUser.properties.admin.type).toBe('boolean');
+    const updateRow = openApiSpec.components.schemas.UpdateRowRequest;
+    expect(updateRow.required).toEqual(['rowid', 'values']);
+    expect(updateRow.properties.rowid.type).toBe('integer');
+  });
 });

lib/openapi.ts

@@ -8,7 +8,7 @@ export const openApiSpec = {
   info: {
     title: 'Flight Ops API',
     description:
-      'JSON API for Flight Ops — EU airport data for the map, the live game-state snapshot, player actions (load / fly / abandon / buy / sell), and app metadata. Every action endpoint ticks the sim clock first and returns the full state snapshot on success.',
+      'JSON API for Flight Ops — world airport data for the map, the live game-state snapshot, player actions (load / fly / abandon / buy / sell), admin-panel auth + whole-database tooling (v0.71.0), and app metadata. Every action endpoint ticks the sim clock first and returns the full state snapshot on success.',
     // Sourced from package.json so it stays in sync with every version bump.
     version: pkg.version,
   },
@@ -17,13 +17,13 @@ export const openApiSpec = {
   paths: {
     '/api/airports': {
       get: {
-        summary: 'List EU airports',
+        summary: 'List world airports',
         description:
-          'All fixed-wing EU airports (large, medium and seaplane bases) as a GeoJSON FeatureCollection.',
+          'The curated world airport dataset — one marker per metro area (large airports only, close clusters merged to the biggest; see scripts/build-world-airports.mjs) — as a GeoJSON FeatureCollection.',
         operationId: 'listAirports',
         responses: {
           200: {
-            description: 'GeoJSON FeatureCollection of EU airports',
+            description: 'GeoJSON FeatureCollection of world airports',
             content: {
               'application/json': {
                 schema: { $ref: '#/components/schemas/AirportFeatureCollection' },
@@ -37,7 +37,7 @@ export const openApiSpec = {
       get: {
         summary: 'Game state snapshot',
         description:
-          'Full current game state for client polling — account, sim clock, planes and packages, plus the static market reference data (catalog + economy constants) so clients can compute buy/sell previews locally. Tick-on-read: each call first advances the sim clock by (real time since last read) × timeScale (clamped per tick), so expiry/delivery/spawn are always applied before the snapshot is returned.',
+          'Full current game state for client polling — account, sim clock, planes and packages, plus the static market reference data (catalog + economy constants) so clients can compute buy/sell previews locally. The world clock advances on a ~1 s background tick at a fixed rate (v0.52.0, ISS-117: no player-facing time controls), clamped per tick; while no plane is flying or in repair the clock stays frozen. Each call ticks first, so expiry/delivery/spawn are always applied before the snapshot is returned.',
         operationId: 'getState',
         responses: {
           200: {
@@ -51,35 +51,17 @@ export const openApiSpec = {
         },
       },
     },
-    '/api/sim': {
+    '/api/events': {
-      post: {
+      get: {
-        summary: 'Set sim time controls',
+        summary: 'Live state stream (SSE)',
         description:
-          'Advance the sim clock (tick-on-read) and set the time scale / pause state. The clock is advanced first, so the returned simState already reflects current game time; package expiry, arrival delivery and market spawn run inside that tick.',
+          'Server-Sent Events feed of full game-state snapshots (v0.57.0, ISS-129) — the current snapshot is sent immediately on connect and a fresh one after every sim tick (~1 s), so clients can subscribe instead of polling /api/state. Each event\'s data payload is JSON with exactly the StateSnapshot shape; comment lines starting with ":" are heartbeats.',
-        operationId: 'setSimControls',
+        operationId: 'subscribeToEvents',
-        requestBody: {
-          required: false,
-          content: {
-            'application/json': {
-              schema: { $ref: '#/components/schemas/SimControlsRequest' },
-            },
-          },
-        },
         responses: {
           200: {
-            description: 'Updated sim state',
+            description: 'SSE stream of state snapshots (text/event-stream)',
             content: {
-              'application/json': {
+              'text/event-stream': { schema: { type: 'string' } },
-                schema: { $ref: '#/components/schemas/SimState' },
-              },
-            },
-          },
-          400: {
-            description: 'Invalid body (not an object, unknown field, or wrong types)',
-            content: {
-              'application/json': {
-                schema: { $ref: '#/components/schemas/Error' },
-              },
             },
           },
         },
@@ -165,31 +147,6 @@ export const openApiSpec = {
         },
       },
     },
-    '/api/packages/{id}/ignore': {
-      post: {
-        summary: 'Ignore an open job',
-        description:
-          'Dismiss an OPEN job so it leaves the market permanently (v0.29.0, ISS-047 part B). No penalty and nothing else changes — the top-up logic spawns a replacement on the next tick. No body.',
-        operationId: 'ignorePackage',
-        parameters: [
-          { name: 'id', in: 'path', required: true, schema: { type: 'string' } },
-        ],
-        responses: {
-          200: {
-            description: 'Ignored — full state snapshot (package "ignored", gone from the open list)',
-            content: { 'application/json': { schema: { $ref: '#/components/schemas/StateSnapshot' } } },
-          },
-          404: {
-            description: 'Unknown package id',
-            content: { 'application/json': { schema: { $ref: '#/components/schemas/Error' } } },
-          },
-          409: {
-            description: 'Package not "open"',
-            content: { 'application/json': { schema: { $ref: '#/components/schemas/Error' } } },
-          },
-        },
-      },
-    },
     '/api/planes/{planeId}/fly': {
       post: {
         summary: 'Fly a plane to an airport',
@@ -223,7 +180,7 @@ export const openApiSpec = {
           },
           409: {
             description:
-              'Plane not grounded, or the leg does not fit even a FULL tank (v0.16.0 weight-proportional burn — the fuel required to cover the great-circle distance arriving empty; dispatch auto-refuels up to min(maxFuel, max(fuel, 1.5 × required)) first, ISS-082), or cash is insufficient for that top-up',
+              'Plane not grounded, plane broken (health ≤ 0 — repair it first, v0.45.0), or the leg does not fit even a FULL tank (v0.16.0 weight-proportional burn — the fuel required to cover the great-circle distance arriving empty; dispatch auto-refuels up to min(maxFuel, max(fuel, 1.5 × required)) first, ISS-082), or cash is insufficient for that top-up',
             content: { 'application/json': { schema: { $ref: '#/components/schemas/Error' } } },
           },
         },
@@ -233,7 +190,7 @@ export const openApiSpec = {
       post: {
         summary: 'Queue a flight leg for a plane',
         description:
-          'Append a NOT-yet-started leg to the plane\'s flight queue (v0.25.0, ISS-043). Works whether the plane is grounded or flying — you can pre-build a route; the active leg still starts via /fly and nothing auto-starts here. On landing, the engine auto-chains the first queued leg when fuel covers it — with a short tank it auto-refuels to 150% of the requirement (capped at tank capacity) when cash allows (ISS-082); only an unaffordable top-up grounds the plane with the queue kept intact for a later dispatch.',
+          'Append a NOT-yet-started leg to the plane\'s flight queue (v0.25.0, ISS-043). Works whether the plane is grounded or flying — you can pre-build a route; the active leg still starts via /fly and nothing auto-starts here. On landing, the engine auto-chains the first queued leg when fuel covers it and the plane is not broken by the landing\'s wear (v0.45.0) — with a short tank it auto-refuels to 150% of the requirement (capped at tank capacity) when cash allows (ISS-082); only an unaffordable top-up (or a broken plane) grounds the plane with the queue kept intact for a later dispatch.',
         operationId: 'queueLeg',
         parameters: [
           { name: 'planeId', in: 'path', required: true, schema: { type: 'string' } },
@@ -370,14 +327,14 @@ export const openApiSpec = {
       post: {
         summary: 'Repair a grounded plane',
         description:
-          'Restore a worn-out plane to full health for the flat repair cost (v0.39.0, ISS-069): the plane is grounded in "repairing" status until 3 sim days pass, when the engine\'s tick flips it back to "available". While repairing it cannot load, fly or be sold; a broken plane (health ≤ 0) still flies but burns 50% more fuel. A full-health repair is a free no-op (cost 0). No body.',
+          'Ground a worn-out plane in "repairing" status for the flat repair cost (v0.39.0, ISS-069): its health climbs back to 100 over 3 sim days — the engine\'s tick applies the curve each tick and flips it back to "available" exactly when full health is reached (v0.45.0, ISS-089). While repairing it cannot load, fly or be sold; a broken plane (health ≤ 0) cannot fly at all until repaired. A full-health repair is a free no-op (cost 0). No body.',
         operationId: 'repairPlane',
         parameters: [
           { name: 'planeId', in: 'path', required: true, schema: { type: 'string' } },
         ],
         responses: {
           200: {
-            description: 'Repair started (or free no-op) — full state snapshot (health 100, status "repairing" with the gate set, cash reduced by the flat cost)',
+            description: 'Repair started (or free no-op) — full state snapshot (status "repairing" with the gate set, health unchanged until the engine\'s tick heals it back to 100 over the duration, cash reduced by the flat cost)',
             content: { 'application/json': { schema: { $ref: '#/components/schemas/StateSnapshot' } } },
           },
           404: {
@@ -391,6 +348,243 @@ export const openApiSpec = {
         },
       },
     },
+    // v0.71.0 — admin panel: session auth + generic whole-database CRUD behind the admin flag.
+    '/api/login': {
+      post: {
+        summary: 'Log in',
+        description:
+          'Verify username/password (scrypt) and mint a 7-day session. The client stores the returned sessionId in localStorage and sends it as the X-Flight-Session header on later requests. An unknown username still runs one full scrypt against a fixed dummy digest, so timing stays uniform.',
+        operationId: 'login',
+        requestBody: {
+          required: true,
+          content: {
+            'application/json': {
+              schema: { $ref: '#/components/schemas/LoginRequest' },
+            },
+          },
+        },
+        responses: {
+          200: {
+            description: 'Authenticated — new session id + the user',
+            content: { 'application/json': { schema: { $ref: '#/components/schemas/LoginResponse' } } },
+          },
+          400: {
+            description: 'Invalid body (not an object, unknown field, or missing/non-string username/password)',
+            content: { 'application/json': { schema: { $ref: '#/components/schemas/Error' } } },
+          },
+          401: {
+            description: 'Unknown username or wrong password',
+            content: { 'application/json': { schema: { $ref: '#/components/schemas/Error' } } },
+          },
+        },
+      },
+    },
+    '/api/logout': {
+      post: {
+        summary: 'Log out',
+        description:
+          'Delete the session named by the X-Flight-Session header (no body). Idempotent — deleting an unknown or already-deleted session is still 200.',
+        operationId: 'logout',
+        responses: {
+          200: {
+            description: 'Session deleted (or was already gone)',
+            content: { 'application/json': { schema: { $ref: '#/components/schemas/OkResponse' } } },
+          },
+          401: {
+            description: 'Missing X-Flight-Session header',
+            content: { 'application/json': { schema: { $ref: '#/components/schemas/Error' } } },
+          },
+        },
+      },
+    },
+    '/api/me': {
+      get: {
+        summary: 'Current user',
+        description:
+          'Resolve the X-Flight-Session header to its user, or 401 when the session is missing/unknown/expired. The client uses it to decide what the Admin modal shows on open.',
+        operationId: 'getMe',
+        responses: {
+          200: {
+            description: 'The authenticated user',
+            content: { 'application/json': { schema: { $ref: '#/components/schemas/SessionUser' } } },
+          },
+          401: {
+            description: 'Missing, unknown or expired session',
+            content: { 'application/json': { schema: { $ref: '#/components/schemas/Error' } } },
+          },
+        },
+      },
+    },
+    '/api/admin/tables': {
+      get: {
+        summary: 'List database tables (admin)',
+        description:
+          'Every user table as [{ name }] in name order, excluding SQLite internals. Requires a valid X-Flight-Session of an ADMIN user — 401 without a live session, 403 for non-admins.',
+        operationId: 'listAdminTables',
+        responses: {
+          200: {
+            description: 'The table names',
+            content: {
+              'application/json': {
+                schema: { type: 'array', items: { $ref: '#/components/schemas/AdminTable' } },
+              },
+            },
+          },
+          401: {
+            description: 'Missing, unknown or expired session',
+            content: { 'application/json': { schema: { $ref: '#/components/schemas/Error' } } },
+          },
+          403: {
+            description: 'Valid session but the user is not an admin',
+            content: { 'application/json': { schema: { $ref: '#/components/schemas/Error' } } },
+          },
+        },
+      },
+    },
+    '/api/admin/tables/{name}/rows': {
+      get: {
+        summary: 'Read table rows (admin)',
+        description:
+          'Column headers + up to `limit` rows of the named table (default 500, cap 1000). rowid is exposed as __rowid so the PK-less tables (account, sim_state) are editable like any other. Table names are validated against sqlite_master and values are always bound as parameters.',
+        operationId: 'listAdminRows',
+        parameters: [
+          { name: 'name', in: 'path', required: true, schema: { type: 'string' } },
+          { name: 'limit', in: 'query', required: false, schema: { type: 'integer', minimum: 1, maximum: 1000 } },
+        ],
+        responses: {
+          200: {
+            description: 'Column headers + rows (each row carries its __rowid)',
+            content: { 'application/json': { schema: { $ref: '#/components/schemas/AdminRowsResponse' } } },
+          },
+          400: {
+            description: 'limit is not a positive integer',
+            content: { 'application/json': { schema: { $ref: '#/components/schemas/Error' } } },
+          },
+          401: {
+            description: 'Missing, unknown or expired session',
+            content: { 'application/json': { schema: { $ref: '#/components/schemas/Error' } } },
+          },
+          403: {
+            description: 'Valid session but the user is not an admin',
+            content: { 'application/json': { schema: { $ref: '#/components/schemas/Error' } } },
+          },
+          404: {
+            description: 'Unknown table name',
+            content: { 'application/json': { schema: { $ref: '#/components/schemas/Error' } } },
+          },
+        },
+      },
+      put: {
+        summary: 'Update a row (admin)',
+        description:
+          'Body { rowid, values }: update only the given columns of that row. Column names are validated against PRAGMA table_info; values are always bound as parameters.',
+        operationId: 'updateAdminRow',
+        parameters: [{ name: 'name', in: 'path', required: true, schema: { type: 'string' } }],
+        requestBody: {
+          required: true,
+          content: {
+            'application/json': {
+              schema: { $ref: '#/components/schemas/UpdateRowRequest' },
+            },
+          },
+        },
+        responses: {
+          200: {
+            description: 'Updated',
+            content: { 'application/json': { schema: { $ref: '#/components/schemas/OkResponse' } } },
+          },
+          400: {
+            description: 'Invalid body, non-integer rowid, unknown column, or empty values',
+            content: { 'application/json': { schema: { $ref: '#/components/schemas/Error' } } },
+          },
+          401: {
+            description: 'Missing, unknown or expired session',
+            content: { 'application/json': { schema: { $ref: '#/components/schemas/Error' } } },
+          },
+          403: {
+            description: 'Valid session but the user is not an admin',
+            content: { 'application/json': { schema: { $ref: '#/components/schemas/Error' } } },
+          },
+          404: {
+            description: 'Unknown table name',
+            content: { 'application/json': { schema: { $ref: '#/components/schemas/Error' } } },
+          },
+        },
+      },
+      post: {
+        summary: 'Insert a row (admin)',
+        description:
+          'Body { values }: insert a new row with exactly the given columns (others take their defaults or NULL). Returns the new rowid.',
+        operationId: 'insertAdminRow',
+        parameters: [{ name: 'name', in: 'path', required: true, schema: { type: 'string' } }],
+        requestBody: {
+          required: true,
+          content: {
+            'application/json': {
+              schema: { $ref: '#/components/schemas/InsertRowRequest' },
+            },
+          },
+        },
+        responses: {
+          200: {
+            description: 'Inserted — the new rowid',
+            content: { 'application/json': { schema: { $ref: '#/components/schemas/InsertRowResponse' } } },
+          },
+          400: {
+            description: 'Invalid body, unknown column, or empty values',
+            content: { 'application/json': { schema: { $ref: '#/components/schemas/Error' } } },
+          },
+          401: {
+            description: 'Missing, unknown or expired session',
+            content: { 'application/json': { schema: { $ref: '#/components/schemas/Error' } } },
+          },
+          403: {
+            description: 'Valid session but the user is not an admin',
+            content: { 'application/json': { schema: { $ref: '#/components/schemas/Error' } } },
+          },
+          404: {
+            description: 'Unknown table name',
+            content: { 'application/json': { schema: { $ref: '#/components/schemas/Error' } } },
+          },
+          409: {
+            description: 'Database constraint violation (NOT NULL / UNIQUE)',
+            content: { 'application/json': { schema: { $ref: '#/components/schemas/Error' } } },
+          },
+        },
+      },
+      delete: {
+        summary: 'Delete a row (admin)',
+        description:
+          'Query parameter rowid=N deletes that one row. Idempotent — deleting a non-existent rowid is still 200.',
+        operationId: 'deleteAdminRow',
+        parameters: [
+          { name: 'name', in: 'path', required: true, schema: { type: 'string' } },
+          { name: 'rowid', in: 'query', required: true, schema: { type: 'integer' } },
+        ],
+        responses: {
+          200: {
+            description: 'Deleted (or was already gone)',
+            content: { 'application/json': { schema: { $ref: '#/components/schemas/OkResponse' } } },
+          },
+          400: {
+            description: 'Missing or non-integer rowid query parameter',
+            content: { 'application/json': { schema: { $ref: '#/components/schemas/Error' } } },
+          },
+          401: {
+            description: 'Missing, unknown or expired session',
+            content: { 'application/json': { schema: { $ref: '#/components/schemas/Error' } } },
+          },
+          403: {
+            description: 'Valid session but the user is not an admin',
+            content: { 'application/json': { schema: { $ref: '#/components/schemas/Error' } } },
+          },
+          404: {
+            description: 'Unknown table name',
+            content: { 'application/json': { schema: { $ref: '#/components/schemas/Error' } } },
+          },
+        },
+      },
+    },
   },
   components: {
     schemas: {
@@ -493,24 +687,9 @@ export const openApiSpec = {
       SimState: {
         type: 'object',
         properties: {
-          clockMs: { type: 'integer', description: 'Sim-clock epoch ms (game time)' },
+          clockMs: { type: 'integer', description: 'Sim-clock epoch ms (game time). The world runs at a fixed rate with no player-facing controls (v0.52.0, ISS-117).' },
-          timeScale: { type: 'number', minimum: 1, maximum: 1000 },
-          paused: { type: 'boolean' },
-        },
-        required: ['clockMs', 'timeScale', 'paused'],
-      },
-      SimControlsRequest: {
-        type: 'object',
-        description: 'Partial update — omit a field to leave it unchanged.',
-        properties: {
-          timeScale: {
-            type: 'number',
-            minimum: 1,
-            maximum: 1000,
-            description: 'Game-time multiplier; values outside [1, 1000] are clamped. The UI offers the ladder 1/2/5/10/25/50/100/250/500/1000.',
-          },
-          paused: { type: 'boolean' },
         },
+        required: ['clockMs'],
       },
       LoadPackageRequest: {
         type: 'object',
@@ -554,6 +733,92 @@ export const openApiSpec = {
         },
         required: ['planeId'],
       },
+      // v0.71.0 — admin panel auth + DB tooling schemas.
+      LoginRequest: {
+        type: 'object',
+        properties: {
+          username: { type: 'string', description: 'Account username (non-empty).' },
+          password: { type: 'string', description: 'Plaintext password — verified server-side with scrypt, never stored.' },
+        },
+        required: ['username', 'password'],
+      },
+      SessionUser: {
+        type: 'object',
+        properties: {
+          username: { type: 'string' },
+          admin: { type: 'boolean', description: 'Whether this account may use the /api/admin/* endpoints.' },
+        },
+        required: ['username', 'admin'],
+      },
+      LoginResponse: {
+        type: 'object',
+        properties: {
+          sessionId: { type: 'string', description: 'Opaque session id — store it and send it back as the X-Flight-Session header. Valid 7 days.' },
+          user: { $ref: '#/components/schemas/SessionUser' },
+        },
+        required: ['sessionId', 'user'],
+      },
+      OkResponse: {
+        type: 'object',
+        properties: {
+          ok: { const: true },
+        },
+        required: ['ok'],
+      },
+      AdminTable: {
+        type: 'object',
+        properties: {
+          name: { type: 'string', description: 'SQLite table name (sqlite_% internals excluded).' },
+        },
+        required: ['name'],
+      },
+      AdminRowsResponse: {
+        type: 'object',
+        properties: {
+          columns: {
+            type: 'array',
+            items: { type: 'string' },
+            description: 'Column names; the first entry is always __rowid (the rowid pseudo-column).',
+          },
+          rows: {
+            type: 'array',
+            items: { type: 'object', additionalProperties: true },
+            description: 'Up to `limit` rows, each keyed by column name including __rowid.',
+          },
+        },
+        required: ['columns', 'rows'],
+      },
+      UpdateRowRequest: {
+        type: 'object',
+        properties: {
+          rowid: { type: 'integer', description: 'The __rowid of the row to update.' },
+          values: {
+            type: 'object',
+            additionalProperties: true,
+            description: 'Only the columns to change (validated against PRAGMA table_info); others are untouched.',
+          },
+        },
+        required: ['rowid', 'values'],
+      },
+      InsertRowRequest: {
+        type: 'object',
+        properties: {
+          values: {
+            type: 'object',
+            additionalProperties: true,
+            description: 'Exactly the columns to set; others take their defaults or NULL.',
+          },
+        },
+        required: ['values'],
+      },
+      InsertRowResponse: {
+        type: 'object',
+        properties: {
+          ok: { const: true },
+          rowid: { type: 'integer', description: 'The __rowid of the inserted row.' },
+        },
+        required: ['ok', 'rowid'],
+      },
       Error: {
         type: 'object',
         properties: {
@@ -594,7 +859,7 @@ export const openApiSpec = {
           health: {
             type: 'number',
             description:
-              'Structural health in [0, 100] (v0.39.0) — wears down by a fixed amount per km of landed legs; at 0 the plane is broken and burns 50% more fuel until repaired.',
+              'Structural health in [0, 100] (v0.39.0) — wears down by a fixed amount per km of landed legs; at 0 the plane is broken and cannot fly until repaired (v0.45.0). While "repairing" this doubles as repair progress: it climbs back to 100 over the repair duration.',
           },
           repairUntilSimTime: {
             type: ['integer', 'null'],
@@ -633,13 +898,14 @@ export const openApiSpec = {
           cargoCount: { type: 'integer' },
           weightKg: { type: 'number', description: 'Package weight in kg (v0.27.0) — drives load validation and the per-kg payout part.' },
           special: { type: ['string', 'null'], description: 'Special status from the specials registry (v0.37.0); null = none.' },
+          distanceKm: { type: 'number', description: 'Great-circle leg distance in km (v0.48.0) — computed server-side from airport coordinates, not stored.' },
           deadlineSimTime: { type: 'integer', description: 'Sim-clock epoch ms (game time)' },
           // 'expired' = an open OR loaded package whose deadline passed on a tick;
           // loaded expired packages keep their slot, deliver no reward, abandon free.
-          // 'ignored' (v0.29.0, ISS-047 part B) = a dismissed open job — terminal, leaves the market.
+          status: { enum: ['open', 'loaded', 'delivered', 'expired', 'abandoned'] },
-          status: { enum: ['open', 'loaded', 'delivered', 'expired', 'abandoned', 'ignored'] },
           planeId: { type: ['string', 'null'] },
           createdSimTime: { type: 'integer' },
+          expiresRealMs: { type: ['integer', 'null'], description: 'Wall-clock epoch ms when an OPEN job expires (v0.65.0) — createdRealMs + lifetime; null for every non-open status.' },
         },
         required: [
           'id',
@@ -651,10 +917,12 @@ export const openApiSpec = {
           'cargoType',
           'cargoCount',
           'weightKg', // v0.27.0 (ISS-045) — package weight in kg
+          'distanceKm', // v0.48.0 (ISS-095) — great-circle leg distance in km
           'deadlineSimTime',
           'status',
           'planeId',
           'createdSimTime',
+          'expiresRealMs', // v0.65.0 — wall-clock expiry of open jobs; null otherwise
         ],
       },
     },

lib/sim/engine.test.ts

@@ -8,28 +8,36 @@ import * as schema from '@/lib/db/schema';
 import { loadAirportsGeoJson } from '@/lib/airports';
 import { haversineKm, initialBearingDeg } from '@/lib/geo';
 import { weatherFor } from '@/lib/weather';
-import { BROKEN_BURN_MULTIPLIER, conditionBurnMultiplier, FUEL_DISCOUNT_PER_REP, FUEL_PRICE_PER_L, MAX_FUEL_DISCOUNT, PLANE_TYPES, repRate, WEAR_PER_KM } from '@/lib/game/catalog';
+import { FUEL_DISCOUNT_PER_REP, FUEL_PRICE_PER_L, MAX_FUEL_DISCOUNT, PLANE_TYPES, REPAIR_DURATION_MS, repRate, WEAR_PER_KM } from '@/lib/game/catalog';
 import { SPECIALS } from '@/lib/game/specials';
-import { MARKET_TARGET_OPEN_PACKAGES, mulberry32 } from '@/lib/game/seed';
+import { JOB_LIFETIME_MS, POOL_BANDS, POOL_TARGET_PER_AIRPORT, REFILL_DELAY_MS, SMALL_REFILL_DELAY_MS, mulberry32, poolBandOf, STARTING_CLOCK_MS } from '@/lib/game/seed';
 import { arrivalTimeFor, fuelAtWeighted, requiredFuelFor, windBurnFactor } from './movement';
 import {
-  clampTimeScale,
   deliverPackages,
-  expirePackages,
+  expireLoadedPackages,
+  expireOpenPackages,
   finishRepairs,
   MAX_TICK_ELAPSED_MS,
-  MAX_TIME_SCALE,
-  MIN_TIME_SCALE,
   reputationGainFor,
-  spawnCoveragePackages,
+  shouldAdvanceTime,
-  spawnOpenPackages,
+  spawnPoolPackages,
   tickOnce,
+  WORLD_TIME_SCALE,
 } from './engine';
 
 // Engine tests run against throwaway DB files (openGameDb) with fake timers so
 // Date.now() — the only wall-clock input to a tick — is fully controlled. The
-// public tickNow()/applyTimeControls() wrappers (singleton + lock) are covered
+// public tickNow()/setTestTimeScale() wrappers (singleton + lock) are covered by the e2e suite
-// by app/api/sim/route.test.ts and the e2e suite.
+// (every spec's setScale helper hits /api/test/set-timescale; sim.spec.ts pins its validation).
+
+// #135: fresh DBs seed a GROUNDED starter, so any test that needs clock advance must put a plane in
+// flight first (a fully grounded fleet freezes the world) — departureSimTime at the game-clock
+// origin keeps its arrival hours away.
+async function makeWorldActive(inst: Awaited<ReturnType<typeof openGameDb>>) {
+  await inst.db.update(schema.planes)
+    .set({ status: 'flying', destIcao: 'LEMD', departureSimTime: STARTING_CLOCK_MS })
+    .where(eq(schema.planes.id, 'plane-starter'));
+}
 
 let dir: string;
 const T0 = 1_750_000_000_000; // seed moment / fake "now" at DB open
@@ -37,11 +45,15 @@ const T0 = 1_750_000_000_000; // seed moment / fake "now" at DB open
 beforeAll(async () => {
   vi.useFakeTimers();
   vi.setSystemTime(T0);
+  // #135 (v0.62.0): this file exercises the FLIGHT_TEST_HOOKS branch of tickOnce — stored
+  // sim.timeScale overrides are only honored when the env var is set, exactly like CI.
+  vi.stubEnv('FLIGHT_TEST_HOOKS', '1');
   dir = await fs.mkdtemp(path.join(os.tmpdir(), 'flight-sim-'));
 });
 
 afterAll(async () => {
   vi.useRealTimers();
+  vi.unstubAllEnvs();
   await fs.rm(dir, { recursive: true, force: true });
 });
 
@@ -53,43 +65,74 @@ async function freshDb(name: string) {
 describe('tickOnce — clock advance', () => {
   it('advances the clock by elapsed real ms × timeScale', async () => {
     const inst = await freshDb('scale.db');
+    await makeWorldActive(inst); // a fully grounded fleet freezes the clock (#135)
     vi.setSystemTime(T0 + 1_000); // one real second later
     await inst.db.update(schema.simState).set({ timeScale: 5 });
 
     const sim = await tickOnce(inst);
 
-    expect(sim.clockMs).toBe(T0 + 5_000); // 1 s × 5
+    expect(sim.clockMs).toBe(STARTING_CLOCK_MS + 5_000); // 1 s × 5
     expect(sim.lastRealTickMs).toBe(T0 + 1_000);
   });
 
-  it('freezes the clock while paused but keeps tracking real time', async () => {
+  it('production (no FLIGHT_TEST_HOOKS): a legacy stored timeScale is ignored — always WORLD_TIME_SCALE (#135)', async () => {
-    const inst = await freshDb('pause.db');
+    const inst = await freshDb('prod-rate.db');
-    await inst.db.update(schema.simState).set({ paused: true, timeScale: 60 });
+    await makeWorldActive(inst);
+    await inst.db.update(schema.simState).set({ timeScale: 1_000 }); // what a pre-v0.52.0 save holds
 
-    vi.setSystemTime(T0 + 3_600_000); // an hour of real pause
+    vi.setSystemTime(T0 + 1_000);
+    const saved = process.env.FLIGHT_TEST_HOOKS;
+    delete process.env.FLIGHT_TEST_HOOKS;
+    let sim: schema.SimStateRow;
+    try {
+      sim = await tickOnce(inst);
+    } finally {
+      if (saved !== undefined) process.env.FLIGHT_TEST_HOOKS = saved; // restore the stubbed value
+    }
+
+    expect(sim.clockMs).toBe(STARTING_CLOCK_MS + 1_000 * WORLD_TIME_SCALE); // ×24, NOT ×1000
+  });
+
+  it('a fully grounded fleet freezes the clock, then resumes with no catch-up (#135)', async () => {
+    const inst = await freshDb('idle.db'); // seeded starter is on the ground → frozen
+
+    vi.setSystemTime(T0 + 3_600_000); // an hour of real idleness
     let sim = await tickOnce(inst);
-    expect(sim.clockMs).toBe(T0); // frozen — no advance at all
+    expect(sim.clockMs).toBe(STARTING_CLOCK_MS); // frozen — no fast-forward, no idle creep
     expect(sim.lastRealTickMs).toBe(T0 + 3_600_000);
 
-    // Unpause: resumes from where it stopped, with NO catch-up for the pause.
+    // A plane takes off: resumes from where it stopped, with NO catch-up for the frozen time.
-    await inst.db.update(schema.simState).set({ paused: false });
+    await inst.db.update(schema.simState).set({ timeScale: 60 });
+    await makeWorldActive(inst);
     vi.setSystemTime(T0 + 3_600_500);
     sim = await tickOnce(inst);
-    expect(sim.clockMs).toBe(T0 + 500 * 60); // only the 500 ms since unpausing × 60
+    expect(sim.clockMs).toBe(STARTING_CLOCK_MS + 500 * 60); // only the 500 ms since activity × 60
+  });
+
+  it('a grounded fleet ignores any raised timeScale — frozen regardless (#135)', async () => {
+    const inst = await freshDb('idle-scale.db');
+    await inst.db.update(schema.simState).set({ timeScale: 1_000 }); // FLIGHT_TEST_HOOKS-style override
+
+    vi.setSystemTime(T0 + 1_000);
+    const sim = await tickOnce(inst);
+
+    expect(sim.clockMs).toBe(STARTING_CLOCK_MS); // frozen, NOT ×1000
   });
 
   it('clamps long absences: a 1-hour gap advances at most MAX_TICK_ELAPSED_MS × scale', async () => {
     const inst = await freshDb('clamp.db');
+    await makeWorldActive(inst);
     vi.setSystemTime(T0 + 3_600_000); // server sat idle for an hour
 
-    const sim = await tickOnce(inst); // timeScale is the seeded 1
+    const sim = await tickOnce(inst); // timeScale is the seeded WORLD_TIME_SCALE
 
-    expect(sim.clockMs).toBe(T0 + MAX_TICK_ELAPSED_MS); // exactly one clamped tick, not a fast-forward
+    expect(sim.clockMs).toBe(STARTING_CLOCK_MS + MAX_TICK_ELAPSED_MS * WORLD_TIME_SCALE); // exactly one clamped tick, not a fast-forward
     vi.setSystemTime(T0); // reset for later tests in this file
   });
 
   it('does not advance when two ticks land in the same millisecond', async () => {
     const inst = await freshDb('same-ms.db');
+    await makeWorldActive(inst);
     vi.setSystemTime(T0 + 1_000);
     const a = await tickOnce(inst);
     const b = await tickOnce(inst); // no real time passed since `a`
@@ -97,39 +140,68 @@ describe('tickOnce — clock advance', () => {
   });
 });
 
-describe('expirePackages', () => {
+describe('expireLoadedPackages (sim clock)', () => {
-  it('flips open AND loaded packages past their deadline; terminal statuses never expire', async () => {
+  it('flips loaded packages past their sim deadline; terminal statuses never expire', async () => {
-    const inst = await freshDb('expiry.db');
+    const inst = await freshDb('expiry-loaded.db');
-    const clock = T0 + 100_000;
+    // Game-clock anchor just after the seed moment — well inside every seeded package's deadline
+    // window (DEADLINE_MIN_HOURS), so only the rows inserted below can expire.
+    const clock = STARTING_CLOCK_MS + 100_000;
 
     await inst.db.insert(schema.packages).values([
-      { id: 'p-open-past', originIcao: 'EDDF', destIcao: 'LEMD', reward: 1, cargoType: 'Mail', cargoCount: 1, deadlineSimTime: clock - 1, status: 'open', planeId: null, createdSimTime: T0 },
+      { id: 'p-loaded-past', originIcao: 'EDDF', destIcao: 'LEMD', reward: 1, cargoType: 'Mail', cargoCount: 1, deadlineSimTime: clock - 1, status: 'loaded', planeId: 'plane-starter', createdSimTime: STARTING_CLOCK_MS },
-      { id: 'p-open-future', originIcao: 'EDDF', destIcao: 'LEMD', reward: 1, cargoType: 'Mail', cargoCount: 1, deadlineSimTime: clock + 1, status: 'open', planeId: null, createdSimTime: T0 },
+      { id: 'p-loaded-future', originIcao: 'EDDF', destIcao: 'LEMD', reward: 1, cargoType: 'Mail', cargoCount: 1, deadlineSimTime: clock + 1, status: 'loaded', planeId: 'plane-starter', createdSimTime: STARTING_CLOCK_MS },
-      { id: 'p-loaded-past', originIcao: 'EDDF', destIcao: 'LEMD', reward: 1, cargoType: 'Mail', cargoCount: 1, deadlineSimTime: clock - 1, status: 'loaded', planeId: 'plane-starter', createdSimTime: T0 },
+      { id: 'p-delivered-past', originIcao: 'EDDF', destIcao: 'LEMD', reward: 1, cargoType: 'Mail', cargoCount: 1, deadlineSimTime: clock - 1, status: 'delivered', planeId: null, createdSimTime: STARTING_CLOCK_MS },
-      { id: 'p-delivered-past', originIcao: 'EDDF', destIcao: 'LEMD', reward: 1, cargoType: 'Mail', cargoCount: 1, deadlineSimTime: clock - 1, status: 'delivered', planeId: null, createdSimTime: T0 },
+      { id: 'p-abandoned-past', originIcao: 'EDDF', destIcao: 'LEMD', reward: 1, cargoType: 'Mail', cargoCount: 1, deadlineSimTime: clock - 1, status: 'abandoned', planeId: null, createdSimTime: STARTING_CLOCK_MS },
-      { id: 'p-abandoned-past', originIcao: 'EDDF', destIcao: 'LEMD', reward: 1, cargoType: 'Mail', cargoCount: 1, deadlineSimTime: clock - 1, status: 'abandoned', planeId: null, createdSimTime: T0 },
-      { id: 'p-ignored-past', originIcao: 'EDDF', destIcao: 'LEMD', reward: 1, cargoType: 'Mail', cargoCount: 1, deadlineSimTime: clock - 1, status: 'ignored', planeId: null, createdSimTime: T0 },
     ]);
 
-    const n = await expirePackages(inst, clock);
+    const n = await expireLoadedPackages(inst, clock);
-    expect(n).toBe(2); // the open and the loaded one
+    expect(n).toBe(1); // only the loaded one — open jobs live on the wall clock now (v0.65.0)
 
     const byId = new Map((await inst.db.select().from(schema.packages)).map((p) => [p.id, p.status]));
-    expect(byId.get('p-open-past')).toBe('expired');
-    expect(byId.get('p-open-future')).toBe('open'); // deadline not reached yet
     expect(byId.get('p-loaded-past')).toBe('expired'); // v0.12.0: loaded packages expire too (keep their slot)
+    expect(byId.get('p-loaded-future')).toBe('loaded'); // deadline not reached yet
     expect(byId.get('p-delivered-past')).toBe('delivered'); // terminal — never flips
     expect(byId.get('p-abandoned-past')).toBe('abandoned'); // terminal — never flips
-    expect(byId.get('p-ignored-past')).toBe('ignored'); // v0.29.0 (ISS-047 part B) — terminal, never flips
   });
 
   it('a deadline exactly at the clock counts as expired', async () => {
-    const inst = await freshDb('expiry-edge.db');
+    const inst = await freshDb('expiry-loaded-edge.db');
     await inst.db.insert(schema.packages).values({
       id: 'p-edge', originIcao: 'EDDF', destIcao: 'LEMD', reward: 1, cargoType: 'Mail', cargoCount: 1,
-      deadlineSimTime: T0 + 50_000, status: 'open', planeId: null, createdSimTime: T0,
+      deadlineSimTime: STARTING_CLOCK_MS + 50_000, status: 'loaded', planeId: 'plane-starter', createdSimTime: STARTING_CLOCK_MS,
     });
-    expect(await expirePackages(inst, T0 + 50_000)).toBe(1); // <= is inclusive
+    expect(await expireLoadedPackages(inst, STARTING_CLOCK_MS + 50_000)).toBe(1); // <= is inclusive
+  });
+});
+
+describe('expireOpenPackages (v0.65.0 wall clock)', () => {
+  it('flips open packages past their real-time lifetime; fresh ones and terminal statuses never', async () => {
+    const inst = await freshDb('expiry-open.db');
+    // T0 is the fake Date.now() at DB open — seeded rows carry createdRealMs = T0, so they are FRESH
+    // (a full JOB_LIFETIME_MS away) and only the aged row below can expire.
+    await inst.db.insert(schema.packages).values([
+      { id: 'p-open-aged', originIcao: 'EDDF', destIcao: 'LEMD', reward: 1, cargoType: 'Mail', cargoCount: 1, deadlineSimTime: STARTING_CLOCK_MS + 3_600_000, status: 'open', planeId: null, createdSimTime: STARTING_CLOCK_MS, createdRealMs: T0 - JOB_LIFETIME_MS - 1 },
+      { id: 'p-open-fresh', originIcao: 'EDDF', destIcao: 'LEMD', reward: 1, cargoType: 'Mail', cargoCount: 1, deadlineSimTime: STARTING_CLOCK_MS + 3_600_000, status: 'open', planeId: null, createdSimTime: STARTING_CLOCK_MS, createdRealMs: T0 },
+      { id: 'p-delivered-aged', originIcao: 'EDDF', destIcao: 'LEMD', reward: 1, cargoType: 'Mail', cargoCount: 1, deadlineSimTime: STARTING_CLOCK_MS + 3_600_000, status: 'delivered', planeId: null, createdSimTime: STARTING_CLOCK_MS, createdRealMs: T0 - JOB_LIFETIME_MS - 1 },
+    ]);
+
+    const n = await expireOpenPackages(inst, T0);
+    expect(n).toBe(1); // only the aged open one — loaded jobs are sim-clock territory now
+
+    const byId = new Map((await inst.db.select().from(schema.packages)).map((p) => [p.id, p.status]));
+    expect(byId.get('p-open-aged')).toBe('expired');
+    expect(byId.get('p-open-fresh')).toBe('open'); // lifetime not reached yet
+    expect(byId.get('p-delivered-aged')).toBe('delivered'); // terminal — never flips
+  });
+
+  it('a lifetime exactly at the clock counts as expired', async () => {
+    const inst = await freshDb('expiry-open-edge.db');
+    await inst.db.insert(schema.packages).values({
+      id: 'p-edge', originIcao: 'EDDF', destIcao: 'LEMD', reward: 1, cargoType: 'Mail', cargoCount: 1,
+      deadlineSimTime: STARTING_CLOCK_MS + 50_000, status: 'open', planeId: null, createdSimTime: STARTING_CLOCK_MS,
+      createdRealMs: T0 - JOB_LIFETIME_MS,
+    });
+    expect(await expireOpenPackages(inst, T0)).toBe(1); // <= is inclusive
   });
 });
 
@@ -313,17 +385,16 @@ describe('deliverPackages (v0.12.0 arrival delivery)', () => {
     const clock = T0 + travelMs(km, type.speedKmh); // exactly at arrival
     expect(await deliverPackages(inst, clock)).toBe(1);
 
-    // Expected top-up from the SAME helpers the engine uses: landed fuel (≈ 0), post-wear health,
+    // Expected top-up from the SAME helpers the engine uses: landed fuel (≈ 0), wind-adjusted
-    // wind-adjusted requirement for LEMD→EHAM, ×1.5 margin capped at tank capacity.
+    // requirement for LEMD→EHAM, ×1.5 margin capped at tank capacity.
     const fc = await loadAirportsGeoJson();
     const nextP = fc.features.find((x) => x.properties.icao === 'EHAM')!.properties;
     const landedFuel = fuelAtWeighted(depFuel, type.burnPerKm * f, type.emptyWeightKg, type.maxFuel, km, 1);
     expect(landedFuel).toBeCloseTo(0, 6); // sanity: arrived empty — the top-up path is what ran
-    const newHealth = Math.max(0, 100 - WEAR_PER_KM * km);
     const wTo = weatherFor(TO); // the chained leg departs from the arrival airport
     const fNext = windBurnFactor(wTo.windKt, wTo.windDirDeg, initialBearingDeg(to.lat, to.lon, nextP.lat, nextP.lon));
     const nextRequiredL = requiredFuelFor(
-      type.burnPerKm * fNext * conditionBurnMultiplier(newHealth),
+      type.burnPerKm * fNext,
       type.emptyWeightKg,
       type.maxFuel,
       haversineKm(to.lat, to.lon, nextP.lat, nextP.lon),
@@ -379,9 +450,55 @@ describe('deliverPackages (v0.12.0 arrival delivery)', () => {
     expect(plane.status).toBe('available'); // unchanged landing behavior…
     expect(JSON.parse(plane.queue)).toEqual([]); // …and the queue stays empty
   });
+
+  it('grounds with the queue intact when the next leg does not fit even a full tank (v0.46.0 backstop)', async () => {
+    const { inst, to, km, type } = await setupFlight('chain-nofit.db'); // full tank EDDF→LEMD
+    const fc = await loadAirportsGeoJson();
+    const farP = fc.features.find((f) => f.properties.icao === 'FGSL')!.properties; // ~4267 km from LEMD — beyond ATR range
+
+    // Precondition sanity: the LEMD→FGSL hop genuinely does not fit a full tank (wind-adjusted,
+    // exactly as deliverPackages computes it) — so no top-up could ever make it flyable.
+    const wTo = weatherFor(TO);
+    const fNext = windBurnFactor(wTo.windKt, wTo.windDirDeg, initialBearingDeg(to.lat, to.lon, farP.lat, farP.lon));
+    const nextRequiredL = requiredFuelFor(
+      type.burnPerKm * fNext,
+      type.emptyWeightKg,
+      type.maxFuel,
+      haversineKm(to.lat, to.lon, farP.lat, farP.lon),
+    );
+    expect(nextRequiredL).toBeGreaterThan(type.maxFuel);
+
+    await inst.db.update(schema.planes)
+      .set({ queue: JSON.stringify(['FGSL']) })
+      .where(eq(schema.planes.id, 'plane-starter'));
+
+    const clock = T0 + travelMs(km, type.speedKmh); // exactly at arrival
+    expect(await deliverPackages(inst, clock)).toBe(1);
+
+    const plane = (await inst.db.select().from(schema.planes))[0];
+    expect(plane.status).toBe('available'); // grounded — the unflyable leg was NOT chained…
+    expect(plane.destIcao).toBeNull();
+    expect(JSON.parse(plane.queue)).toEqual(['FGSL']); // …queue kept intact for a later dispatch
   });
 
-describe('wear on landed legs + broken burn (v0.39.0, ISS-069)', () => {
+  it('drops a queued leg to the arrival airport without flying — defensive guard for legacy rows (v0.46.0)', async () => {
+    const { inst, km, type } = await setupFlight('chain-selfleg.db'); // full tank EDDF→LEMD
+    // Legacy state: queue[0] is the airport we are about to land at — pre-v0.46.0 this chained a
+    // zero-distance self-hop (the phantom hop). The guard drops it and grounds instead.
+    await inst.db.update(schema.planes)
+      .set({ queue: JSON.stringify(['LEMD', 'EHAM']) })
+      .where(eq(schema.planes.id, 'plane-starter'));
+
+    expect(await deliverPackages(inst, T0 + travelMs(km, type.speedKmh))).toBe(1);
+
+    const plane = (await inst.db.select().from(schema.planes))[0];
+    expect(plane.status).toBe('available'); // grounded — the self-leg was dropped, not flown…
+    expect(plane.destIcao).toBeNull();
+    expect(JSON.parse(plane.queue)).toEqual(['EHAM']); // …the rest of the queue kept for a later dispatch
+  });
+});
+
+describe('wear on landed legs (v0.39.0, ISS-069)', () => {
   const FROM = 'EDDF';
   const TO = 'LEMD';
 
@@ -433,27 +550,22 @@ describe('wear on landed legs + broken burn (v0.39.0, ISS-069)', () => {
     expect(plane.health).toBe(0); // still clamped after the second leg
   });
 
-  it('a broken plane burns ×1.5 more fuel on the leg (landed fuel)', async () => {
+  it('a plane that lands broken does NOT chain — grounded with the queue intact (v0.45.0, ISS-089)', async () => {
-    const { inst, from, to, km, type } = await setupFlight('wear-broken.db');
+    const { inst, km, type } = await setupFlight('wear-broken-nochain.db'); // full tank EDDF→LEMD
-    await inst.db.update(schema.planes).set({ health: 0 }).where(eq(schema.planes.id, 'plane-starter'));
+    // Start below one leg's wear so this landing clamps health to 0 — a full-tank departure leaves
+    // enough fuel for the queued LEMD→EHAM hop (same precondition as chain-ok), so ONLY the broken
+    // guard can explain why it doesn't chain.
+    await inst.db.update(schema.planes)
+      .set({ health: WEAR_PER_KM * km / 2, queue: JSON.stringify(['EHAM']) })
+      .where(eq(schema.planes.id, 'plane-starter'));
 
     expect(await deliverPackages(inst, T0 + travelMs(km, type.speedKmh))).toBe(1);
 
-    const w = weatherFor(FROM);
-    const f = windBurnFactor(w.windKt, w.windDirDeg, initialBearingDeg(from.lat, from.lon, to.lat, to.lon));
     const plane = (await inst.db.select().from(schema.planes))[0];
-    // The ×1.5-adjusted closed form — the same factor livePlane() shows in flight…
+    expect(plane.health).toBe(0); // broken by this landing's wear…
-    expect(plane.fuel).toBeCloseTo(
+    expect(plane.status).toBe('available'); // …grounded — the chain was skipped despite enough fuel…
-      fuelAtWeighted(type.maxFuel, type.burnPerKm * f * BROKEN_BURN_MULTIPLIER, type.emptyWeightKg, type.maxFuel, km, 1),
+    expect(plane.destIcao).toBeNull();
-      6,
+    expect(JSON.parse(plane.queue)).toEqual(['EHAM']); // …queue kept intact for a later dispatch
-    );
-
-    // …and strictly less than the healthy control on the identical leg.
-    const control = await setupFlight('wear-broken-control.db');
-    expect(await deliverPackages(control.inst, T0 + travelMs(km, type.speedKmh))).toBe(1);
-    const healthy = (await control.inst.db.select().from(schema.planes))[0];
-    expect(healthy.fuel).toBeCloseTo(fuelAtWeighted(type.maxFuel, type.burnPerKm * f, type.emptyWeightKg, type.maxFuel, km, 1), 6);
-    expect(plane.fuel).toBeLessThan(healthy.fuel); // the broken plane genuinely burned more
   });
 });
 
@@ -476,120 +588,111 @@ describe('finishRepairs (v0.39.0, ISS-069)', () => {
 
   it('runs inside tickOnce even when nothing landed: a past gate flips the plane back', async () => {
     const inst = await freshDb('repair-tick.db');
+    // The repairing plane keeps the world advancing (ISS-117); scale pinned to 1 for clean math.
+    await inst.db.update(schema.simState).set({ timeScale: 1 });
     await inst.db.update(schema.planes)
-      .set({ status: 'repairing', repairUntilSimTime: T0 + 1_500 })
+      .set({ status: 'repairing', repairUntilSimTime: STARTING_CLOCK_MS + 1_500 })
       .where(eq(schema.planes.id, 'plane-starter'));
 
-    vi.setSystemTime(T0 + 2_000); // one clamped tick at scale 1 → clock T0+2000 ≥ gate; nothing is flying
+    vi.setSystemTime(T0 + 2_000); // one clamped tick at scale 1 → clock STARTING_CLOCK_MS+2000 ≥ gate
     await tickOnce(inst);
 
     const plane = (await inst.db.select().from(schema.planes))[0];
     expect(plane.status).toBe('available');
     expect(plane.repairUntilSimTime ?? null).toBeNull();
   });
-});
 
-describe('slow to 1× when a landing leaves any plane on the ground (ISS-057)', () => {
+  it('heals gradually along round(f × 100) while repairing; lands exactly on 100 + available at the gate (v0.45.0, ISS-089)', async () => {
-  const FROM = 'EDDF';
+    const inst = await freshDb('repair-curve.db');
-  const TO = 'LEMD';
+    // Repair started at T0 with health 42 — the gate is what repairPlane stores: start + duration.
-
+    const gate = T0 + REPAIR_DURATION_MS;
-  // Starter flying EDDF→LEMD with departureSimTime set so its arrival is EXACTLY T0 —
-  // any advancing tick past T0 finalizes it. timeScale is the value under test;
-  // lastSelectedTimeScale mirrors what a manual POST /api/sim would have stored.
-  async function setupLanding(name: string, timeScale: number) {
-    const inst = await freshDb(name);
-    const fc = await loadAirportsGeoJson();
-    const from = fc.features.find((f) => f.properties.icao === FROM)!.properties;
-    const to = fc.features.find((f) => f.properties.icao === TO)!.properties;
-    const km = haversineKm(from.lat, from.lon, to.lat, to.lon);
-    const type = PLANE_TYPES.atr72;
-
-    await inst.db.update(schema.simState).set({ timeScale, lastSelectedTimeScale: timeScale });
     await inst.db.update(schema.planes)
-      .set({ status: 'flying', destIcao: TO, departureSimTime: T0 - travelMs(km, type.speedKmh), fuel: type.maxFuel })
+      .set({ status: 'repairing', health: 42, repairUntilSimTime: gate })
       .where(eq(schema.planes.id, 'plane-starter'));
 
-    return { inst, from, km, type };
+    // Mid-repair (f = 0.5): the curve (round(50)) is above the start value → health climbs to 50…
+    expect(await finishRepairs(inst, T0 + REPAIR_DURATION_MS / 2)).toBe(0); // …but no flip before the gate…
+    let plane = (await inst.db.select().from(schema.planes))[0];
+    expect(plane.status).toBe('repairing');
+    expect(plane.health).toBe(50);
+
+    // …and it never DROPS below the start value: at f = 0.2 the curve (20) is below 42, so health stays put.
+    const inst2 = await freshDb('repair-curve-floor.db');
+    await inst2.db.update(schema.planes)
+      .set({ status: 'repairing', health: 42, repairUntilSimTime: gate })
+      .where(eq(schema.planes.id, 'plane-starter'));
+    expect(await finishRepairs(inst2, T0 + REPAIR_DURATION_MS / 5)).toBe(0);
+    const plane2 = (await inst2.db.select().from(schema.planes))[0];
+    expect(plane2.health).toBe(42); // max(p.health, round(f × 100)) — the start value is the floor
+
+    // At the gate: exactly 100 and back in service.
+    expect(await finishRepairs(inst, gate)).toBe(1);
+    plane = (await inst.db.select().from(schema.planes))[0];
+    expect(plane.status).toBe('available');
+    expect(plane.health).toBe(100);
+    expect(plane.repairUntilSimTime ?? null).toBeNull();
+  });
+});
+
+describe('grounded fleet freezes the world clock (#135)', () => {
+  it('pins WORLD_TIME_SCALE = 24 — the single fixed world rate (ISS-117)', () => {
+    expect(WORLD_TIME_SCALE).toBe(24);
+  });
+
+  it('shouldAdvanceTime: grounded/empty fleets are frozen; any flying or repairing plane advances', () => {
+    expect(shouldAdvanceTime([])).toEqual({ advance: false, flying: 0, repairing: 0 });
+    expect(shouldAdvanceTime([{ status: 'available' }, { status: 'available' }])).toEqual({ advance: false, flying: 0, repairing: 0 });
+    expect(shouldAdvanceTime([{ status: 'flying' }, { status: 'available' }])).toEqual({ advance: true, flying: 1, repairing: 0 });
+    expect(shouldAdvanceTime([{ status: 'repairing' }])).toEqual({ advance: true, flying: 0, repairing: 1 });
+    expect(shouldAdvanceTime([{ status: 'flying' }, { status: 'repairing' }])).toEqual({ advance: true, flying: 1, repairing: 1 });
+  });
+
+  it('a fully grounded fleet stays frozen but keeps tracking real time', async () => {
+    const inst = await freshDb('idle-pause.db'); // seeded starter is on the ground → frozen
+    vi.setSystemTime(T0 + 3_600_000);
+
+    const sim = await tickOnce(inst);
+
+    expect(sim.clockMs).toBe(STARTING_CLOCK_MS); // frozen — no idle creep
+    expect(sim.lastRealTickMs).toBe(T0 + 3_600_000); // …and the real-time anchor moved on
+  });
+
+  it('a repairing plane keeps the world advancing', async () => {
+    const inst = await freshDb('idle-repair.db');
+    await inst.db.update(schema.planes)
+      .set({ status: 'repairing', repairUntilSimTime: STARTING_CLOCK_MS + REPAIR_DURATION_MS })
+      .where(eq(schema.planes.id, 'plane-starter'));
+
+    vi.setSystemTime(T0 + 1_000);
+    const sim = await tickOnce(inst);
+
+    expect(sim.clockMs).toBeGreaterThan(STARTING_CLOCK_MS); // the repair gate is what keeps time moving
+  });
+
+  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).
+    // Direct status flip WITHOUT slotFreeAtRealMs, mirroring expireOpenPackages: models "slots are
+    // empty", not "taken" — a real load stamps the cooldown and would block this refill for REFILL_DELAY_MS.
+    for (const p of await inst.db.select().from(schema.packages)) {
+      if (p.status === 'open') {
+        await inst.db.update(schema.packages).set({ status: 'expired' }).where(eq(schema.packages.id, p.id));
+      }
     }
 
-  it('last plane lands → sim slows to 1× WITHOUT pausing; lastSelectedTimeScale is preserved', async () => {
+    vi.setSystemTime(T0 + 1_000); // a background tick while the fleet is grounded
-    const { inst } = await setupLanding('slow-last.db', 1000);
-    vi.setSystemTime(T0 + 2_000); // one full clamped tick at scale 1000 → clock T0+2e6 ≥ arrival (T0)
-
     const sim = await tickOnce(inst);
 
-    expect(sim.paused).toBe(false); // no pause anymore — ISS-057 replaces it with a slow-down…
+    expect(sim.clockMs).toBe(STARTING_CLOCK_MS); // freeze preserved…
-    expect((await inst.db.select().from(schema.simState))[0].paused).toBe(false); // …persisted on the row…
+    const openRows = (await inst.db.select().from(schema.packages)).filter((p) => p.status === 'open');
-    expect(sim.timeScale).toBe(1); // …slowed to the floor…
+    expect(openRows.length).toBe(POOL_TARGET_PER_AIRPORT); // …but the starter's pool is refilled to its full composition…
-    expect(sim.lastSelectedTimeScale).toBe(1000); // …with the last manual speed kept for resume
+    expect(openRows.every((p) => p.originIcao === 'EDDF')).toBe(true); // …all at the grounded starter's airport
-    expect((await inst.db.select().from(schema.planes))[0].status).toBe('available'); // landing itself unchanged
-  });
-
-  it('a landing while another plane is still flying → slows to 1× (any plane on ground)', async () => {
-    const { inst, from, type } = await setupLanding('slow-other.db', 1000);
-    // A second plane on the same route departing at T0 — arrives far after this tick's clock.
-    await inst.db.insert(schema.planes).values({
-      id: 'p-b', model: 'atr72', status: 'flying', fuel: type.maxFuel, maxFuel: type.maxFuel,
-      locationIcao: FROM, destIcao: TO, lat: from.lat, lon: from.lon, departureSimTime: T0,
-    });
-
-    vi.setSystemTime(T0 + 2_000);
-    const sim = await tickOnce(inst);
-
-    expect(sim.paused).toBe(false);
-    expect(sim.timeScale).toBe(1); // the just-landed starter is on ground → slow (literal issue reading)
-    const byId = new Map((await inst.db.select().from(schema.planes)).map((p) => [p.id, p.status]));
-    expect(byId.get('plane-starter')).toBe('available'); // the starter did land…
-    expect(byId.get('p-b')).toBe('flying'); // …but the fleet is not idle — still slowed
-  });
-
-  it('already at 1× → stays 1 (no-op slow)', async () => {
-    const { inst } = await setupLanding('slow-one.db', 1);
-    vi.setSystemTime(T0 + 2_000); // one tick at scale 1 advances 2e3 game ms — past the T0 arrival
-
-    const sim = await tickOnce(inst);
-
-    expect(sim.paused).toBe(false);
-    expect(sim.timeScale).toBe(1);
-    expect((await inst.db.select().from(schema.planes))[0].status).toBe('available');
-  });
-
-  it('a chained plane does NOT slow the sim (nothing is grounded)', async () => {
-    const { inst } = await setupLanding('slow-chain.db', 1000); // full tank, arrival exactly T0
-    // A queued next hop with plenty of fuel → chains on landing instead of grounding.
-    await inst.db.update(schema.planes)
-      .set({ queue: JSON.stringify(['EDDV']) })
-      .where(eq(schema.planes.id, 'plane-starter'));
-
-    vi.setSystemTime(T0 + 2_000); // one full clamped tick at scale 1000 → clock T0+2e6 ≥ arrival (T0)
-    const sim = await tickOnce(inst);
-
-    expect(sim.paused).toBe(false);
-    expect(sim.timeScale).toBe(1000); // still flying after the chain, nothing grounded — no slow…
-    const plane = (await inst.db.select().from(schema.planes))[0];
-    expect(plane.status).toBe('flying'); // …the fresh select in tickOnce counts it as airborne
-    expect(plane.destIcao).toBe('EDDV');
-  });
-
-  it('manually-paused sim is untouched by ticks (no landing processed while paused)', async () => {
-    const inst = await freshDb('slow-paused.db');
-    // The fleet is fully grounded (the seeded starter) — a paused tick must not touch the
-    // controls even though "any plane on ground" holds: the trigger requires a landing this tick.
-    await inst.db.update(schema.simState).set({ timeScale: 1000, lastSelectedTimeScale: 1000, paused: true });
-
-    vi.setSystemTime(T0 + 5_000);
-    const sim = await tickOnce(inst);
-
-    expect(sim.paused).toBe(true); // no landing processed while paused → trigger never fires
-    expect(sim.timeScale).toBe(1000);
-    expect(sim.lastSelectedTimeScale).toBe(1000);
-    expect((await inst.db.select().from(schema.planes))[0].status).toBe('available');
   });
 });
 
-describe('spawnOpenPackages', () => {
+describe('spawnPoolPackages (v0.65.0 per-airport pools)', () => {
-  it('tops the market up to MARKET_TARGET_OPEN_PACKAGES using the shared seed builder', async () => {
+  it('tops each pool airport up to the POOL_BANDS composition using the shared seed builder', async () => {
-    const inst = await freshDb('spawn.db');
+    const inst = await freshDb('pool.db');
     const clock = T0 + 123_456;
 
     // Leave exactly 3 open packages (the rest of the seeded set is "done").
@@ -598,16 +701,18 @@ describe('spawnOpenPackages', () => {
       await inst.db.update(schema.packages).set({ status: 'delivered' }).where(eq(schema.packages.id, p.id));
     }
 
-    const needed = await spawnOpenPackages(inst, clock, mulberry32(7));
+    const needed = await spawnPoolPackages(inst, clock, mulberry32(7), T0);
-    expect(needed).toBe(MARKET_TARGET_OPEN_PACKAGES - 3);
+    expect(needed).toBe(POOL_TARGET_PER_AIRPORT - 3);
 
     const openRows = (await inst.db.select().from(schema.packages)).filter((p) => p.status === 'open');
-    expect(openRows.length).toBe(MARKET_TARGET_OPEN_PACKAGES);
+    expect(openRows.length).toBe(POOL_TARGET_PER_AIRPORT);
+    expect(openRows.every((p) => p.originIcao === 'EDDF')).toBe(true); // single grounded plane → one pool
 
     const fc = await loadAirportsGeoJson();
     const icaoSet = new Set(fc.features.map((f) => f.properties.icao));
     for (const p of openRows.slice(3)) { // the spawned ones
       expect(p.createdSimTime).toBe(clock); // created at game time, not real time
+      expect(p.createdRealMs).toBe(T0); // …and stamped with the injected wall clock
       expect(icaoSet.has(p.originIcao)).toBe(true);
       expect(icaoSet.has(p.destIcao)).toBe(true);
       expect(p.originIcao).not.toBe(p.destIcao);
@@ -619,15 +724,36 @@ describe('spawnOpenPackages', () => {
     }
 
     // Already at target → nothing more to spawn.
-    expect(await spawnOpenPackages(inst, clock, mulberry32(7))).toBe(0);
+    expect(await spawnPoolPackages(inst, clock, mulberry32(7), T0)).toBe(0);
   });
 
-  it('is deterministic for an injected RNG (spawn matches the seed builder)', async () => {
+  it('keeps the band composition per airport — weights stay inside their band', async () => {
-    const a = await freshDb('spawn-a.db');
+    const inst = await freshDb('pool-composition.db');
-    const b = await freshDb('spawn-b.db');
+    // Wipe all seeded packages so the spawner builds the pool from zero with a known RNG.
+    for (const p of await inst.db.select().from(schema.packages)) {
+      await inst.db.delete(schema.packages).where(eq(schema.packages.id, p.id));
+    }
+
+    const n = await spawnPoolPackages(inst, T0 + 5_000, mulberry32(7), T0);
+    expect(n).toBe(POOL_TARGET_PER_AIRPORT); // one pool (EDDF) at full composition
+
+    const openRows = (await inst.db.select().from(schema.packages)).filter((p) => p.status === 'open');
+    const byBand = [0, 0, 0, 0];
+    for (const p of openRows) {
+      const b = poolBandOf(p.weightKg);
+      byBand[b]++;
+      expect(p.weightKg).toBeGreaterThanOrEqual(POOL_BANDS[b].minKg); // weight stays in its band…
+      expect(p.weightKg).toBeLessThanOrEqual(POOL_BANDS[b].maxKg); // …on both ends
+    }
+    expect(byBand).toEqual(POOL_BANDS.map((b) => b.count));
+  });
+
+  it('is deterministic for an injected RNG and wall clock', async () => {
+    const a = await freshDb('pool-a.db');
+    const b = await freshDb('pool-b.db');
     const clock = T0 + 999;
 
-    // Wipe all packages in both so both spawn from zero with the same RNG.
+    // Wipe all packages in both so both spawn from zero with the same RNG and now.
     for (const inst of [a, b]) {
       const rows = await inst.db.select().from(schema.packages);
       for (const r of rows) {
@@ -635,8 +761,8 @@ describe('spawnOpenPackages', () => {
       }
     }
 
-    expect(await spawnOpenPackages(a, clock, mulberry32(42))).toBe(MARKET_TARGET_OPEN_PACKAGES);
+    expect(await spawnPoolPackages(a, clock, mulberry32(42), T0)).toBe(POOL_TARGET_PER_AIRPORT);
-    expect(await spawnOpenPackages(b, clock, mulberry32(42))).toBe(MARKET_TARGET_OPEN_PACKAGES);
+    expect(await spawnPoolPackages(b, clock, mulberry32(42), T0)).toBe(POOL_TARGET_PER_AIRPORT);
 
     const strip = (rows: schema.PackageRow[]) =>
       rows.filter((p) => p.status === 'open').map(({ id: _id, ...rest }) => JSON.stringify(rest)).sort();
@@ -644,114 +770,73 @@ describe('spawnOpenPackages', () => {
       strip(await b.db.select().from(schema.packages)),
     );
   });
-});
 
-describe('spawnCoveragePackages (v0.8.0 spawn coverage rule)', () => {
+  it('spawns for flying destinations and queued airports, not just grounded locations', async () => {
-  // The seeded starter plane is grounded at EDDF with no seeded package from
+    const inst = await freshDb('pool-membership.db');
-  // there, so a fresh DB always has exactly one uncovered airport: EDDF.
-
-  it('spawns an open package originating at the airport of each uncovered grounded plane', async () => {
-    const inst = await freshDb('coverage.db');
-    const clock = T0 + 5_000;
-
-    // Wipe all seeded packages so coverage is the only source of new ones.
     for (const p of await inst.db.select().from(schema.packages)) {
       await inst.db.delete(schema.packages).where(eq(schema.packages.id, p.id));
     }
-
+    // Starter flies to LEMD with a queued leg to EHAM; a second plane sits at LEMD. The pool is
-    const n = await spawnCoveragePackages(inst, clock, mulberry32(7));
+    // {LEMD (flying dest + grounded), EHAM (queued)} — the starter's departure airport is NOT in it.
-    expect(n).toBe(1); // only EDDF is uncovered (single grounded plane)
+    await inst.db.update(schema.planes)
-
+      .set({ status: 'flying', destIcao: 'LEMD', departureSimTime: T0, queue: JSON.stringify(['EHAM']) })
-    const openRows = (await inst.db.select().from(schema.packages)).filter((p) => p.status === 'open');
+      .where(eq(schema.planes.id, 'plane-starter'));
-    expect(openRows.length).toBe(1);
+    await inst.db.insert(schema.planes).values({
-    expect(openRows[0].originIcao).toBe('EDDF'); // origin forced to the plane's airport
+      id: 'p-2', model: 'atr72', status: 'available', fuel: 100, maxFuel: 6300, locationIcao: 'LEMD', destIcao: null, lat: 40.4, lon: -3.6, departureSimTime: null,
-    expect(openRows[0].createdSimTime).toBe(clock);
     });
 
-  it('does nothing when every grounded airport already has an open package', async () => {
+    const n = await spawnPoolPackages(inst, T0 + 5_000, mulberry32(7), T0);
-    const inst = await freshDb('coverage-covered.db');
+    expect(n).toBe(POOL_TARGET_PER_AIRPORT * 2); // one full pool per airport in the set
-    for (const p of await inst.db.select().from(schema.packages)) {
-      await inst.db.delete(schema.packages).where(eq(schema.packages.id, p.id));
-    }
-    // One open package from EDDF covers the starter plane's airport.
-    await inst.db.insert(schema.packages).values({
-      id: 'p-cover', originIcao: 'EDDF', destIcao: 'LEMD', reward: 1, cargoType: 'Mail', cargoCount: 1,
-      deadlineSimTime: T0 + 3_600_000, status: 'open', planeId: null, createdSimTime: T0,
-    });
-
-    expect(await spawnCoveragePackages(inst, T0 + 5_000, mulberry32(7))).toBe(0);
-    expect((await inst.db.select().from(schema.packages)).length).toBe(1); // nothing added
-  });
-
-  it('spawns one package per uncovered airport when planes sit at several airports', async () => {
-    const inst = await freshDb('coverage-multi.db');
-    for (const p of await inst.db.select().from(schema.packages)) {
-      await inst.db.delete(schema.packages).where(eq(schema.packages.id, p.id));
-    }
-    // A second grounded plane at LEMD; two planes sharing EDDF must not double-spawn.
-    await inst.db.insert(schema.planes).values([
-      { id: 'p-2', model: 'atr72', status: 'available', fuel: 100, maxFuel: 6300, locationIcao: 'LEMD', destIcao: null, lat: 40.4, lon: -3.6, departureSimTime: null },
-      { id: 'p-3', model: 'atr72', status: 'available', fuel: 100, maxFuel: 6300, locationIcao: 'EDDF', destIcao: null, lat: 50.03, lon: 8.57, departureSimTime: null },
-    ]);
-
-    const n = await spawnCoveragePackages(inst, T0 + 5_000, mulberry32(7));
-    expect(n).toBe(2); // EDDF (×2 planes → one package) and LEMD
 
     const origins = (await inst.db.select().from(schema.packages))
       .filter((p) => p.status === 'open')
       .map((p) => p.originIcao)
       .sort();
-    expect(origins).toEqual(['EDDF', 'LEMD']);
+    expect(origins).toEqual(
+      [...Array(POOL_TARGET_PER_AIRPORT).fill('EHAM'), ...Array(POOL_TARGET_PER_AIRPORT).fill('LEMD')].sort(),
+    );
   });
 
-  it('ignores flying planes — they cannot take new work until they land', async () => {
+  it('holds taken slots for their refill delay, then refills them', async () => {
-    const inst = await freshDb('coverage-flying.db');
+    const inst = await freshDb('pool-cooldown.db');
-    for (const p of await inst.db.select().from(schema.packages)) {
+    // Take one small job and one heavy job at EDDF: both stamp slotFreeAtRealMs (the shared per-airport
-      await inst.db.delete(schema.packages).where(eq(schema.packages.id, p.id));
+    // cooldown — see the ponytail note in spawnPoolPackages).
-    }
+    const all = await inst.db.select().from(schema.packages);
-    await inst.db.update(schema.planes)
+    const small = all.find((p) => p.status === 'open' && poolBandOf(p.weightKg) === 0)!;
-      .set({ status: 'flying', departureSimTime: T0, destIcao: 'LEMD' })
+    const heavy = all.find((p) => p.status === 'open' && poolBandOf(p.weightKg) >= 2)!;
-      .where(eq(schema.planes.id, 'plane-starter'));
+    await inst.db.update(schema.packages).set({ status: 'loaded', planeId: 'plane-starter', slotFreeAtRealMs: T0 }).where(eq(schema.packages.id, small.id));
+    await inst.db.update(schema.packages).set({ status: 'loaded', planeId: 'plane-starter', slotFreeAtRealMs: T0 }).where(eq(schema.packages.id, heavy.id));
 
-    expect(await spawnCoveragePackages(inst, T0 + 5_000, mulberry32(7))).toBe(0); // no grounded planes
+    // While the cooldown runs (real = T0), nothing refills — even though two slots are empty.
+    expect(await spawnPoolPackages(inst, T0 + 5_000, mulberry32(7), T0)).toBe(0);
+
+    // The small slot frees first (SMALL_REFILL_DELAY_MS) — exactly its missing count refills; the heavy
+    // one is still held by REFILL_DELAY_MS.
+    expect(await spawnPoolPackages(inst, T0 + 5_000, mulberry32(7), T0 + SMALL_REFILL_DELAY_MS)).toBe(1);
+
+    // The heavy slot frees at REFILL_DELAY_MS — the last empty band tops up too.
+    expect(await spawnPoolPackages(inst, T0 + 5_000, mulberry32(7), T0 + REFILL_DELAY_MS)).toBe(1);
+
+    const openRows = (await inst.db.select().from(schema.packages)).filter((p) => p.status === 'open');
+    expect(openRows.length).toBe(POOL_TARGET_PER_AIRPORT); // pool back to full composition
   });
 
-  it('runs inside tickOnce: a fresh DB gains an EDDF-origin package after one advancing tick', async () => {
+  it('runs inside tickOnce: a fresh DB keeps every pool topped up through the full pipeline', async () => {
-    const inst = await freshDb('coverage-tick.db');
+    const inst = await freshDb('pool-tick.db');
-    vi.setSystemTime(T0 + 1_000); // one real second → advanceMs > 0 at scale 1
+    // A second, airborne plane keeps the world advancing (ISS-117) while the seeded starter stays
+    // grounded — pools at EDDF (grounded) and LEMD (flying destination). Arrival is hours out, so it
+    // never lands here.
+    await inst.db.insert(schema.planes).values({
+      id: 'p-air', model: 'atr72', status: 'flying', fuel: 6300, maxFuel: 6300,
+      locationIcao: 'EDDF', destIcao: 'LEMD', lat: 50.03, lon: 8.57, departureSimTime: STARTING_CLOCK_MS,
+    });
+    vi.setSystemTime(T0 + 1_000); // one real second → advanceMs > 0 at the seeded scale
 
     await tickOnce(inst);
 
-    const fromEdff = (await inst.db.select().from(schema.packages)).filter(
+    const openRows = (await inst.db.select().from(schema.packages)).filter((p) => p.status === 'open');
-      (p) => p.status === 'open' && p.originIcao === 'EDDF',
+    expect(openRows.length).toBe(POOL_TARGET_PER_AIRPORT * 2); // both pools held through the full tick pipeline
-    );
+    expect(openRows.every((p) => p.originIcao === 'EDDF' || p.originIcao === 'LEMD')).toBe(true);
-    expect(fromEdff.length).toBeGreaterThanOrEqual(1); // coverage held through the full tick pipeline
-  });
-});
-
-describe('clampTimeScale — v0.14.0 ladder bounds [1, 1000]', () => {
-  it('clamps below-minimum values to MIN_TIME_SCALE', () => {
-    expect(clampTimeScale(0)).toBe(MIN_TIME_SCALE);
-    expect(clampTimeScale(-5)).toBe(MIN_TIME_SCALE);
-    expect(clampTimeScale(0.1)).toBe(MIN_TIME_SCALE);
-  });
-
-  it('clamps above-maximum values to MAX_TIME_SCALE', () => {
-    expect(clampTimeScale(1001)).toBe(MAX_TIME_SCALE);
-    expect(clampTimeScale(2000)).toBe(MAX_TIME_SCALE);
-    expect(clampTimeScale(Number.MAX_SAFE_INTEGER)).toBe(MAX_TIME_SCALE);
-  });
-
-  it('passes in-range values through unclamped — ladder and off-ladder alike', () => {
-    for (const s of [1, 2, 5, 10, 25, 50, 100, 250, 500, 1000]) {
-      expect(clampTimeScale(s)).toBe(s); // the full v0.14.0 slider ladder
-    }
-    expect(clampTimeScale(37)).toBe(37); // off-ladder but in range (e.g. a legacy value)
-  });
-
-  it('keeps the endpoints exact', () => {
-    expect(clampTimeScale(MIN_TIME_SCALE)).toBe(MIN_TIME_SCALE);
-    expect(clampTimeScale(MAX_TIME_SCALE)).toBe(MAX_TIME_SCALE);
   });
 });
 

lib/sim/engine.ts

@@ -1,36 +1,47 @@
 import { randomInt, randomUUID } from 'node:crypto';
-import { eq, inArray } from 'drizzle-orm';
+import { eq, sql } from 'drizzle-orm';
 import { getGameDb, persist, type GameDb } from '@/lib/db/client';
 import * as schema from '@/lib/db/schema';
 import { loadAirportsGeoJson } from '@/lib/airports';
 import { haversineKm, initialBearingDeg } from '@/lib/geo';
 import { weatherFor } from '@/lib/weather';
-import { conditionBurnMultiplier, FUEL_DISCOUNT_PER_REP, FUEL_PRICE_PER_L, MAX_FUEL_DISCOUNT, PLANE_TYPES, repRate, WEAR_PER_KM } from '@/lib/game/catalog';
+import { FUEL_DISCOUNT_PER_REP, FUEL_PRICE_PER_L, MAX_FUEL_DISCOUNT, PLANE_TYPES, REPAIR_DURATION_MS, repRate, WEAR_PER_KM } from '@/lib/game/catalog';
 import { SPECIALS } from '@/lib/game/specials';
-import { parseIcaoQueue } from '@/lib/game/state';
+import { getStateSnapshot, parseIcaoQueue, poolAirports, sseFrame } from '@/lib/game/state';
+import { broadcast } from '@/lib/sse';
+
 import {
-  generatePackage,
+  JOB_LIFETIME_MS,
-  MARKET_TARGET_OPEN_PACKAGES,
+  POOL_BANDS,
+  REFILL_DELAY_MS,
+  SMALL_REFILL_DELAY_MS,
+  generatePoolPackage,
   mulberry32,
+  poolBandOf,
   type Rng,
   type SeedAirport,
 } from '@/lib/game/seed';
 import { arrivalTimeFor, fuelAtWeighted, requiredFuelFor, windBurnFactor } from './movement';
 
-// Server-authoritative sim engine (v0.7.0) — tick-on-read: there is NO background
+// Server-authoritative sim engine (v0.7.0). ISS-117 (v0.52.0): the clock advances on a background
-// timer. Every read/action endpoint calls tickNow() first; the clock advances by
+// tick (~1 s, started at boot from instrumentation.ts) AND on every read/action — both through the
-// (real ms since last tick) × timeScale, clamped per tick so long absences never
+// same locked tickOnce path. Each tick advances by (real ms since last tick) × scale, clamped per
-// fast-forward the game.
+// tick so long absences never fast-forward the game; while no plane is flying or in repair the
+// world clock stays FROZEN (#135 v0.62.0 — final ISS-117 semantics), and lastRealTickMs always
+// keeps tracking real time, so resuming activity never fast-forwards the frozen span. Scale is the
+// fixed WORLD_TIME_SCALE in production; only FLIGHT_TEST_HOOKS deployments honor sim.timeScale
+// (the test-hook override) — legacy saves may hold stale values (#135).
 
-// Clamp constant: max real-time gap counted by a single tick. Chosen at 2000 ms —
+// Clamp constant: max real-time gap counted by a single tick. Chosen at 2000 ms — comfortably above
-// comfortably above a normal client poll interval (~1 s), so active play advances
+// both the client poll interval (~1 s) and the background-tick interval, so active play advances
-// ~real time × scale; small enough that one stale read after an absence moves game
+// ~real time × scale; small enough that one stale read after an absence moves game time by at most
-// time by at most 2 s × scale (≈ 33 min even at max scale 1000). The sim therefore
+// 2 s × scale.
-// only meaningfully progresses while actively polled.
 export const MAX_TICK_ELAPSED_MS = 2_000;
 
-export const MIN_TIME_SCALE = 1;
+// ISS-117: the fixed world rate — imported for tickOnce, re-exported so server code and tests
-export const MAX_TIME_SCALE = 1000; // top of the slider ladder (v0.14.0)
+// have one familiar home.
+import { WORLD_TIME_SCALE } from '@/lib/worldClock';
+export { WORLD_TIME_SCALE };
 
 // Reputation gain per delivered package: BASE + PER_KM × great-circle km, rounded
 // to 2 decimals (reputation is REAL). A short hop (~300 km) earns ~1.15 rep, a
@@ -42,18 +53,15 @@ export function reputationGainFor(km: number): number {
   return Math.round((REP_BASE + REP_PER_KM * km) * 100) / 100;
 }
 
-export interface SimControlsInput {
+// Serialize ticks across concurrent requests (Next.js route handlers run in the same process): each
-  timeScale?: number;
+// tick re-reads sim_state after the previous one wrote it, so no advance is ever applied twice.
-  paused?: boolean;
+// ISS-129 (v0.57.0): the chain lives on globalThis — instrumentation.ts and route handlers get
-}
+// separate module instances from Next.js, so a plain `let` would give each layer its own lock and let
-
+// their ticks interleave against the shared DB below.
-// Serialize ticks across concurrent requests (Next.js route handlers run in the
+const g = globalThis as unknown as { __flightTickChain?: Promise<unknown> };
-// same process): each tick re-reads sim_state after the previous one wrote it, so
-// no advance is ever applied twice.
-let chain: Promise<unknown> = Promise.resolve();
 function withLock<T>(fn: () => Promise<T>): Promise<T> {
-  const run = chain.then(fn);
+  const run = (g.__flightTickChain ??= Promise.resolve()).then(fn);
-  chain = run.then(
+  g.__flightTickChain = run.then(
     () => undefined,
     () => undefined,
   );
@@ -62,63 +70,70 @@ function withLock<T>(fn: () => Promise<T>): Promise<T> {
 
 // --- Tick core (takes a GameDb so unit tests can inject their own instance) ---
 
+// #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/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;
+  for (const p of planes) {
+    if (p.status === 'flying') flying++;
+    else if (p.status === 'repairing') repairing++;
+  }
+  return { advance: flying > 0 || repairing > 0, flying, repairing };
+}
+
 export async function tickOnce(inst: GameDb): Promise<schema.SimStateRow> {
   const rows = await inst.db.select().from(schema.simState);
   const sim = rows[0];
   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/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
+  // timeScale (e.g. 1000 from pre-v0.52.0 UI controls, or an old e2e run against the live instance).
+  // Only FLIGHT_TEST_HOOKS deployments honor sim.timeScale, which POST /api/test/set-timescale writes.
+  const scale = process.env.FLIGHT_TEST_HOOKS === '1' ? sim.timeScale : WORLD_TIME_SCALE;
   const elapsed = Math.max(0, nowMs - sim.lastRealTickMs);
-  // While paused the clock is frozen; lastRealTickMs still tracks real time so
+  const advanceMs = advance ? Math.min(elapsed, MAX_TICK_ELAPSED_MS) * scale : 0;
-  // unpausing resumes cleanly with no catch-up jump for the pause duration.
-  const advanceMs = sim.paused ? 0 : Math.min(elapsed, MAX_TICK_ELAPSED_MS) * sim.timeScale;
   const clockMs = Math.round(sim.clockMs + advanceMs);
 
-  let landedThisTick = 0;
   if (advanceMs > 0) {
-    await expirePackages(inst, clockMs);
+    await expireLoadedPackages(inst, clockMs);
-    // ISS-057: remember the landings so the tick can slow down when a plane is left on ground.
+    await deliverPackages(inst, clockMs);
-    landedThisTick = await deliverPackages(inst, clockMs);
     // 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.
+    // nothing landed this tick; BEFORE the spawns so a just-repaired plane gets pool 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);
-  }
-
-  const sets: Partial<Pick<schema.SimStateRow, 'clockMs' | 'lastRealTickMs' | 'timeScale'>> = {
-    clockMs,
-    lastRealTickMs: nowMs,
-  };
-  // Slow on landing (ISS-057): when ≥1 plane landed this tick and ANY plane is grounded
-  // ('available') afterwards, drop the sim to MIN_TIME_SCALE — a just-landed plane counts, so
-  // any real landing slows. A chained plane stays 'flying' via deliverPackages' auto-chain
-  // branch, so a pure-chain tick with nothing grounded does NOT slow. Pause is manual-only now;
-  // flyPlane restores lastSelectedTimeScale when the last grounded plane takes off. Arrival-
-  // triggered by design: a grounded fleet at high scale is left alone (no idle-enforcement), and
-  // a paused tick never processes landings (advanceMs === 0), so the trigger only fires on an
-  // advancing tick — a manual speed change while planes sit grounded survives until the next landing.
-  if (landedThisTick > 0) {
-    const available = await inst.db.select().from(schema.planes).where(eq(schema.planes.status, 'available'));
-    if (available.length >= 1) sets.timeScale = MIN_TIME_SCALE;
   }
+  // v0.65.0: market refresh runs on EVERY tick — frozen ones included (#135 follow-up carried over) —
+  // because while grounded nothing else creates packages but removal paths (open-job expiry) still run; without
+  // this a grounded fleet could drain its pools to zero and soft-lock forever. Open jobs age on the
+  // WALL clock (JOB_LIFETIME_MS after createdRealMs), so even a fully paused world refreshes its board;
+  // both passes are idempotent no-ops when satisfied, so advancing ticks behave exactly as before.
+  await expireOpenPackages(inst, nowMs);
+  // AFTER delivery on purpose: a plane that just landed gets work spawned at its new location within
+  // the same tick (its destination joins the pool while flying, and its arrival airport on landing).
+  await spawnPoolPackages(inst, clockMs);
 
   // Persist lastRealTickMs even when nothing advanced — it is the tick anchor.
-  await inst.db.update(schema.simState).set(sets);
+  await inst.db.update(schema.simState).set({ clockMs, lastRealTickMs: nowMs });
   await persist(inst);
   const updated = (await inst.db.select().from(schema.simState))[0];
   if (!updated) throw new Error('sim_state row missing after tick');
   return updated;
 }
 
-// Packages whose deadline has passed become 'expired' — both OPEN ones (they leave
+// v0.65.0: expiry split by clock. LOADED cargo expires on the SIM clock (unchanged since v0.12.0 —
-// the market so spawn can top it back up) and LOADED ones (v0.12.0: they keep
+// it keeps occupying its slot, delivers no reward on arrival, and abandons for free); OPEN jobs
-// occupying their slot, deliver no reward on arrival, and abandon for free).
+// expire on the WALL clock (see expireOpenPackages). Delivered/abandoned packages are terminal and
-// Delivered/abandoned packages are terminal and never flip. Returns the count.
+// never flip. Both return the count flipped.
-export async function expirePackages(inst: GameDb, clockMs: number): Promise<number> {
+export async function expireLoadedPackages(inst: GameDb, clockMs: number): Promise<number> {
-  const rows = await inst.db.select().from(schema.packages).where(inArray(schema.packages.status, ['open', 'loaded']));
+  const rows = await inst.db.select().from(schema.packages).where(eq(schema.packages.status, 'loaded'));
   let n = 0;
   for (const p of rows) {
     if (p.deadlineSimTime <= clockMs) {
@@ -129,18 +144,52 @@ export async function expirePackages(inst: GameDb, clockMs: number): Promise<num
   return n;
 }
 
-// Repairs whose gate has passed flip the plane back to 'available' and clear the gate
+// v0.65.0: open jobs live on the WALL clock — JOB_LIFETIME_MS after createdRealMs they expire
-// (v0.39.0, ISS-069) — same shape as expirePackages: one guarded pass over the rows,
+// regardless of time scale or fleet state, so a paused/frozen world still refreshes its board. Runs
-// `<=` inclusive at the clock. Returns the count flipped.
+// every tick (~1 s), outside the advance gate. An expired job's slot respawns immediately (no
+// slotFreeAtRealMs is set — only TAKEN jobs start a refill cooldown). v0.69.0: legacy 'ignored' rows
+// (pre-v0.69.0 dismissals) are swept in too — each self-heals to 'expired' on the first tick past its
+// lifetime, and no new ones can ever be created. Returns the count flipped.
+export async function expireOpenPackages(inst: GameDb, nowMs: number): Promise<number> {
+  // Raw SQL on purpose: 'ignored' is no longer in the status enum (v0.69.0) — it only exists as a
+  // legacy value in pre-v0.69.0 databases, so the typed column can't express the query.
+  const rows = await inst.db.select().from(schema.packages).where(sql`${schema.packages.status} IN ('open', 'ignored')`);
+  let n = 0;
+  for (const p of rows) {
+    if (p.createdRealMs + JOB_LIFETIME_MS <= nowMs) {
+      await inst.db.update(schema.packages).set({ status: 'expired' }).where(eq(schema.packages.id, p.id));
+      n++;
+    }
+  }
+  return n;
+}
+
+// Repairs heal gradually (v0.45.0, ISS-089): while a plane is 'repairing', its health climbs along
+// round(f × 100), where f is the fraction of REPAIR_DURATION_MS elapsed since the repair started —
+// derived from the stored gate alone (start = gate − duration), so no schema change. The plane flips
+// back to 'available' exactly when it reaches full health, i.e. at the gate. Same shape as
+// expirePackages: one guarded pass over the rows. Returns the count flipped.
 export async function finishRepairs(inst: GameDb, clockMs: number): Promise<number> {
   const rows = await inst.db.select().from(schema.planes).where(eq(schema.planes.status, 'repairing'));
   let n = 0;
   for (const p of rows) {
-    if (p.repairUntilSimTime !== null && p.repairUntilSimTime <= clockMs) {
+    if (p.repairUntilSimTime === null) continue; // defensive — repairing always carries a gate
+    // ponytail: constant duration regardless of starting health — the curve is absolute (f × 100), so a
+    // plane at 90 heals in the same sim time as one at 5. Proportional duration would need storing the
+    // start health; add a column if balance wants it. The flip stays strictly at the gate (`<=` inclusive,
+    // as before) — round(f × 100) can hit 100 a hair early (f ≥ 0.995), which is cosmetic only: the plane
+    // is still 'repairing' and grounded until the gate passes.
+    const f = Math.min(1, Math.max(0, (clockMs - (p.repairUntilSimTime - REPAIR_DURATION_MS)) / REPAIR_DURATION_MS));
+    if (p.repairUntilSimTime <= clockMs) {
       await inst.db.update(schema.planes)
-        .set({ status: 'available', repairUntilSimTime: null })
+        .set({ status: 'available', health: 100, repairUntilSimTime: null })
         .where(eq(schema.planes.id, p.id));
       n++;
+    } else {
+      const newHealth = Math.min(100, Math.max(p.health, Math.round(f * 100)));
+      if (newHealth !== p.health) {
+        await inst.db.update(schema.planes).set({ health: newHealth }).where(eq(schema.planes.id, p.id));
+      }
     }
   }
   return n;
@@ -151,15 +200,15 @@ export async function finishRepairs(inst: GameDb, clockMs: number): Promise<numb
 // ones still inside their deadline are delivered (cash += reward + reputation
 // gain per package), 'expired' ones just unbind (no reward). Packages destined
 // elsewhere stay loaded on the plane for a later leg. Then (v0.25.0, ISS-043)
-// auto-chain: if the queue holds legs and fuel covers the first one, start it
+// auto-chain: if the queue holds legs, fuel covers the first one and the plane is not
-// immediately from the arrival airport; with a short tank, ISS-082 (v0.42.0) tops
+// broken by this landing's wear (v0.45.0, ISS-089), start it immediately from the arrival
+// airport; with a short tank, ISS-082 (v0.42.0) tops
 // up to 150% of the requirement (capped at tank capacity) when cash allows and
 // chains anyway — only an unaffordable top-up grounds the plane there with its
 // remaining fuel and the queue kept intact for a later dispatch.
 // Idempotent — a finalized plane either leaves the 'flying' state or starts a NEW
 // leg whose own arrival is in the future, so it can never be awarded twice.
-// Returns planes landed. NOTE: runs BEFORE tickOnce's slow-down check on purpose —
+// Returns planes landed.
-// a chained plane is already 'flying' again here, so a pure-chain landing never slows the sim.
 export async function deliverPackages(inst: GameDb, clockMs: number): Promise<number> {
   const [planeRows, packageRows] = await Promise.all([
     inst.db.select().from(schema.planes),
@@ -182,12 +231,10 @@ export async function deliverPackages(inst: GameDb, clockMs: number): Promise<nu
 
     // Arrived: progress is exactly 1 here, so remaining fuel is the full-leg weighted burn —
     // wind-adjusted (v0.36.0) by departure weather vs route heading, same factor flyPlane used.
-    // v0.39.0 (ISS-069): broken planes (health ≤ 0 at DEPARTURE) burn BROKEN_BURN_MULTIPLIER × more —
-    // p.health is the pre-landing value, so this stays bit-consistent with livePlane()'s gauge.
     const w = weatherFor(p.locationIcao);
     const landedFuel = fuelAtWeighted(
       p.fuel,
-      type.burnPerKm * windBurnFactor(w.windKt, w.windDirDeg, initialBearingDeg(from.lat, from.lon, to.lat, to.lon)) * conditionBurnMultiplier(p.health),
+      type.burnPerKm * windBurnFactor(w.windKt, w.windDirDeg, initialBearingDeg(from.lat, from.lon, to.lat, to.lon)),
       type.emptyWeightKg,
       type.maxFuel,
       distanceKm,
@@ -224,25 +271,35 @@ export async function deliverPackages(inst: GameDb, clockMs: number): Promise<nu
     // (requiredFuelFor is independent of current load). ISS-082 (v0.42.0): manual refuel is gone,
     // so a short tank no longer strands the chain — when cash allows, top up to 150% of the
     // requirement (capped at tank capacity) and chain anyway; unaffordable → ground here with the
-    // queue kept intact. An unknown ICAO in the queue simply cannot chain either way.
+    // queue kept intact. An unknown ICAO in the queue simply cannot chain either way. v0.45.0
+    // (ISS-089): a plane that lands BROKEN (newHealth ≤ 0) never chains — it stays grounded with
+    // the queue intact until repaired, exactly like flyPlane's broken guard.
     const queue = parseIcaoQueue(p.queue);
     let chainedTo: string | null = null;
     let topUpFuel: number | null = null; // post-top-up fuel for the chained departure, when a top-up happened
-    if (queue.length > 0) {
+    if (queue.length > 0 && newHealth > 0) {
       const nextDest = queue[0];
+      // ponytail: defensive guard for legacy rows — a queued leg to the airport we just landed at is a
+      // zero-distance no-op hop; drop it and ground instead of flying. Normal play can't produce this
+      // since v0.46.0 (flyPlane consumes queue[0] on dispatch, every chain shifts its own leg).
+      if (nextDest === to.icao) {
+        queue.shift();
+      } else {
         const next = byIcao.get(nextDest); // unknown ICAO in the queue → cannot chain
         if (next) {
-        // Wind-adjusted requirement for the NEXT leg — it departs from `to` (v0.36.0). v0.39.0 (ISS-069):
+          // Wind-adjusted requirement for the NEXT leg — it departs from `to` (v0.36.0).
-        // the chained leg starts AFTER this landing's wear, so its burn uses newHealth — exactly what
-        // livePlane()/the next landing will compute for that flight.
           const wNext = weatherFor(to.icao);
           const nextRequiredL = requiredFuelFor(
-          type.burnPerKm * windBurnFactor(wNext.windKt, wNext.windDirDeg, initialBearingDeg(to.lat, to.lon, next.lat, next.lon)) * conditionBurnMultiplier(newHealth),
+            type.burnPerKm * windBurnFactor(wNext.windKt, wNext.windDirDeg, initialBearingDeg(to.lat, to.lon, next.lat, next.lon)),
             type.emptyWeightKg,
             type.maxFuel,
             haversineKm(to.lat, to.lon, next.lat, next.lon),
           );
-        if (nextRequiredL <= landedFuel) {
+          // v0.46.0 backstop: a leg that doesn't fit even a full tank is unflyable — ground with the queue
+          // intact, mirroring flyPlane's 409 without throwing in the engine.
+          if (nextRequiredL > type.maxFuel) {
+            // no chain — the grounded update below keeps the queue for a later dispatch
+          } else if (nextRequiredL <= landedFuel) {
             queue.shift();
             chainedTo = nextDest;
           } else {
@@ -262,6 +319,7 @@ export async function deliverPackages(inst: GameDb, clockMs: number): Promise<nu
           }
         }
       }
+    }
     await inst.db.update(schema.planes)
       .set(
         chainedTo
@@ -294,19 +352,28 @@ export async function deliverPackages(inst: GameDb, clockMs: number): Promise<nu
   return n;
 }
 
-// Top the market back up to MARKET_TARGET_OPEN_PACKAGES open packages using the
+// v0.65.0: per-airport job pools replace the global market top-up (v0.7.0) and the coverage spawn
-// SAME builder as the first-run seed (generatePackage), so spawned packages are
+// (v0.8.0). Every airport where a plane can take work — grounded there, flying TO it, or queued for
-// indistinguishable from seeded ones. RNG is injectable for deterministic tests.
+// it (poolAirports in lib/game/state.ts) — keeps the POOL_BANDS composition of open packages: each
-export async function spawnOpenPackages(
+// band is topped back up to its count using generatePoolPackage, so seeded and spawned packages are
+// indistinguishable. A TAKEN slot (loaded) stays empty for the band's refill delay after
+// slotFreeAtRealMs; expired/delivered/abandoned never block, so an untaken job's slot respawns on
+// the next tick. Orphaned pools (plane left without taking a job) simply expire out — no cleanup.
+// RNG and wall-clock now are injectable for deterministic tests. Returns the number created.
+export async function spawnPoolPackages(
   inst: GameDb,
   clockMs: number,
   rng?: Rng,
+  nowMs?: number,
 ): Promise<number> {
-  const openCount = (
+  const real = nowMs ?? Date.now();
-    await inst.db.select().from(schema.packages).where(eq(schema.packages.status, 'open'))
+  const [planeRows, packageRows] = await Promise.all([
-  ).length;
+    inst.db.select().from(schema.planes),
-  const needed = MARKET_TARGET_OPEN_PACKAGES - openCount;
+    inst.db.select().from(schema.packages),
-  if (needed <= 0) return 0;
+  ]);
+
+  const pool = poolAirports(planeRows);
+  if (pool.size === 0) return 0; // no pool airports — e.g. the whole fleet is in the shop with empty queues
 
   const fc = await loadAirportsGeoJson();
   const airports: SeedAirport[] = fc.features.map((f) => ({
@@ -320,70 +387,77 @@ export async function spawnOpenPackages(
   const account = (await inst.db.select().from(schema.account))[0];
   if (!account) throw new Error('account row missing');
 
-  for (let i = 0; i < needed; i++) {
-    await inst.db.insert(schema.packages).values(
-      generatePackage({ id: randomUUID(), airports, rng: rand, nowMs: clockMs, reputation: account.reputation }),
-    );
-  }
-  return needed;
-}
-
-// Spawn coverage rule (v0.8.0): in addition to topping the market up, every
-// airport that currently has a grounded 'available' plane must have ≥1 OPEN
-// package originating there — so work is always available where the fleet sits
-// (including onboarding at EDDF). One package per uncovered airport, generated
-// with generatePackage and origin forced to that airport. Runs after
-// spawnOpenPackages in tickOnce, so randomly spawned packages count as coverage
-// too; and after deliverPackages, so a plane that just landed gets work spawned
-// at its new location within the same tick. Returns the number created.
-export async function spawnCoveragePackages(
-  inst: GameDb,
-  clockMs: number,
-  rng?: Rng,
-): Promise<number> {
-  const [planeRows, openRows] = await Promise.all([
-    inst.db.select().from(schema.planes),
-    inst.db.select().from(schema.packages).where(eq(schema.packages.status, 'open')),
-  ]);
-
-  // Distinct airports with at least one grounded plane (flying planes don't count —
-  // they can't take new work until they land).
-  const groundedIcas = [
-    ...new Set(planeRows.filter((p) => p.status === 'available').map((p) => p.locationIcao)),
-  ];
-  if (groundedIcas.length === 0) return 0;
-
-  const covered = new Set(openRows.map((c) => c.originIcao));
-  const missing = groundedIcas.filter((icao) => !covered.has(icao));
-  if (missing.length === 0) return 0;
-
-  const fc = await loadAirportsGeoJson();
-  const airports: SeedAirport[] = fc.features.map((f) => ({
-    icao: f.properties.icao,
-    name: f.properties.name,
-    lat: f.properties.lat,
-    lon: f.properties.lon,
-  }));
-  const rand = rng ?? mulberry32(randomInt(0, 2 ** 31));
-  // v0.38.0 (ISS-072): same reputation quality as spawnOpenPackages — read once per batch.
-  const account = (await inst.db.select().from(schema.account))[0];
-  if (!account) throw new Error('account row missing');
-
   let n = 0;
-  for (const icao of missing) {
+  for (const originIcao of pool) {
-    if (!airports.some((a) => a.icao === icao)) continue; // defensive — the dataset is the source of all ICACs
+    // Open counts and refill cooldowns per band at this airport. Only open/loaded rows matter:
+    // terminal statuses never block a slot, and loaded carries the slotFreeAtRealMs stamp.
+    const openByBand = [0, 0, 0, 0];
+    let blockedUntil: number | null = null;
+    for (const p of packageRows) {
+      if (p.originIcao !== originIcao || p.status === 'delivered' || p.status === 'expired' || p.status === 'abandoned') continue;
+      const b = poolBandOf(p.weightKg);
+      if (p.status === 'open') openByBand[b]++;
+      else if (p.slotFreeAtRealMs !== null && (blockedUntil === null || p.slotFreeAtRealMs > blockedUntil)) {
+        // ponytail: one shared cooldown per airport, not per band — a taken heavy job delays small-job
+        // refills too. Per-band tracking is a trivial change if the board feels sluggish.
+        blockedUntil = p.slotFreeAtRealMs;
+      }
+    }
+    for (let bandIdx = 0; bandIdx < POOL_BANDS.length; bandIdx++) {
+      const delay = bandIdx === 0 ? SMALL_REFILL_DELAY_MS : REFILL_DELAY_MS;
+      while (openByBand[bandIdx] < POOL_BANDS[bandIdx].count && !(blockedUntil !== null && blockedUntil + delay > real)) {
         await inst.db.insert(schema.packages).values(
-      generatePackage({ id: randomUUID(), airports, rng: rand, nowMs: clockMs, originIcao: icao, reputation: account.reputation }),
+          generatePoolPackage({
+            airports,
+            originIcao,
+            bandIdx,
+            rng: rand,
+            clockMs,
+            id: randomUUID(),
+            createdRealMs: real,
+            reputation: account.reputation,
+          }),
         );
+        openByBand[bandIdx]++;
         n++;
       }
+    }
+  }
   return n;
 }
 
 // --- Public API (singleton DB + lock) — call from every read/action endpoint ---
 
+// ISS-129 (v0.57.0): after each tick on the singleton path, push a fresh snapshot to all SSE
+// subscribers (/api/events). ISS-133 (v0.59.0): frames carry the sseFrame projection — terminal
+// package history is dropped, everything else matches GET /api/state exactly. Failures are logged,
+// not fatal: polling still works either way. Background ticks (~1 s) cover action mutations for
+// other clients too.
+async function broadcastState(): Promise<void> {
+  try {
+    broadcast(JSON.stringify(sseFrame(await getStateSnapshot())));
+  } catch (err) {
+    console.error('flight: state broadcast failed', err);
+  }
+}
+
 export function tickNow(): Promise<schema.SimStateRow> {
-  return withLock(async () => tickOnce(await getGameDb()));
+  return withLock(async () => {
+    const row = await tickOnce(await getGameDb());
+    await broadcastState();
+    return row;
+  });
+}
+
+// ISS-117: the world clock runs even with nobody polling — a ~1 s interval drives the same locked
+// tick path as reads/actions. Started once at server boot from instrumentation.ts (Next ≥15); the
+// guard makes double-starts harmless (dev HMR reloads).
+let backgroundTimer: ReturnType<typeof setInterval> | null = null;
+export function startBackgroundTick(intervalMs = 1_000): void {
+  if (backgroundTimer !== null) return;
+  backgroundTimer = setInterval(() => {
+    tickNow().catch((err) => console.error('flight: background tick failed', err));
+  }, intervalMs);
 }
 
 // Run a game action atomically with respect to ticks (v0.8.0): the clock is
@@ -399,31 +473,17 @@ export function runAction<T>(fn: (inst: GameDb) => Promise<T>): Promise<T> {
   });
 }
 
-// Tick first so the returned state reflects current time, then apply the new
+// Test-hook backing (FLIGHT_TEST_HOOKS=1 only — see app/api/test/set-timescale/route.ts): set the
-// controls. timeScale is clamped to [1, 1000]; validation of raw input happens in
+// effective time scale under the same lock as ticks so a background tick can never interleave
-// the route handler (400 on non-number / non-boolean). ISS-057: posting a timeScale
+// between read and write. Input validation happens in the route; this trusts its number.
-// ALSO records it as lastSelectedTimeScale — the resume target flyPlane restores when
+export function setTestTimeScale(scale: number): Promise<schema.SimStateRow> {
-// the last grounded plane takes off. A {paused}-only post never touches it, so the
-// last manual intent wins without an extra flag.
-export function applyTimeControls(input: SimControlsInput): Promise<schema.SimStateRow> {
   return withLock(async () => {
     const inst = await getGameDb();
     await tickOnce(inst);
-    const sets: Partial<Pick<schema.SimStateRow, 'timeScale' | 'lastSelectedTimeScale' | 'paused'>> = {};
+    await inst.db.update(schema.simState).set({ timeScale: scale });
-    if (input.timeScale !== undefined) {
-      const scale = clampTimeScale(input.timeScale);
-      sets.timeScale = scale;
-      sets.lastSelectedTimeScale = scale;
-    }
-    if (input.paused !== undefined) sets.paused = input.paused;
-    if (Object.keys(sets).length > 0) await inst.db.update(schema.simState).set(sets);
     await persist(inst);
     const updated = (await inst.db.select().from(schema.simState))[0];
     if (!updated) throw new Error('sim_state row missing');
     return updated;
   });
 }
-
-export function clampTimeScale(v: number): number {
-  return Math.min(MAX_TIME_SCALE, Math.max(MIN_TIME_SCALE, v));
-}

lib/sim/movement.test.ts

@@ -5,6 +5,8 @@ import {
   burnRateConstant,
   FUEL_DENSITY_KG_PER_L,
   fuelAtWeighted,
+  guaranteedRangeKm,
+  MAX_WIND_BURN_FACTOR,
   maxRangeKm,
   positionAt,
   progressAt,
@@ -234,3 +236,22 @@ describe('maxRangeKm (v0.28.0)', () => {
     expect(() => maxRangeKm(BURN, 0, TANK)).toThrow();
   });
 });
+
+describe('guaranteedRangeKm (v0.51.0, ISS-099)', () => {
+  it("MAX_WIND_BURN_FACTOR is windBurnFactor's actual maximum over the weather domain", () => {
+    // Full headwind at max wind: exactly +20% — the constant must track the factor function, not a copy.
+    expect(MAX_WIND_BURN_FACTOR).toBe(windBurnFactor(30, 90, 90));
+  });
+
+  it('is maxRangeKm under worst-case headwind burn (ATR ≈ 3696 km ±5%)', () => {
+    const r = guaranteedRangeKm(BURN, WE, TANK);
+    expect(r).toBeCloseTo(maxRangeKm(BURN * MAX_WIND_BURN_FACTOR, WE, TANK), 12);
+    expect(r).toBeGreaterThan(3696 * 0.95);
+    expect(r).toBeLessThan(3696 * 1.05);
+  });
+
+  it('zero fuel → zero range; rejects a non-positive empty weight', () => {
+    expect(guaranteedRangeKm(BURN, WE, 0)).toBe(0);
+    expect(() => guaranteedRangeKm(BURN, 0, TANK)).toThrow();
+  });
+});

lib/sim/movement.ts

@@ -137,3 +137,16 @@ export function maxRangeKm(burnPerKm: number, emptyWeightKg: number, maxFuel: nu
   const rho = FUEL_DENSITY_KG_PER_L;
   return Math.log(1 + (rho * maxFuel) / emptyWeightKg) * ((emptyWeightKg + rho * maxFuel) / (rho * burnPerKm));
 }
+
+// Max headwind burn multiplier over the weather domain (v0.51.0, ISS-099): the upper end of
+// windBurnFactor's [0.8, 1.2] range — a full 30 kt headwind (the max in lib/weather.ts) ÷ 150.
+export const MAX_WIND_BURN_FACTOR = 1 + 30 / 150;
+
+// Guaranteed full-tank range (v0.51.0, ISS-099): the maxRangeKm closed form under worst-case
+// headwind burn — any leg within this distance is flyable in ALL weather, since windBurnFactor
+// never exceeds MAX_WIND_BURN_FACTOR and requiredFuelFor grows with the burn rate. This is what
+// the UI displays as "Max range", so a spec-possible leg always passes flyPlane's fuel guard
+// (requiredFuelFor ≤ maxFuel under the same wind-adjusted burn).
+export function guaranteedRangeKm(burnPerKm: number, emptyWeightKg: number, maxFuel: number): number {
+  return maxRangeKm(burnPerKm * MAX_WIND_BURN_FACTOR, emptyWeightKg, maxFuel);
+}

lib/sse.test.ts

@@ -0,0 +1,45 @@
+import { describe, expect, it } from 'vitest';
+import { broadcast, subscribe } from './sse';
+
+// ISS-129 (v0.57.0): the fan-out registry behind /api/events — plain Set semantics, so no DB or
+// server needed. Subscribers leak across tests in this file (module-level state), which is fine:
+// each test only asserts on its own arrays.
+
+describe('lib/sse', () => {
+  it('delivers broadcasts to subscribers and stops after unsubscribe', () => {
+    const a: string[] = [];
+    const b: string[] = [];
+    const unsubA = subscribe((t) => a.push(t));
+    const unsubB = subscribe((t) => b.push(t));
+
+    broadcast('x');
+    expect(a).toEqual(['x']);
+    expect(b).toEqual(['x']);
+
+    unsubA();
+    broadcast('y');
+    expect(a).toEqual(['x']); // unsubscribed — no more events
+    expect(b).toEqual(['x', 'y']);
+    unsubB();
+  });
+
+  it('a throwing subscriber does not break the others', () => {
+    const got: string[] = [];
+    subscribe(() => {
+      throw new Error('boom');
+    });
+    const unsub = subscribe((t) => got.push(t));
+    broadcast('z');
+    expect(got).toEqual(['z']);
+    unsub();
+  });
+
+  it('unsubscribe is idempotent', () => {
+    const got: string[] = [];
+    const unsub = subscribe((t) => got.push(t));
+    unsub();
+    unsub(); // second call must not throw
+    broadcast('w');
+    expect(got).toEqual([]);
+  });
+});

lib/sse.ts

@@ -0,0 +1,29 @@
+// ISS-129 (v0.57.0): in-process fan-out registry for the SSE state stream (/api/events). The app
+// runs as one long-lived server process (`next start`; instrumentation.ts already keeps background
+// sim state alive) — no new dependencies, no WS upgrade needed. The Set lives on globalThis because
+// Next.js gives instrumentation.ts (where broadcast() fires from the background tick) and route
+// handlers (where subscribe() happens in /api/events) separate module instances; a plain `let` would
+// give each its own empty set and no push would ever be delivered.
+
+type Push = (text: string) => void;
+
+const g = globalThis as unknown as { __flightSseSubscribers?: Set<Push> };
+const subscribers: Set<Push> = (g.__flightSseSubscribers ??= new Set());
+
+export function subscribe(fn: Push): () => void {
+  subscribers.add(fn);
+  return () => {
+    subscribers.delete(fn);
+  };
+}
+
+// Call each subscriber safely — one dead stream must not take the others down.
+export function broadcast(text: string): void {
+  for (const fn of [...subscribers]) {
+    try {
+      fn(text);
+    } catch {
+      // subscriber's stream is gone; its own cleanup unsubscribes it
+    }
+  }
+}

lib/timeScale.test.ts

@@ -1,81 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { MAX_SCALE, MIN_SCALE, TIME_SCALES, scaleToSlider, sliderToScale } from './timeScale';
-
-const STEPS = TIME_SCALES.length - 1; // 9 intervals across the 10 ladder positions (v0.14.0)
-
-describe('sliderToScale', () => {
-  it('is exact at the endpoints (0 → 1×, 1 → 1000×)', () => {
-    expect(sliderToScale(0)).toBe(MIN_SCALE);
-    expect(sliderToScale(1)).toBe(MAX_SCALE);
-  });
-
-  it('maps each of the 10 positions to the ladder', () => {
-    const expected = [1, 2, 5, 10, 25, 50, 100, 250, 500, 1000];
-    for (let i = 0; i < TIME_SCALES.length; i++) {
-      expect(sliderToScale(i / STEPS)).toBe(expected[i]);
-    }
-  });
-
-  it('is monotonic non-decreasing across the whole range', () => {
-    let prev = sliderToScale(0);
-    for (let i = 1; i <= 2000; i++) {
-      const s = sliderToScale(i / 2000);
-      expect(s).toBeGreaterThanOrEqual(prev);
-      prev = s;
-    }
-  });
-
-  it('only ever returns a ladder value', () => {
-    for (let i = 0; i <= 2000; i++) {
-      expect(TIME_SCALES).toContain(sliderToScale(i / 2000));
-    }
-  });
-
-  it('clamps out-of-range and non-finite input', () => {
-    expect(sliderToScale(-0.5)).toBe(MIN_SCALE);
-    expect(sliderToScale(1.5)).toBe(MAX_SCALE);
-    expect(sliderToScale(NaN)).toBe(MIN_SCALE);
-  });
-});
-
-describe('scaleToSlider', () => {
-  it('is exact at the endpoints (1× → 0, 1000× → 1)', () => {
-    expect(scaleToSlider(1)).toBe(0);
-    expect(scaleToSlider(1000)).toBe(1);
-  });
-
-  it('places each ladder value on its own position', () => {
-    for (let i = 0; i < TIME_SCALES.length; i++) {
-      expect(scaleToSlider(TIME_SCALES[i])).toBeCloseTo(i / STEPS, 12);
-    }
-  });
-
-  it('stays within [0, 1] for in-range scales', () => {
-    for (let s = MIN_SCALE; s <= MAX_SCALE; s++) {
-      const t = scaleToSlider(s);
-      expect(t).toBeGreaterThanOrEqual(0);
-      expect(t).toBeLessThanOrEqual(1);
-    }
-  });
-
-  it('clamps out-of-range and non-finite input', () => {
-    expect(scaleToSlider(0)).toBe(0);
-    expect(scaleToSlider(-3)).toBe(0);
-    expect(scaleToSlider(1001)).toBe(1); // above the ladder top → clamped to 1000× → t=1
-    expect(scaleToSlider(NaN)).toBe(0);
-  });
-});
-
-describe('round-trip', () => {
-  it('sliderToScale(scaleToSlider(s)) === s for every ladder value', () => {
-    for (const s of TIME_SCALES) {
-      expect(sliderToScale(scaleToSlider(s))).toBe(s);
-    }
-  });
-
-  it('maps off-ladder scales to the nearest ladder step by log distance', () => {
-    expect(sliderToScale(scaleToSlider(3))).toBe(2); // ln 3 ≈ 1.10 → closer to 2 (ln ≈ 0.69) than 5 (ln ≈ 1.61)
-    expect(sliderToScale(scaleToSlider(60))).toBe(50); // legacy max from the v0.9.x era sits between 50 and 100, nearer 50
-    expect(sliderToScale(scaleToSlider(200))).toBe(250); // ln 200 ≈ 5.30 → closer to 250 (ln ≈ 5.52) than 100 (ln ≈ 4.61)
-  });
-});

lib/timeScale.ts

@@ -1,33 +0,0 @@
-// Pure mapping helpers for the time-scale slider (v0.9.2, values reworked in v0.14.0) — no
-// game logic, unit-testable in node. The slider has 10 discrete positions on a mixed
-// ×2/×2.5 ladder: 1× → 2× → 5× → 10× → 25× → 50× → 100× → 250× → 500× → 1000×, so each
-// step roughly doubles the speed (matching POST /api/sim's clamp range [1, 1000]).
-
-export const TIME_SCALES = [1, 2, 5, 10, 25, 50, 100, 250, 500, 1000] as const;
-export const MIN_SCALE: number = TIME_SCALES[0];
-export const MAX_SCALE: number = TIME_SCALES[TIME_SCALES.length - 1];
-
-const clamp = (v: number, lo: number, hi: number) => Math.min(hi, Math.max(lo, v));
-
-// t → scale: the position maps to the nearest ladder step. Exact at the endpoints:
-// sliderToScale(0) === 1, sliderToScale(1) === 1000.
-export function sliderToScale(t: number): number {
-  const tt = clamp(Number.isFinite(t) ? t : 0, 0, 1);
-  return TIME_SCALES[clamp(Math.round(tt * (TIME_SCALES.length - 1)), 0, TIME_SCALES.length - 1)];
-}
-
-// scale → t: the nearest ladder position by log distance. Exact at the endpoints:
-// scaleToSlider(1) === 0, scaleToSlider(1000) === 1; round-trips every value in TIME_SCALES.
-export function scaleToSlider(scale: number): number {
-  const s = clamp(Number.isFinite(scale) ? scale : MIN_SCALE, MIN_SCALE, MAX_SCALE);
-  let best = 0;
-  let bestDist = Infinity;
-  for (let i = 0; i < TIME_SCALES.length; i++) {
-    const d = Math.abs(Math.log(s) - Math.log(TIME_SCALES[i]));
-    if (d < bestDist) {
-      bestDist = d;
-      best = i;
-    }
-  }
-  return best / (TIME_SCALES.length - 1);
-}

lib/useGameState.test.ts

@@ -6,7 +6,7 @@ import { fetchState } from './useGameState';
 
 const SNAPSHOT = {
   account: { cash: 20_000, reputation: 10 },
-  simState: { clockMs: 1_750_000_000_000, timeScale: 1, paused: false },
+  simState: { clockMs: 1_750_000_000_000 },
   planes: [],
   packages: [],
 };

lib/useGameState.ts

@@ -28,15 +28,21 @@ export async function fetchState(): Promise<StateSnapshot> {
     (window as unknown as Record<string, unknown>).__flightLastSnapshot = {
       planeIds: snapshot.planes.map((p) => p.id),
       cash: snapshot.account.cash,
-      timeScale: snapshot.simState.timeScale,
+      clockMs: snapshot.simState.clockMs,
       at: Date.now(),
     };
   }
   return snapshot;
 }
 
-// The shell's single polling source (v0.9.0): one GET /api/state loop for the whole page,
+// The shell's single state source (v0.9.0): one snapshot feed for the whole page, so every pane
-// so every pane renders from the same snapshot instead of running its own poll loops.
+// renders from the same snapshot instead of running its own poll loops. ISS-129 (v0.57.0): primary
+// transport is SSE — /api/events pushes a full snapshot after every sim tick; polling stays as an
+// automatic fallback (no event within 5 s of connect, or on stream error) and stops again when fresh
+// events flow. EventSource reconnects natively, so there is no custom reconnect logic here.
+const SSE_URL = '/api/events';
+const SSE_SILENCE_MS = 5_000;
+
 export function useGameState(intervalMs = 1000): GameStateResult {
   const [state, setState] = useState<StateSnapshot | null>(null);
   const [loading, setLoading] = useState(true);
@@ -70,10 +76,54 @@ export function useGameState(intervalMs = 1000): GameStateResult {
   }, []);
 
   useEffect(() => {
-    refresh(); // fetch immediately on mount, don't wait for the first interval tick
+    let pollId: ReturnType<typeof setInterval> | null = null;
-    const id = setInterval(refresh, intervalMs);
+    let silenceTimer: ReturnType<typeof setTimeout> | null = null;
-    return () => clearInterval(id);
+    let closed = false;
-  }, [intervalMs, refresh]);
+
+    const stopPolling = () => {
+      if (pollId !== null) clearInterval(pollId);
+      pollId = null;
+    };
+    // Fallback loop: immediate catch-up fetch, then the old interval.
+    const startPolling = () => {
+      if (closed || pollId !== null) return;
+      refresh();
+      pollId = setInterval(refresh, intervalMs);
+    };
+
+    let source: EventSource | null = null;
+    try {
+      source = new EventSource(SSE_URL);
+    } catch {
+      source = null; // no EventSource support — pure polling below
+    }
+
+    if (source !== null) {
+      source.onmessage = (event) => {
+        try {
+          applySnapshot(JSON.parse(event.data));
+        } catch {
+          // malformed event — the next one overwrites it anyway
+        }
+        stopPolling(); // fresh push flow → polling no longer needed
+        if (silenceTimer !== null) clearTimeout(silenceTimer);
+        silenceTimer = setTimeout(startPolling, SSE_SILENCE_MS); // re-arm on EVERY message: a stream that goes silent after the first event (half-open connection — no onerror fires) must fall back to polling again, or state freezes until reload
+      };
+      source.onerror = () => startPolling(); // stream trouble → poll until pushes resume
+      silenceTimer = setTimeout(startPolling, SSE_SILENCE_MS); // connected but silent for 5 s → poll
+    } else {
+      startPolling();
+    }
+
+    refresh(); // mount: same immediate fetch as before (fast first paint + __flightLastSnapshot)
+
+    return () => {
+      closed = true;
+      source?.close();
+      stopPolling();
+      if (silenceTimer !== null) clearTimeout(silenceTimer);
+    };
+  }, [intervalMs, refresh, applySnapshot]);
 
   return { state, loading, error, refresh, applySnapshot };
 }

lib/useSimClock.test.ts

@@ -1,49 +1,46 @@
 import { describe, expect, it } from 'vitest';
 import { advanceSimClock, type SimClockAnchor } from './useSimClock';
+import { WORLD_TIME_SCALE } from './worldClock';
 
 // ISS-007 (v0.16.1) — the pure extrapolation core of lib/useSimClock.ts. The hook itself is a
 // thin setInterval + re-sync wrapper covered by e2e (panes.spec.ts "ticks smoothly between polls");
-// this suite pins the math: game time advances real-time × timeScale, frozen while paused.
+// this suite pins the math: game time advances real-time × WORLD_TIME_SCALE while something is
+// flying or in repair, and stays frozen at the anchor value while fully grounded (#135).
 
 const anchor = (over: Partial<SimClockAnchor> = {}): SimClockAnchor => ({
   clockMs: 1_750_000_000_000,
   at: 1_000_000,
-  timeScale: 1,
+  advancing: true,
-  paused: false,
   ...over,
 });
 
 describe('advanceSimClock', () => {
-  it('advances by exactly elapsed real-time × timeScale while running', () => {
+  it('advances by exactly elapsed real-time × WORLD_TIME_SCALE while running', () => {
-    expect(advanceSimClock(anchor(), 1_001_000)).toBe(1_750_000_000_000 + 1_000); // scale 1: 1 s real = 1 s game
+    expect(advanceSimClock(anchor(), 1_001_000)).toBe(1_750_000_000_000 + 1_000 * WORLD_TIME_SCALE);
-    expect(advanceSimClock(anchor({ timeScale: 25 }), 1_002_500)).toBe(1_750_000_000_000 + 62_500);
+    // The e2e scenario: ~2.6 s real at the fixed world rate.
-    // The e2e scenario: scale 1000, 2.5 s real → 2 500 game seconds.
+    expect(advanceSimClock(anchor(), 1_002_600)).toBe(1_750_000_000_000 + 2_600 * WORLD_TIME_SCALE);
-    expect(advanceSimClock(anchor({ timeScale: 1000 }), 1_002_500)).toBe(1_750_000_000_000 + 2_500_000);
   });
 
   it('returns the anchor value exactly at zero elapsed', () => {
-    expect(advanceSimClock(anchor({ timeScale: 1000 }), 1_000_000)).toBe(1_750_000_000_000);
+    expect(advanceSimClock(anchor(), 1_000_000)).toBe(1_750_000_000_000);
   });
 
-  it('is frozen while paused regardless of elapsed or scale', () => {
+  it('stays exactly at the anchor value while grounded (frozen, #135)', () => {
-    const a = anchor({ timeScale: 1000, paused: true });
+    const a = anchor({ advancing: false });
-    expect(advanceSimClock(a, 1_000_000)).toBe(1_750_000_000_000);
+    expect(advanceSimClock(a, 1_000_000)).toBe(1_750_000_000_000); // zero elapsed — the anchor value
-    expect(advanceSimClock(a, 2_000_000)).toBe(1_750_000_000_000); // a full second later — still frozen
+    expect(advanceSimClock(a, 1_001_000)).toBe(1_750_000_000_000); // a full second later — still frozen
   });
 
   it('clamps to the anchor value when nowMs is before the anchor (clock skew), never backwards', () => {
-    expect(advanceSimClock(anchor({ timeScale: 1000 }), 999_999)).toBe(1_750_000_000_000);
+    expect(advanceSimClock(anchor(), 999_999)).toBe(1_750_000_000_000);
-    expect(advanceSimClock(anchor({ paused: true }), 999_999)).toBe(1_750_000_000_000);
+    expect(advanceSimClock(anchor({ advancing: false }), 999_999)).toBe(1_750_000_000_000);
   });
 
-  it('mirrors the server tick model (tickOnce): advance = elapsed × timeScale while actively polled', () => {
+  it('mirrors the server tick model (tickOnce): advance = elapsed × WORLD_TIME_SCALE while actively polled', () => {
     // lib/sim/engine.ts: clockMs += min(now − lastRealTickMs, MAX_TICK_ELAPSED_MS) × timeScale.
     // For gaps under the 2 s clamp the client extrapolation is exactly the server's own formula.
-    const scale = 50;
     for (const gap of [1, 250, 999, 1_999]) {
-      expect(advanceSimClock(anchor({ timeScale: scale }), 1_000_000 + gap)).toBe(
+      expect(advanceSimClock(anchor(), 1_000_000 + gap)).toBe(1_750_000_000_000 + gap * WORLD_TIME_SCALE);
-        1_750_000_000_000 + gap * scale,
-      );
     }
   });
 });

lib/useSimClock.ts

@@ -2,57 +2,51 @@
 
 import { useEffect, useRef, useState } from 'react';
 import type { StateSnapshot } from './game/state';
+import { WORLD_TIME_SCALE } from './worldClock';
 
 // ISS-007 (v0.16.1): the sim clock ticks smoothly on the CLIENT between polls instead of
-// jumping once per snapshot. The server's authoritative rate is exactly real-time × timeScale
+// jumping once per snapshot. The server's authoritative rate is exactly real-time × scale
 // (tickOnce in lib/sim/engine.ts: advance = min(elapsed, MAX_TICK_ELAPSED_MS) × timeScale), so
 // client-side extrapolation mirrors the server's own model. Every new snapshot re-anchors to
-// server truth, bounding any drift by network latency only.
+// server truth, bounding any drift by network latency only. ISS-117 (v0.52.0): the scale is the
+// fixed WORLD_TIME_SCALE; #135 (v0.62.0): while nothing is happening it stays FROZEN at the anchor
+// value — mirroring the server's freeze, so polls re-anchor without any jump.
 
 export interface SimClockAnchor {
   // Server truth at anchor time — the snapshot's simState.clockMs.
   clockMs: number;
   // Date.now() when that snapshot was received.
   at: number;
-  timeScale: number;
+  // Whether the world clock is advancing (any plane flying or in repair).
-  paused: boolean;
+  advancing: boolean;
 }
 
-// Pure core of the extrapolation — mirrors tickOnce: while running, game time advances by
+// Pure core of the extrapolation — mirrors tickOnce: while advancing, game time advances by
-// real-time × timeScale; while paused it is frozen (advance 0). nowMs before `at` clamps to
+// real-time × WORLD_TIME_SCALE; while fully grounded it stays frozen at the anchor value (#135).
-// the anchor value instead of going backwards. Unit-testable in node.
+// nowMs before `at` clamps to the anchor value instead of going backwards. Unit-testable in node.
 export function advanceSimClock(anchor: SimClockAnchor, nowMs: number): number {
-  if (anchor.paused) return anchor.clockMs;
+  if (!anchor.advancing) return anchor.clockMs; // frozen while everything is grounded (#135)
-  return anchor.clockMs + Math.max(0, nowMs - anchor.at) * anchor.timeScale;
+  return anchor.clockMs + Math.max(0, nowMs - anchor.at) * WORLD_TIME_SCALE;
 }
 
 // ~10 fps display refresh — smooth for a seconds-precision wall clock without busy re-renders.
 const DISPLAY_TICK_MS = 100;
 
-export interface SimClockControls {
-  // EFFECTIVE controls (optimistic pending scale / current pause), not the snapshot's:
-  // UI changes take effect on click/drag without waiting for a confirming snapshot.
-  timeScale: number;
-  paused: boolean;
-}
-
 // Returns the display clockMs to render, or null until the first snapshot arrives.
-export function useSimClock(snapshot: StateSnapshot | null, controls: SimClockControls): number | null {
+export function useSimClock(snapshot: StateSnapshot | null): number | null {
   const anchorRef = useRef<SimClockAnchor | null>(null);
   const [displayMs, setDisplayMs] = useState<number | null>(null);
 
-  // Re-sync on every snapshot AND effective-control change: snap to server truth. The snapshot
+  // Re-sync on every snapshot: snap to server truth. The snapshot object is fresh per poll
-  // object is fresh per poll (useGameState), so this runs once per poll cycle as well.
+  // (useGameState), so this runs once per poll cycle as well.
   useEffect(() => {
     if (!snapshot) return;
-    anchorRef.current = {
+    // Mirror of the server's shouldAdvanceTime (lib/sim/engine.ts): full rate only while a plane
-      clockMs: snapshot.simState.clockMs,
+    // is flying or in repair, frozen otherwise (#135). One line on purpose — keep it in sync.
-      at: Date.now(),
+    const advancing = snapshot.planes.some((p) => p.status === 'flying' || p.status === 'repairing');
-      timeScale: controls.timeScale,
+    anchorRef.current = { clockMs: snapshot.simState.clockMs, at: Date.now(), advancing };
-      paused: controls.paused,
-    };
     setDisplayMs(advanceSimClock(anchorRef.current, Date.now()));
-  }, [snapshot, controls.timeScale, controls.paused]);
+  }, [snapshot]);
 
   useEffect(() => {
     const id = setInterval(() => {

lib/worldClock.ts

@@ -0,0 +1,10 @@
+// ISS-117 (v0.52.0): the world clock runs at a fixed rate — no player-facing time controls.
+// Server-side the effective scale lives in the sim_state row (seeded to this value); client-side
+// lib/useSimClock.ts extrapolates between polls at this same constant, so keep them in sync here.
+export const WORLD_TIME_SCALE = 24;
+
+// #135 (v0.62.0): a fully grounded fleet FREEZES the world clock — shouldAdvanceTime
+// (lib/sim/engine.ts) gates every tick and advanceSimClock (lib/useSimClock.ts) holds its anchor
+// value, so polls re-anchor without any jump. This replaces the v0.56.0 idle slowdown
+// (IDLE_WORLD_TIME_SCALE = WORLD_TIME_SCALE / 24): final semantics are ISS-117's — frozen when
+// everything is grounded, full rate otherwise.

package.json

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

scripts/build-world-airports.mjs

@@ -0,0 +1,179 @@
+#!/usr/bin/env node
+// Build data/airports_world.csv from the full OurAirports world dump (ISS-079, v0.44.0).
+//
+// Pipeline: download → keep `large_airport` rows only (same density curation as the EU file,
+// v0.2.8) → greedy 40 km haversine clustering → one airport per cluster ("the biggest").
+// v0.68.0 (ISS-144): additionally keeps a sparse set of "special" remote airports — non-large
+// fixed-wing rows with no large airport within 1000 km, greedily thinned to one per ~1000 km
+// region (scheduled service + larger types preferred) so Antarctica, the high Arctic, Alaska,
+// northern Canada and far islands are represented without over-filling empty regions.
+// The output keeps the exact OurAirports header so lib/airports.ts parses it unchanged.
+//
+// Usage: node scripts/build-world-airports.mjs   (writes data/airports_world.csv, prints stats)
+// Aborts without writing anything if the download fails after retries — no fabricated data.
+
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+
+const SOURCE_URL = 'https://davidmegginson.github.io/ourairports-data/airports.csv'; // legacy ourairports.com/data URL is dead (see CHANGELOG v0.1.0)
+const OUT_FILE = path.join(import.meta.dirname, '..', 'data', 'airports_world.csv');
+const CLUSTER_RADIUS_KM = 40; // mid of the issue's 30–50 km range — n≈1k rows makes O(n²) trivial
+// v0.61.0 (ISS-097): mirrors REMOTE_RADIUS_KM in lib/airports.ts — "no other airport within this
+// radius" is what makes a small airport worth keeping (Antarctica, high Arctic, far islands).
+const REMOTE_RADIUS_KM = 1000;
+
+// Same fixed-wing type set as INCLUDED_TYPES in lib/airports.ts (standalone copy — the script must
+// stay dependency-free): all fixed-wing airports plus seaplane bases.
+const FIXED_WING_TYPES = new Set(['airport', 'small_airport', 'medium_airport', 'large_airport', 'seaplane_base']);
+
+// Standalone copy of isRemote in lib/airports.ts, for CSV rows: true when `row` has no member of
+// `others` within REMOTE_RADIUS_KM. Callers pass disjoint sets (the row itself is not in `others`).
+function isRemoteRow(row, others) {
+  for (const o of others) {
+    if (haversineKm(row, o) <= REMOTE_RADIUS_KM) return false;
+  }
+  return true;
+}
+
+// --- Minimal RFC-4180 parser (same semantics as lib/airports.ts parseCsv, standalone copy) ---
+function parseCsv(text) {
+  const rows = [];
+  let row = [];
+  let field = '';
+  let inQuotes = false;
+  for (let i = 0; i < text.length; i++) {
+    const c = text[i];
+    if (inQuotes) {
+      if (c === '"') {
+        if (text[i + 1] === '"') { field += '"'; i++; } else inQuotes = false;
+      } else field += c;
+    } else if (c === '"') inQuotes = true;
+    else if (c === ',') { row.push(field); field = ''; }
+    else if (c === '\n') { row.push(field); rows.push(row); row = []; field = ''; }
+    else if (c !== '\r') field += c;
+  }
+  if (field.length > 0 || row.length > 0) { row.push(field); rows.push(row); }
+  const [header, ...rest] = rows;
+  return rest
+    .filter((r) => r.length === header.length && !(r.length === 1 && r[0] === ''))
+    .map((r) => Object.fromEntries(header.map((h, i) => [h, r[i]])));
+}
+
+function haversineKm(a, b) {
+  const toRad = (d) => (d * Math.PI) / 180;
+  const dLat = toRad(b.latitude_deg - a.latitude_deg);
+  const dLon = toRad(b.longitude_deg - a.longitude_deg);
+  const x =
+    Math.sin(dLat / 2) ** 2 +
+    Math.cos(toRad(a.latitude_deg)) * Math.cos(toRad(b.latitude_deg)) * Math.sin(dLon / 2) ** 2;
+  return 2 * 6371 * Math.asin(Math.min(1, Math.sqrt(x)));
+}
+
+// "Biggest" proxy — the CSV carries no passenger/traffic data, so rank by service signals:
+// scheduled_service first, then an IATA code (commercially served), then a Wikipedia page,
+// then file order. ponytail: good-enough proxy for hub-vs-satellite; swap in pax data if it ever exists.
+function biggestOf(members) {
+  const rank = (r) => [r.scheduled_service === 'yes' ? 1 : 0, r.iata_code ? 1 : 0, r.wikipedia_link ? 1 : 0];
+  let best = members[0];
+  for (const m of members.slice(1)) {
+    const rb = rank(m);
+    const rk = rank(best);
+    if (rb[0] > rk[0] || (rb[0] === rk[0] && rb[1] > rk[1]) || (rb[0] === rk[0] && rb[1] === rk[1] && rb[2] > rk[2])) best = m;
+  }
+  return best; // ties keep the lowest file order (members are in file order)
+}
+
+async function download(url, attempts = 3) {
+  for (let i = 1; i <= attempts; i++) {
+    try {
+      const res = await fetch(url);
+      if (!res.ok) throw new Error(`HTTP ${res.status}`);
+      const text = await res.text();
+      if (!(text.startsWith('"id"') || text.startsWith('id,')) || text.split('\n').length < 10_000) throw new Error('response does not look like the OurAirports CSV');
+      return text;
+    } catch (err) {
+      console.error(`download attempt ${i}/${attempts} failed: ${err.message}`);
+      if (i === attempts) throw err;
+      await new Promise((r) => setTimeout(r, 2000 * i));
+    }
+  }
+  throw new Error('unreachable');
+}
+
+const text = await download(SOURCE_URL);
+const [headerLine] = text.split('\n');
+const header = headerLine.replace(/\r$/, '').split(',').map((h) => h.replace(/^"|"$/g, ''));
+if (header.length !== 19) { console.error(`unexpected header (${header.length} columns): ${headerLine}`); process.exit(1); }
+
+const allRows = parseCsv(text);
+// v0.61.0 (ISS-097): curation runs over ALL fixed-wing rows, not just large_airport — the remote
+// pass below needs the full pool to test against.
+const fixed = allRows.filter((r) => FIXED_WING_TYPES.has(r.type));
+const large = fixed.filter((r) => r.type === 'large_airport');
+console.log(`downloaded ${allRows.length} rows; ${fixed.length} are fixed-wing, ${large.length} of them large_airport`);
+
+// Greedy clustering in file order: a row joins the first cluster whose anchor is within the
+// radius, otherwise it starts a new one. Deterministic — same input, same output. Returns the
+// "biggest" member (one airport per cluster) plus the clusters themselves for reporting.
+function clusterWinners(rows) {
+  const clusters = []; // { anchorIdx (into rows), members }
+  for (let i = 0; i < rows.length; i++) {
+    let joined = false;
+    for (const c of clusters) {
+      if (haversineKm(rows[i], rows[c.anchorIdx]) <= CLUSTER_RADIUS_KM) { c.members.push(i); joined = true; break; }
+    }
+    if (!joined) clusters.push({ anchorIdx: i, members: [i] });
+  }
+  const winners = clusters.map((c) => biggestOf(c.members.map((i) => rows[i])));
+  return { winners, clusters };
+}
+
+const { winners: kept, clusters: largeClusters } = clusterWinners(large);
+const multiClusters = [];
+for (const c of largeClusters) {
+  if (c.members.length > 1) {
+    const winner = biggestOf(c.members.map((i) => large[i]));
+    multiClusters.push({
+      city: winner.municipality || winner.name,
+      keptIcao: winner.icao_code || winner.ident,
+      dropped: c.members.map((i) => large[i]).filter((r) => r !== winner).map((r) => `${r.icao_code || r.ident} (${r.name})`),
+    });
+  }
+}
+
+// v0.68.0 (ISS-144): "special" remote airports — one per ~REMOTE_RADIUS_KM region. Candidates are
+// the non-large fixed-wing rows with no large airport within REMOTE_RADIUS_KM (unchanged), sorted
+// by priority (scheduled service, then type rank medium < small < seaplane, then numeric id) and
+// accepted greedily: a candidate joins only if it is at least REMOTE_RADIUS_KM from EVERY already
+// accepted special — no special airport within 1000 km of another. One per ~1000 km region, so
+// central Australia / Canada edges get a handful of well-chosen strips instead of dozens; this
+// subsumes the old 40 km remote clustering (deleted).
+const TYPE_RANK = { medium_airport: 0, small_airport: 1, seaplane_base: 2 }; // legacy 'airport' ranks last
+const candidates = fixed.filter((r) => r.type !== 'large_airport' && isRemoteRow(r, kept));
+candidates.sort(
+  (a, b) =>
+    Number(b.scheduled_service === 'yes') - Number(a.scheduled_service === 'yes') ||
+    (TYPE_RANK[a.type] ?? 3) - (TYPE_RANK[b.type] ?? 3) ||
+    Number(a.id) - Number(b.id),
+);
+const remoteKept = [];
+for (const c of candidates) {
+  if (remoteKept.every((k) => haversineKm(c, k) >= REMOTE_RADIUS_KM)) remoteKept.push(c);
+}
+
+// --- Guards (fail loud before writing anything) ---
+const finalRows = [...kept, ...remoteKept];
+const key = (r) => r.icao_code || r.ident; // the effective ICAO consumers key by (toGeoJson fallback)
+const keys = new Set(finalRows.map(key));
+if (keys.size !== finalRows.length) { console.error('duplicate ICAO in curated set — aborting'); process.exit(1); }
+for (const must of ['EDDF', 'UNNT', 'LPPD']) { // EDDF is the seed hub; UNNT (Novosibirsk) + LPPD (Ponta Delgada) pin the 409-backstop test pair
+  if (!keys.has(must)) { console.error(`required airport ${must} missing from curated set — aborting`); process.exit(1); }
+}
+if (remoteKept.length === 0) { console.error('no remote airports found in the dump — curation rule broken, aborting'); process.exit(1); }
+if (finalRows.length < 300 || finalRows.length > 2500) { console.error(`unexpected row count ${finalRows.length}`); process.exit(1); }
+
+await fs.writeFile(OUT_FILE, [headerLine.replace(/\r$/, ''), ...finalRows.map((r) => header.map((h) => `"${String(r[h] ?? '').replace(/"/g, '""')}"`).join(','))].join('\n') + '\n', 'utf8');
+
+console.log(`wrote ${OUT_FILE}: ${kept.length} large + ${remoteKept.length} remote = ${finalRows.length} rows (${large.length - kept.length} large dropped into ${multiClusters.length} multi-airport clusters)`);
+console.log('sample merged cities (kept ← dropped):');
+for (const c of multiClusters.slice(0, 15)) console.log(`  ${c.city}: kept ${c.keptIcao} ← ${c.dropped.join(', ')}`);