Merge pull request 'v1.10.0: top-bar Log out (ISS-157) + Admin button gated to admins (ISS-158)' (#164) from feat/topbar-logout-admin-gate into master

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

CHANGELOG.md

@@ -1,5 +1,74 @@
 # Changelog
 
+## v1.10.0 — 2026-09-27 22:31
+- **Top-bar Log out (ISS-157).** New `Log out` button as the last child of the top bar (`components/Map.tsx`) — flex row puts it top-right, no CSS. Same three steps as the admin panel's in-modal button: best-effort `POST /api/logout` with the session header, clear the stored session id, drop back to the sign-in screen via the existing `onLogout`. The two in-modal Log out buttons are kept (zero e2e churn).
+- **Admin button only for admins (ISS-158).** The top-bar `Admin` button now renders only when `/api/me` reports `admin: true` — hidden entirely, not disabled. No server change: the endpoint already returns `{username, admin}`; `app/page.tsx` now parses that body on its mount probe and passes `isAdmin` down AppShell → Map. The probe also re-runs after a form sign-in (bumped `probeKey`) so `isAdmin` tracks the user who just signed in, not whoever was probed before — an admin logging out followed by a non-admin signing in no longer sees the Admin button.
+- **E2E.** New test in `e2e/map.spec.ts`: top-bar Log out → sign-in form visible and app header gone (mirrors the existing admin-panel logout assertion).
+
+## v1.9.0 — 2026-09-27 20:57
+- **E2E speedup follow-up (test-only, no game code changed).** `e2e/relocation.spec.ts`'s self-heal helper `flyHomeViaApi` now fast-forwards its cleanup legs at the v1.8.0 `FAST = 10_000` rate instead of a blanket `SCALE = 1000` — every scale-dependent wait in that file is a pure arrival wait (status `'available'` / `locationIcao === HUB`) with no mid-leg observation, so the higher rate is safe and the now-unused `SCALE` constant was dropped. Expected CI wall time for the file drops from ~40 s to ~25 s (~2–3 s off test 1, ~10–11 s each off tests 2 and 3). Test 3's deliberate `setScale(page, 1)` guard is untouched; `map.spec.ts` wheel-zoom (real-time-bound) and `multiplayer.spec.ts`'s N-player clock (measures sim-vs-real elapsed time) stay as-is.
+
+## v1.8.0 — 2026-09-27 20:13
+- **E2E speedup (test-only, no game code changed).** Every Playwright spec that fast-forwards legs now uses the fastest rate its assertions allow instead of a blanket `SCALE = 1000`: pure arrival waits (no mid-leg observation) run at `FAST` — a lagged tick can only land a plane sooner, never skip an observed state. Expected CI wall time for the affected tests drops ~5–6× overall (e.g. the antimeridian test's relocation chains go from ~3 min to ~15 s per direction; two-planes' parallel-flight test loses its ~24 s afterEach heal leg).
+- **Per-test rates.** `actions.spec.ts` + `hover.spec.ts` + `two-planes.spec.ts`: new local `FAST = 10_000` for expiry fast-forwards, landing waits and fly-home cleanups. `queue.spec.ts`: same `FAST`, plus `CHAIN = 4_000` for the auto-chain observation (max per-tick advance 2 s × S stays below the LEMD-length leg's ~1e7 sim-ms duration so one lagged tick can't complete it before a poll sees the chained state); its refuel-before-chained-leg test moves to an explicit `2_000` with the fuel lower bound relaxed from `> 1.3×required` to `> required` (at 2_000× the snapshot can land ~0.4×required into leg 2's burn under dind load; a wrong top-up level still lands far below the bound, and the exact level stays pinned by the unchanged cash assertion). `map-interactions.spec.ts`: `FAST = 50_000` for chain hops (≤3400 km each) and arrival waits.
+- **Kept at SCALE = 1000 where mid-leg observation is real.** The antimeridian crossing leg itself (freshness gate ~700 km ≈ 5 s of flight + >3 fresh samples assume ~14 s of real-time flight), the queue spec's final-hop chain window (EHAM→EDDF is only 2_587 sim-s — at higher rates a `/api/state` 500-retry gap could advance past it), and map-interactions' mid-flight click window. The antimeridian crossing dispatch now sets SCALE BEFORE the fly POST: with FAST-rate chains, a leftover fast rate would let the dispatch tick itself consume most of the leg before the setScale lands (flake path).
+- **hover.spec.ts fleet-row test restructured.** It no longer speeds up to 1000× and then freezes mid-leg; it asserts `flying` from the fly endpoint's OWN post-action snapshot (no poll race) and freezes at scale 1 immediately — same pattern as its package-hover sibling, so the ~10 s leg can't land under the assertions.
+- **two-planes parallel-flight test.** Landing waits move to FAST, and a new both-grounded poll after the cleanup dispatches lets the range-edge return legs finish while the clock is still at FAST — previously afterEach's `healPlaneHome` paid that ~24 s leg back at SCALE.
+
+## v1.7.0 — 2026-09-26 20:24
+- **Multiplayer step 12/12 (ISS-116): multiplayer test coverage.** The final campaign step closes the two remaining verification gaps with tests only — no production game code changed: the #135 freeze rule (`shouldAdvanceTime`) already counts ALL planes regardless of owner, and the mint hook has supported a username override since v1.1.0 (the e2e helper just never forwarded it).
+- **E2E.** New `e2e/multiplayer.spec.ts` (serial) plays two live sessions: player A is the suite's usual local player; player B is a second account minted through the same hook with a username override. Test 1 verifies the N-player clock end-to-end (#135 × ISS-113): while A flies and B stays grounded, the world clock advances on every read (one owner airborne is enough to keep time moving), then after A lands — EVERY player grounded — the clock freezes exactly across ~2.5 s of real idleness. Test 2 verifies ownership isolation: both sessions see the same shared fleet with `ownerId`/`ownerName`, A gets 403 "not your plane" on B's starter (fly AND sell — the 403 must beat B's last-plane 409), B gets 403 on A's, a grant to local moves only A's account row while B's stays untouched, and both sessions see the v1.6.0 `players` summary with per-owner plane counts.
+- **Test hooks.** `e2e/auth.ts`'s `mintPlayerSession(page)` now forwards an optional username (the route already supported it). New FLIGHT_TEST_HOOKS-gated `POST /api/test/delete-plane {username}` — deletes every plane owned by that player's row (any bound packages unbound first), idempotent for unknown usernames, returns the local-scoped snapshot like its siblings. Needed because B's onboarding starter is unsellable (per-owner last-plane guard) and would break later specs' single-fleet self-heal within the same CI run; an `afterAll` deletes it even when tests fail.
+- **Tests.** Unit: two new engine tests — a tickOnce-level N-player clock test (A flying + B grounded → advances at exactly the fixed world rate; all owners grounded → frozen with the real-time anchor still tracking, ISS-113) and the symmetric spawn-quality case (local leads → MAX picks local's row, not "prefer non-local"). No existing e2e spec changed: they are additive-safe against a second player.
+
+## v1.6.0 — 2026-09-26 19:35
+- **Multiplayer step 11/12 (ISS-115): leaderboard panel.** Small UI listing every player in the world with cash, reputation and plane count, rendered from snapshot data — no new endpoint. The known gap from step 8 is closed additively: `getStateSnapshot(playerId)` (`lib/game/state.ts`) now projects a `players` array (`PlayerSummary[]`: `{ id, username, cash, reputation, planeCount }`, planeCount = planes owned) into the ONE shared snapshot projection, so GET /api/state, action responses and every SSE frame all carry it in sync automatically. No extra query — the players rows were already loaded for the v1.4.0 owner joins; plane counts are a single in-memory pass over the already-loaded plane rows.
+- **UI.** New "Leaderboard" button on the right side of the map top bar (next to Admin) opens the panel as a modal, reusing the existing `Modal` + `.pane-btn` conventions — per the 2026-09-23 placement decision it is NOT embedded in the left pane. New `components/Leaderboard.tsx`: one row per player (username, cash via `formatCash`, reputation, plane count), sorted by reputation descending with cash then username as deterministic tie-breaks so rows don't shuffle between snapshots on equal rep. Small `.leaderboard` table styles mirror `.admin-rows`.
+- **OpenAPI.** New `PlayerSummary` schema; `StateSnapshot` gains required `players: PlayerSummary[]` — documented in `lib/openapi.ts`, path count unchanged at eighteen.
+- **Tests.** Unit: new `getStateSnapshot players` suite in `lib/game/state.test.ts` against a throwaway seeded DB — single-player regression guard (exactly one row for the seeded local account with its starter plane) and a two-player case asserting cash/reputation/planeCount per owner (local keeps 1, player B counts both of its planes). The `/api/state` route test's exact key-list assertion gains `players`; all four typed snapshot fixtures (`state.test.ts`, `mapData.test.ts`, `deriveEvents.test.ts`, `right-pane.test.ts`) gain the new required field. No e2e spec changes: existing specs assert per-key `toHaveProperty` on planes/packages only, and CI's single minted player sees a one-row leaderboard — behavior unchanged; the button/modal wiring is covered by tsc + the modal pattern already exercised in admin.spec.ts.
+
+## v1.5.0 — 2026-09-26 19:06
+- **Multiplayer step 7/12 (ISS-111): shared-world spawn quality rule.** The #101 decision point is resolved with the agreed default proposal: spawned pool packages scale to the MAX reputation across ALL player rows, so job rewards track the best-progressed player and nobody is stuck on low-rep jobs. New `getSharedWorldReputation(inst)` in `lib/db/localPlayer.ts` — one SQL `MAX(reputation)` over the players table, 0 when there are no players (the rep bonus floors at ×1 either way). The engine's pool spawner (`spawnPoolPackages`, `lib/sim/engine.ts`) reads it once per spawn batch and passes it through `generatePoolPackage(..., reputation)`, replacing the last singleton `getLocalPlayer` job-quality read; the env-gated `/api/test/create-package` hook — which documents itself as carrying "the same job quality as engine spawns" — follows the same rule so no surface can drift.
+- **Sites that stay on 'local' (deliberate).** The seeded local row is still inserted at first-run seeding (`lib/db/client.ts`) and staged by the env-gated `/api/test/*` economy hooks (add-cash, set-cash) — those stage an account, not job quality. Seed-time package generation (`buildSeed`) passes no reputation at all and keeps defaulting to `STARTING_REPUTATION`, so fresh worlds are byte-identical to before.
+- **Tests.** Unit: two new engine tests in the `spawnPoolPackages` suite — with a second player at rep 60 vs local's starting rep, every spawned package's reward matches an independent recomputation (rewardFor × rep bonus × special multiplier) at the MAX and provably not at local's; single-player regression guard asserts one row ⇒ quality is that row's own reputation, identical to the pre-v1.5.0 singleton read. No e2e spec changes: CI plays a single minted player, where MAX equals that player's rep — behavior unchanged.
+
+## v1.4.0 — 2026-09-26 18:35
+- **Multiplayer step 8/12 (ISS-112): per-player snapshot + shared market view with owner info.** The state snapshot is now a true SHARED-WORLD view on every surface that serves it. `getStateSnapshot(playerId)` in `lib/game/state.ts` gains two additive fields: every plane row carries `ownerId` + `ownerName` (players.username via planes.owner_id — the snapshot lists ALL planes, so panes can tell whose plane is whose), and every package row carries `carrierName` (players.username of the carrying plane's owner, joined package → planeId → planes.owner_id → players; null when unassigned). One players-table read per projection serves both joins. `account` stays the acting session player's row (v1.3.0) — no renames or removals anywhere, so existing clients and e2e assertions keep working unchanged.
+- **SSE frames are now PER PLAYER.** The #101 decision point is resolved: visibility of other players' planes is ON by default — there is no toggle (a shared world you can't see in is pointless; nobody asked for a privacy switch). `lib/sse.ts` keys its subscriber registry by player id (`subscribe(playerId, fn)`, new `subscribedPlayerIds()`), and the engine's tick broadcast (`broadcastState` in `lib/sim/engine.ts`) projects ONE snapshot per connected session's player id — N clients = N projections per tick, N is tiny — fanning each frame out to that player's group only. Every client now sees its own account row in every pushed frame instead of the seeded local player's. The connect frame and all pushes come from the SAME shared projection (`getStateSnapshot` + `sseFrame`), as does GET /api/state, so no two surfaces can drift; `/api/events` subscribes under `auth.player.id`.
+- **UI.** Left pane fleet rows show an owner badge (username) next to the model name — every plane in the world is visible and labeled. Right pane open-package rows show a carrier-name badge when `carrierName` is set (open packages are unassigned today, so it renders once assignment lands; the join + render path exist now). One small `.owner-badge` style mirrors `.special-badge`.
+- **OpenAPI.** `PlaneState` gains required `ownerId`/`ownerName`; `PackageState` gains required nullable `carrierName` — documented in `lib/openapi.ts`, path count unchanged at eighteen.
+- **Tests.** Unit: `lib/sse.test.ts` reworked for the keyed registry (per-player isolation, empty-group drop, throwing subscriber, idempotent unsubscribe); new `/api/state` route tests assert all planes carry owner info including a foreign player's plane, and that carrierName joins through planeId → owner_id → username while unassigned packages stay null; new `/api/events` test opens TWO streams (local + a second minted player) and asserts each tick push carries the stream's OWN account row — plus connect-frame parity assertions (owner fields present, same projection as GET). Fixture helpers in `state.test.ts`, `deriveEvents.test.ts`, `right-pane.test.ts`, `mapData.test.ts` gain the new fields. No e2e spec changes: all pane/API assertions are additive-safe (`toContainText`, per-key `toHaveProperty`), and CI's existing suite covers the UI paths.
+
+## v1.3.0 — 2026-09-26 17:05
+- **Multiplayer step 6/12 (ISS-110): per-player money & reputation in the engine + snapshot.** The last singleton economy accesses are converted to per-player rows. `deliverPackages` (`lib/sim/engine.ts`) now pays cash + reputation to the DELIVERED PLANE'S OWNER row (`plane.owner_id`, fresh read per award so multiple deliveries in one tick all count), and the ISS-082 auto-chain top-up debits the same owner's row with their own rep discount — a plane owned by player B earning or refueling never touches any other account. `getStateSnapshot(playerId)` sources the snapshot's `account` field from the ACTING SESSION player's row; the field name/shape (`{cash, reputation}`) is unchanged and OpenAPI stays untouched. Session-scoped callers thread it: `/api/state`, every action response (`performAction`) and the SSE connect frame all pass `auth.player.id`.
+- **Sites that stay on 'local' (deliberate).** The shared SSE broadcast has no acting session — it passes `LOCAL_PLAYER.id` until per-player frames land (#112). The engine's pool-spawn job-quality read stays on the seeded local row: pools are SHARED world state (packages have no owner), so there is no single owning player whose rep should set quality; a ponytail comment names #112 as the decision point. The env-gated `/api/test/*` economy hooks (add-cash, set-cash) remain admin-style tools with no session — they stage the SEEDED local account, which is exactly the player the e2e suite plays via `mint-player-session`'s default; create-package's job-quality read matches the engine spawn.
+- **Tests.** Unit: two new engine tests in `lib/sim/engine.test.ts` — a plane owned by player B delivers → B's cash/rep increase and local is untouched (both directions), and an empty-tank landing with a queued leg debits the top-up from B (B's rep discount) while local stays put; new `/api/state` route test mints a second account with a distinct economy and asserts `account` carries THAT session player's row. All existing suites pass unchanged — every seeded plane is owned by 'local', so single-player behavior is byte-identical. No e2e spec changes: the minted e2e session IS the local player, and CI's existing suite covers the UI paths.
+
+## v1.2.0 — 2026-09-26 16:25
+- **Multiplayer step 4/12 (ISS-108): per-player onboarding.** New registrants start with a starter plane at EDDF, not just cash: `buildStarterPlane(airports, id)` is extracted from `buildSeed` in `lib/game/seed.ts` (byte-identical values to the fresh-install seed — same model, full tank, hub location, no RNG draws; only the id differs) and reused by `POST /api/register`, which inserts it owned by the new player. The test-only mint hook does the same for custom usernames, so e2e-created accounts are onboarded like real ones. ponytail comment marks legacy players without planes (pre-v1.2.0 test mints) as out of scope — they keep exactly what they had.
+- **Multiplayer step 5/12 (ISS-109): `planes.owner_id` + ownership checks.** New `owner_id TEXT NOT NULL` column in the raw DDL and Drizzle mirror; one-time guarded migration (`migrateColumns`, PRAGMA table_info check) backfills every pre-v1.2.0 row to `'local'` via SQLite's constant ALTER default, so a migrated world's planes all belong to the seeded local player exactly as before — idempotent on second open. All seven plane actions plus `repairPlane` now take the session player's id and reject foreign planes with 403 "not your plane" through one shared `assertPlaneOwner()` (checked right after the 404 fetch, so ownership errors win over state errors); `performAction` passes `auth.player.id` as its callback's second argument, keeping every route a pure pass-through. Economy is per-player: new `getPlayer(inst, id)` / `updatePlayerEconomy(inst, id, patch)` in `lib/db/localPlayer.ts` replace the local-only helpers at every action call site (a non-local buyer now debits their own cash; `getLocalPlayer` stays for the snapshot and engine until per-player views land). The sell-plane last-plane guard is PER OWNER — you can't sell your last plane even if other players' planes exist, and selling one of two of yours is fine. `buyPlane` stamps the buyer as owner of the delivered plane.
+- **Mint hook default → kamilkrzywda.** The e2e specs play with the seeded world's planes by id (`plane-starter`), so the no-body mint now resolves to the existing local player that owns them after backfill — creating NO new rows; a custom username still creates a fresh account, now WITH onboarding. `e2e/auth.ts` and every spec are untouched: they keep working because the session they mint is the owner's.
+- **OpenAPI.** The seven plane-targeted action endpoints document the new 403 (buy-plane has no plane target, so it gains none); path count unchanged at eighteen — `openapi.test.ts`'s per-endpoint error-code lists updated to match.
+- **Tests.** Unit: new backfill migration test in `lib/db/client.test.ts` builds a pre-v1.2.0 file (two planes without owner_id) and verifies open() backfills both to `'local'`, does not re-seed, and is a no-op on second open (a post-migration owner change survives reopen); new ownership suite in `lib/game/actions.test.ts` — 403 for every action when the session player doesn't own the plane (both directions), per-owner last-plane guard against the world total, buyer stamped as owner with their own cash debited and local's untouched; register + mint route tests assert exactly one onboarding plane at EDDF owned by the new account. All 74 existing action call sites in `actions.test.ts` now pass `'local'`; no e2e spec changes needed (the minted session is the owner's).
+
+## v1.1.0 — 2026-09-26 14:39
+- **Multiplayer step 3/12 (ISS-107): every game route is session-guarded; new accounts can register.** `lib/auth.ts` grows a shared guard on top of the v0.71.0 session plumbing: `requireAuth(req)` (X-Flight-Session header) and `requireAuthSse(req)` (header OR `?session=` query — EventSource cannot set headers), both returning either `{ok, inst, user, player}` or a ready-made 401/500 response. The guard joins `players` on the account's username, so the seeded admin resolves to the v1.0.0 local player row; an account with no players row is a data error → 500. Coverage: `/api/state`, all eight action routes (one `performAction(req, fn)` call site in `lib/game/actions.ts` guards them all), and the SSE stream (`/api/events`, validated at connect — ponytail comment names the mid-stream ceiling). Exempt by design: `/api/version`, `/api/openapi`, `/api/airports`, `/api/login`, `/api/register`, `/api/logout`, `/api/me`, the admin CRUD (own guard), and every `/api/test/*` hook.
+- **POST /api/register.** Strict body validation (exactly `username` + `password`; unknown fields 400); username lowercased, then 3–20 chars of `[a-z0-9_-]` else 400; password ≥8 chars else 400; 409 when taken. Creates the users row (scrypt via the same `hashPassword()` login verifies) AND a players row with the starter economy (`STARTING_CASH`/`STARTING_REPUTATION`) — one randomUUID shared by both rows — then mints a session immediately and returns `{sessionId, user}` like `/api/login`, so sign-up needs no second round-trip.
+- **Sign-in screen replaces the shell until authenticated.** New `components/SignInScreen.tsx`: full-screen dark panel with two forms (sign in / create account) sharing one submit path; errors surface in a single `role=alert` line. `app/page.tsx` gates on it: stored session → `/api/me` check on mount (stale id cleared, network error falls through to sign-in), then the game shell mounts only when authenticated — so an unauthenticated browser never polls `/api/state`. New client module `lib/authClient.ts` owns the localStorage key (`flight.session`) and builds the `X-Flight-Session` header; every app fetch (state poll, SSE URL, action POSTs, fly/queue in Map) now carries it. Admin panel logout drops back to the sign-in screen via a new `onLogout` prop (page → Map → AdminPanel).
+- **E2E session hook + spec updates.** New test-only `POST /api/test/mint-player-session` (FLIGHT_TEST_HOOKS=1, 404 elsewhere — like its `/api/test/*` siblings): creates the users+players rows for a username if missing and mints a session, idempotent across container restarts since the CI DB volume persists. `e2e/auth.ts` mints + applies it per test (context extraHTTPHeaders for spec-side requests, localStorage init script for the app's own fetches); every guarded-route spec authenticates in a beforeEach; events.spec uses the real client path (`?session=`); api.spec/openapi tests track the new eighteenth endpoint. Admin spec reworked: unauthenticated visitors see the sign-in screen (no shell), wrong credentials error there, and logout returns to it.
+- **Tests.** Unit: new `lib/auth.test.ts` (hash round-trip; 401 on missing/unknown/expired session; admin→local player join; 500 on missing players row), register route tests (validation matrix, shared-id rows + starter economy + minted session, case-insensitive 409) and mint-hook tests (gate off → 404 even with CI's FLIGHT_TEST_HOOKS=1 env — stubbed explicitly, default-username creation, idempotent re-mint, bad usernames). All existing state/events/action route tests now mint a session for the seeded admin user in beforeAll. OpenAPI: `/api/register` documented (RegisterRequest schema; 200/400/409) — spec is now eighteen paths.
+
+## v1.0.0 — 2026-09-24 14:20
+- **Multiplayer step 1/12 (ISS-105): `players` table replaces the singleton `account`.** New `players` table (`id TEXT PK`, `provider`, `username`, `cash REAL`, `reputation REAL`) in the raw DDL (`lib/db/client.ts`) and a matching Drizzle entry (`lib/db/schema.ts`; `AccountRow` → `PlayerRow`). **One-time migration**: on every `open()`, if the legacy `account` table still exists (sqlite_master check, same guard style as the v0.12.0 contracts migration) AND `players` is empty, its single row is copied into a seeded local player — id `local`, provider `local`, username `kamilkrzywda` (so a later step can join players↔users on username) with cash/reputation carried over — and `account` is dropped. Idempotent: fresh DBs never have `account`, already-migrated files no longer do either, so it runs exactly once per legacy file. **Fresh worlds**: the DDL no longer creates `account`; first-run seeding (empty-check flipped from `COUNT(*) FROM account` to `players`) inserts the local player row directly with the same starting cash/reputation as before.
+- **No behavior change — temporary single-player helper.** Every pre-multiplayer read/write of the singleton economy now goes through ONE small module, `lib/db/localPlayer.ts`: `getLocalPlayer(inst)` (resolves the `players` row where id = 'local', throws if missing) and `updateLocalPlayerEconomy(inst, {cash?, reputation?})`. Call sites converted: snapshot (`lib/game/state.ts`), all five actions (`flyPlane` refuel, abandon penalty, buy/sell plane, repair — `lib/game/actions.ts`), the engine's delivery awards + chain top-up + spawn reputation read (`lib/sim/engine.ts`), and the three test hooks (add-cash / set-cash / create-package). The `/api/state` snapshot keeps its exact `account: {cash, reputation}` field name and values, so OpenAPI is untouched — 17 paths, same schemas.
+- **Tests.** Unit: fresh DB now asserts the seeded local player row (`local`/`local`/`kamilkrzywda`, starting cash/reputation) AND that no `account` table exists; new dedicated migration test builds a minimal legacy file containing only an `account` table and verifies open() copies its row into the local player, drops `account`, and is a no-op on second open. All existing suites (actions, engine, client, buy/sell/abandon routes) now read/write through the helper; the admin rows CRUD test's PK-less-table example moves from `account` to `sim_state` (the only remaining PK-less table), and the admin tables-list expectation swaps `account` → `players`. No new e2e spec — behavior is byte-identical and CI's existing suite covers the UI paths; a fresh-stack boot exercises the new seed path.
+
+## v0.73.0 — 2026-09-24 12:24
+- **New-package toasts removed.** The client-side snapshot diff in `lib/deriveEvents.ts` no longer emits "New package available" info toasts when a contract appears (the user was spammed by them); the first-snapshot guard and every other event type — delivered, expired, landed, bought, sold — are unchanged.
+
+## 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).

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

@@ -62,43 +62,43 @@ describe('admin rows CRUD', () => {
     adminSession = await createSession(await getGameDb(), 'admin-kamilkrzywda');
   });
 
-  it('GET returns columns + rows with __rowid for the PK-less account table', async () => {
+  it('GET returns columns + rows with __rowid for the PK-less sim_state table', async () => {
-    const res = await getRows('account');
+    const res = await getRows('sim_state');
     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);
+    for (const col of ['clock_ms', 'time_scale']) expect(body.columns).toContain(col);
-    expect(body.rows).toHaveLength(1); // the single seeded account row
+    expect(body.rows).toHaveLength(1); // the single seeded sim_state row
     expect(typeof body.rows[0].__rowid).toBe('number');
-    expect(typeof body.rows[0].cash).toBe('number');
+    expect(typeof body.rows[0].clock_ms).toBe('number');
   });
 
   it('PUT updates a cell and the change survives a re-fetch', async () => {
-    const before = await (await getRows('account')).json();
+    const before = await (await getRows('sim_state')).json();
-    const originalCash = (before as { rows: Array<Record<string, unknown>> }).rows[0].cash;
+    const originalClockMs = (before as { rows: Array<Record<string, unknown>> }).rows[0].clock_ms;
 
-    const res = await putRow('account', { rowid: 1, values: { cash: 424_242 } });
+    const res = await putRow('sim_state', { rowid: 1, values: { clock_ms: 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();
+    const body = await (await getRows('sim_state')).json();
-    expect((body as { rows: Array<Record<string, unknown>> }).rows[0].cash).toBe(424_242);
+    expect((body as { rows: Array<Record<string, unknown>> }).rows[0].clock_ms).toBe(424_242);
 
-    // Restore the original cash so later tests see a sane world.
+    // Restore the original clock so later tests see a sane world.
-    const restore = await putRow('account', { rowid: 1, values: { cash: originalCash } });
+    const restore = await putRow('sim_state', { rowid: 1, values: { clock_ms: originalClockMs } });
     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 } });
+    const badCol = await putRow('sim_state', { 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: {} });
+    const empty = await putRow('sim_state', { rowid: 1, values: {} });
     expect(empty.status).toBe(400);
 
-    const noRowid = await putRow('account', { values: { cash: 1 } });
+    const noRowid = await putRow('sim_state', { values: { clock_ms: 1 } });
     expect(noRowid.status).toBe(400);
   });
 

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

@@ -74,8 +74,8 @@ function sqlError(err: unknown): Response {
 }
 
 // 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
+// 500, cap 1000). rowid is exposed as __rowid so the PK-less tables (sim_state) are editable
-// editable like any other. Unknown table → 404; bad limit → 400.
+// 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;

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

@@ -70,7 +70,7 @@ describe('GET /api/admin/tables', () => {
     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']) {
+    for (const expected of ['packages', 'players', 'planes', 'sessions', 'sim_state', 'users']) {
       expect(names, `missing ${expected}`).toContain(expected);
     }
     expect(names.some((n) => n.startsWith('sqlite_'))).toBe(false);

app/api/events/route.test.ts

@@ -2,9 +2,15 @@ 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 { createSession, hashPassword } from '@/lib/auth';
+import * as schema from '@/lib/db/schema';
+import { getGameDb } from '@/lib/db/client';
+import { getPlayer } from '@/lib/db/localPlayer';
+import { tickNow } from '@/lib/sim/engine';
 import { GET } from './route';
 
 let dir: string;
+let sessionId: string;
 
 beforeAll(async () => {
   // Same pattern as app/api/state/route.test.ts: point the DB singleton at a throwaway file so
@@ -12,6 +18,8 @@ beforeAll(async () => {
   // 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');
+  // v1.1.0 (ISS-107): /api/events is session-guarded — mint a session for the seeded admin user.
+  sessionId = await createSession(await getGameDb(), 'admin-kamilkrzywda');
 });
 
 afterAll(async () => {
@@ -20,8 +28,18 @@ afterAll(async () => {
 });
 
 describe('GET /api/events', () => {
+  // v1.1.0 (ISS-107): EventSource cannot set headers, so the client passes the session as a query
+  // param — this test exercises exactly that path (requireAuthSse).
+  const req = () => new Request(`http://localhost/api/events?session=${sessionId}`);
+
+  it('rejects an unauthenticated request with 401', async () => {
+    const res = await GET(new Request('http://localhost/api/events'));
+    expect(res.status).toBe(401);
+    expect(((await res.json()) as { error: string }).error).toMatch(/authentication required/i);
+  });
+
   it('streams SSE with the current snapshot as the first event', async () => {
-    const res = await GET();
+    const res = await GET(req());
     expect(res.status).toBe(200);
     expect(res.headers.get('content-type')).toContain('text/event-stream');
     expect(res.headers.get('cache-control')).toBe('no-cache');
@@ -34,8 +52,63 @@ describe('GET /api/events', () => {
       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');
+
+      // v1.4.0 (ISS-112): the connect frame comes from the SAME shared projection as GET /api/state —
+      // planes carry owner info and packages carry carrierName, so pushed frames can never drift.
+      const planes = snap.planes as Array<Record<string, unknown>>;
+      expect(planes.length).toBeGreaterThanOrEqual(1);
+      for (const key of ['ownerId', 'ownerName']) {
+        expect(planes[0], `plane.${key}`).toHaveProperty(key);
+      }
+      const pkgs = snap.packages as Array<Record<string, unknown>>;
+      for (const p of pkgs) expect(p, 'package.carrierName').toHaveProperty('carrierName');
     } finally {
       await reader.cancel(); // → stream cancel → unsubscribe from the registry
     }
   });
+
+  it('pushes PER-PLAYER frames on tick — each stream gets its own account row (v1.4.0, ISS-112)', async () => {
+    const inst = await getGameDb();
+    // A second player with a distinct economy + their own session (rows minted like /api/register).
+    const idB = 'test-player-events-b';
+    await inst.db.insert(schema.users).values({
+      id: idB, username: 'e2e-events-b', passwordHash: hashPassword('unused'), admin: false, createdAt: Date.now(),
+    });
+    await inst.db.insert(schema.players).values({
+      id: idB, provider: 'local', username: 'e2e-events-b', cash: 77_777.77, reputation: 3,
+    });
+    const sidB = await createSession(inst, idB);
+    const localCash = (await getPlayer(inst, 'local')).cash;
+
+    // Two live streams: the seeded local player and player B — both subscribed under their own ids.
+    const resA = await GET(new Request(`http://localhost/api/events?session=${sessionId}`));
+    const readerA = (resA.body as ReadableStream<Uint8Array>).getReader();
+    const resB = await GET(new Request(`http://localhost/api/events?session=${sidB}`));
+    const readerB = (resB.body as ReadableStream<Uint8Array>).getReader();
+
+    // Reads the next `data:` event off a stream and parses its snapshot.
+    const readFrame = async (reader: ReadableStreamDefaultReader<Uint8Array>) => {
+      const { value } = await reader.read();
+      return JSON.parse(new TextDecoder().decode(value).slice('data: '.length)) as Record<string, unknown>;
+    };
+
+    try {
+      // Drain both connect frames (each already carries its own account row)…
+      const connectA = await readFrame(readerA);
+      const connectB = await readFrame(readerB);
+      expect((connectA.account as { cash: number }).cash).toBeCloseTo(localCash, 9);
+      expect((connectB.account as { cash: number }).cash).toBeCloseTo(77_777.77, 9);
+
+      // …then one tick — the broadcast projects per connected player id and fans each frame out to its group only.
+      await tickNow();
+      const pushA = await readFrame(readerA);
+      const pushB = await readFrame(readerB);
+
+      expect((pushA.account as { cash: number }).cash).toBeCloseTo(localCash, 9); // A gets LOCAL's row…
+      expect((pushB.account as { cash: number }).cash).toBeCloseTo(77_777.77, 9); // …B gets ITS OWN — never crossed over
+    } finally {
+      await readerA.cancel(); // → stream cancel → unsubscribe from the registry
+      await readerB.cancel();
+    }
+  });
 });

app/api/events/route.ts

@@ -1,3 +1,4 @@
+import { requireAuthSse } from '@/lib/auth';
 import { getStateSnapshot, sseFrame } from '@/lib/game/state';
 import { subscribe } from '@/lib/sse';
 
@@ -5,12 +6,22 @@ import { subscribe } from '@/lib/sse';
 // 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.
+// pushed frames, so a connect never costs one full-history frame. v1.1.0 (ISS-107): guarded —
+// EventSource cannot set headers, so the session comes from X-Flight-Session OR ?session=
+// (requireAuthSse). ponytail: validated at CONNECT only — a session deleted/expired mid-stream keeps
+// receiving pushes until it reconnects (private infra, 7-day sessions; per-push re-validation would
+// be one indexed lookup per tick if that ever matters). v1.4.0 (ISS-112): frames are PER PLAYER — the
+// route subscribes under THIS session's player id and the engine projects one snapshot per connected
+// player, pushing each frame only to its group; connect + pushed frames share one projection
+// (getStateSnapshot + sseFrame), so they can never drift.
 
 const encoder = new TextEncoder();
 const HEARTBEAT_MS = 15_000;
 
-export async function GET() {
+export async function GET(req: Request) {
+  const auth = await requireAuthSse(req);
+  if (!auth.ok) return auth.response;
+
   let heartbeat: ReturnType<typeof setInterval> | null = null;
   let unsubscribe: (() => void) | null = null;
   const cleanup = () => {
@@ -22,10 +33,12 @@ export async function GET() {
     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.
+      // for the next push instead of seeing an out-of-order frame. v1.4.0 (ISS-112): connect frame and
-      getStateSnapshot()
+      // every later push carry THIS session's player projection — subscribe keys on auth.player.id so
+      // the tick broadcast only sends this client frames projected for its own account row.
+      getStateSnapshot(auth.player.id)
         .then((snapshot) => {
-          unsubscribe = subscribe((text) => {
+          unsubscribe = subscribe(auth.player.id, (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).

app/api/market/buy-plane/route.test.ts

@@ -2,18 +2,22 @@ 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 * as schema from '@/lib/db/schema';
+import { getLocalPlayer, updateLocalPlayerEconomy } from '@/lib/db/localPlayer';
 import { getGameDb } from '@/lib/db/client';
+import { createSession } from '@/lib/auth';
 import { PLANE_TYPES } from '@/lib/game/catalog';
 import { POST } from './route';
 
 let dir: string;
+let sessionId: 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-buy-api-'));
   process.env.FLIGHT_DB_PATH = path.join(dir, 'buy.db');
+  // v1.1.0 (ISS-107): action routes are session-guarded — mint a session for the seeded admin user.
+  sessionId = await createSession(await getGameDb(), 'admin-kamilkrzywda');
 });
 
 afterAll(async () => {
@@ -21,7 +25,14 @@ afterAll(async () => {
   await fs.rm(dir, { recursive: true, force: true });
 });
 
-const post = (body: unknown) => POST(new Request('http://localhost/api/market/buy-plane', { method: 'POST', body: JSON.stringify(body) }));
+const post = (body: unknown) =>
+  POST(
+    new Request('http://localhost/api/market/buy-plane', {
+      method: 'POST',
+      headers: { 'X-Flight-Session': sessionId },
+      body: JSON.stringify(body),
+    }),
+  );
 
 describe('POST /api/market/buy-plane', () => {
   it('rejects a missing model, unknown fields and unknown models with 400', async () => {
@@ -38,14 +49,13 @@ describe('POST /api/market/buy-plane', () => {
     expect(((await res.json()) as { error: string }).error).toMatch(/insufficient funds/i);
 
     // Cash untouched by the failed attempt.
-    const account = (await (await getGameDb()).db.select().from(schema.account))[0];
+    expect((await getLocalPlayer(await getGameDb())).cash).toBe(20_000);
-    expect(account.cash).toBe(20_000);
   });
 
   it('deducts the full price and adds a full-tank plane at EDDF to the snapshot', async () => {
-    const { db } = await getGameDb();
+    const inst = await getGameDb();
-    // Single-row account table — top up cash so the purchase can succeed.
+    // Local player row — top up cash so the purchase can succeed.
-    await db.update(schema.account).set({ cash: 500_000 });
+    await updateLocalPlayerEconomy(inst, { cash: 500_000 });
 
     const res = await post({ model: 'atr72' });
     expect(res.status).toBe(200);

app/api/market/buy-plane/route.ts

@@ -27,5 +27,5 @@ export async function POST(req: Request) {
   }
 
   const model = input.model;
-  return performAction((inst) => buyPlane(inst, model));
+  return performAction(req, (inst, playerId) => buyPlane(inst, model, playerId));
 }

app/api/market/sell-plane/route.test.ts

@@ -4,17 +4,22 @@ import path from 'node:path';
 import { eq } from 'drizzle-orm';
 import { afterAll, beforeAll, describe, expect, it } from 'vitest';
 import * as schema from '@/lib/db/schema';
+import { getLocalPlayer } from '@/lib/db/localPlayer';
 import { getGameDb } from '@/lib/db/client';
+import { createSession } from '@/lib/auth';
 import { PLANE_TYPES, SELL_FRACTION } from '@/lib/game/catalog';
 import { POST } from './route';
 
 let dir: string;
+let sessionId: 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-sell-api-'));
   process.env.FLIGHT_DB_PATH = path.join(dir, 'sell.db');
+  // v1.1.0 (ISS-107): action routes are session-guarded — mint a session for the seeded admin user.
+  sessionId = await createSession(await getGameDb(), 'admin-kamilkrzywda');
 });
 
 afterAll(async () => {
@@ -22,7 +27,14 @@ afterAll(async () => {
   await fs.rm(dir, { recursive: true, force: true });
 });
 
-const post = (body: unknown) => POST(new Request('http://localhost/api/market/sell-plane', { method: 'POST', body: JSON.stringify(body) }));
+const post = (body: unknown) =>
+  POST(
+    new Request('http://localhost/api/market/sell-plane', {
+      method: 'POST',
+      headers: { 'X-Flight-Session': sessionId },
+      body: JSON.stringify(body),
+    }),
+  );
 
 describe('POST /api/market/sell-plane', () => {
   it('rejects a missing planeId and unknown fields with 400', async () => {
@@ -48,7 +60,7 @@ describe('POST /api/market/sell-plane', () => {
     const { db } = await getGameDb();
     // A second, grounded plane so "flying" is the reason for rejection.
     await db.insert(schema.planes).values({
-      id: 'plane-extra', model: 'atr72', status: 'available', fuel: 100, maxFuel: PLANE_TYPES.atr72.maxFuel,
+      id: 'plane-extra', ownerId: 'local', model: 'atr72', status: 'available', fuel: 100, maxFuel: PLANE_TYPES.atr72.maxFuel,
       locationIcao: 'EDDF', destIcao: null, lat: 50.03, lon: 8.57, departureSimTime: null,
     });
     await db.update(schema.planes).set({ status: 'flying' }).where(eq(schema.planes.id, 'plane-extra'));
@@ -59,10 +71,10 @@ describe('POST /api/market/sell-plane', () => {
   });
 
   it('sells a grounded second plane for SELL_FRACTION of the catalog price', async () => {
-    const { db } = await getGameDb();
+    const inst = await getGameDb();
     // The previous test left 'plane-extra' in the DB (now flying) — ground it.
-    await db.update(schema.planes).set({ status: 'available' }).where(eq(schema.planes.id, 'plane-extra'));
+    await inst.db.update(schema.planes).set({ status: 'available' }).where(eq(schema.planes.id, 'plane-extra'));
-    const cashBefore = (await db.select().from(schema.account))[0].cash;
+    const cashBefore = (await getLocalPlayer(inst)).cash;
 
     const res = await post({ planeId: 'plane-extra' });
     expect(res.status).toBe(200);

app/api/market/sell-plane/route.ts

@@ -27,5 +27,5 @@ export async function POST(req: Request) {
   }
 
   const planeId = input.planeId;
-  return performAction((inst) => sellPlane(inst, planeId));
+  return performAction(req, (inst, playerId) => sellPlane(inst, planeId, playerId));
 }

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

@@ -4,16 +4,21 @@ import path from 'node:path';
 import { eq } from 'drizzle-orm';
 import { afterAll, beforeAll, describe, expect, it } from 'vitest';
 import * as schema from '@/lib/db/schema';
+import { getLocalPlayer } from '@/lib/db/localPlayer';
 import { getGameDb } from '@/lib/db/client';
+import { createSession } from '@/lib/auth';
 import { POST } from './route';
 
 let dir: string;
+let sessionId: 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-abandon-api-'));
   process.env.FLIGHT_DB_PATH = path.join(dir, 'abandon.db');
+  // v1.1.0 (ISS-107): action routes are session-guarded — mint a session for the seeded admin user.
+  sessionId = await createSession(await getGameDb(), 'admin-kamilkrzywda');
 });
 
 afterAll(async () => {
@@ -21,9 +26,11 @@ afterAll(async () => {
   await fs.rm(dir, { recursive: true, force: true });
 });
 
-const post = (id: string) => POST(new Request(`http://localhost/api/packages/${id}/abandon`, { method: 'POST' }), {
+const post = (id: string) =>
-  params: Promise.resolve({ id }),
+  POST(
-});
+    new Request(`http://localhost/api/packages/${id}/abandon`, { method: 'POST', headers: { 'X-Flight-Session': sessionId } }),
+    { params: Promise.resolve({ id }) },
+  );
 
 // Insert a LOADED package bound to the starter plane with a long deadline. Returns
 // the exact created/deadline times so tests can compute the penalty from the
@@ -84,8 +91,9 @@ describe('POST /api/packages/:id/abandon', () => {
 
   it('abandons a loaded package for the exact formula penalty and returns the full snapshot', async () => {
     const times = await insertLoadedPackage('p-ab', 1_000); // created "now" → near the 15% floor
-    const { db } = await getGameDb();
+    const inst = await getGameDb();
-    const cashBefore = (await db.select().from(schema.account))[0].cash;
+    const { db } = inst;
+    const cashBefore = (await getLocalPlayer(inst)).cash;
 
     const res = await post('p-ab');
     expect(res.status).toBe(200);
@@ -103,6 +111,7 @@ describe('POST /api/packages/:id/abandon', () => {
       'fuelPricePerL',
       'packages',
       'planes',
+      'players', // v1.6.0 (ISS-115) — leaderboard rows ride on every snapshot
       'sellFraction',
       'simState',
     ]);

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

@@ -7,7 +7,7 @@ import { abandonPackage, performAction } from '@/lib/game/actions';
 // id; 409 wrong status or the plane is in flight. On success returns the full
 // state snapshot.
 
-export async function POST(_req: Request, ctx: { params: Promise<{ id: string }> }) {
+export async function POST(req: Request, ctx: { params: Promise<{ id: string }> }) {
   const { id } = await ctx.params;
-  return performAction((inst) => abandonPackage(inst, id));
+  return performAction(req, (inst, playerId) => abandonPackage(inst, id, playerId));
 }

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

@@ -5,15 +5,19 @@ import { eq } from 'drizzle-orm';
 import { afterAll, beforeAll, describe, expect, it } from 'vitest';
 import * as schema from '@/lib/db/schema';
 import { getGameDb } from '@/lib/db/client';
+import { createSession } from '@/lib/auth';
 import { POST } from './route';
 
 let dir: string;
+let sessionId: 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-load-api-'));
   process.env.FLIGHT_DB_PATH = path.join(dir, 'load.db');
+  // v1.1.0 (ISS-107): action routes are session-guarded — mint a session for the seeded admin user.
+  sessionId = await createSession(await getGameDb(), 'admin-kamilkrzywda');
 });
 
 afterAll(async () => {
@@ -22,9 +26,14 @@ afterAll(async () => {
 });
 
 const post = (id: string, body: unknown) =>
-  POST(new Request(`http://localhost/api/packages/${id}/load`, { method: 'POST', body: JSON.stringify(body) }), {
+  POST(
-    params: Promise.resolve({ id }),
+    new Request(`http://localhost/api/packages/${id}/load`, {
-  });
+      method: 'POST',
+      headers: { 'X-Flight-Session': sessionId },
+      body: JSON.stringify(body),
+    }),
+    { params: Promise.resolve({ id }) },
+  );
 
 describe('POST /api/packages/:id/load', () => {
   it('rejects a missing/non-string planeId and unknown fields with 400', async () => {
@@ -102,6 +111,7 @@ describe('POST /api/packages/:id/load', () => {
       'fuelPricePerL',
       'packages',
       'planes',
+      'players', // v1.6.0 (ISS-115) — leaderboard rows ride on every snapshot
       'sellFraction',
       'simState',
     ]);

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

@@ -31,5 +31,5 @@ export async function POST(req: Request, ctx: { params: Promise<{ id: string }>
   }
 
   const planeId = input.planeId;
-  return performAction((inst) => loadPackage(inst, id, planeId));
+  return performAction(req, (inst, playerId) => loadPackage(inst, id, planeId, playerId));
 }

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

@@ -5,15 +5,19 @@ import { eq } from 'drizzle-orm';
 import { afterAll, beforeAll, describe, expect, it } from 'vitest';
 import * as schema from '@/lib/db/schema';
 import { getGameDb } from '@/lib/db/client';
+import { createSession } from '@/lib/auth';
 import { POST } from './route';
 
 let dir: string;
+let sessionId: 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-fly-api-'));
   process.env.FLIGHT_DB_PATH = path.join(dir, 'fly.db');
+  // v1.1.0 (ISS-107): action routes are session-guarded — mint a session for the seeded admin user.
+  sessionId = await createSession(await getGameDb(), 'admin-kamilkrzywda');
 });
 
 afterAll(async () => {
@@ -22,9 +26,14 @@ afterAll(async () => {
 });
 
 const post = (planeId: string, body: unknown) =>
-  POST(new Request(`http://localhost/api/planes/${planeId}/fly`, { method: 'POST', body: JSON.stringify(body) }), {
+  POST(
-    params: Promise.resolve({ planeId }),
+    new Request(`http://localhost/api/planes/${planeId}/fly`, {
-  });
+      method: 'POST',
+      headers: { 'X-Flight-Session': sessionId },
+      body: JSON.stringify(body),
+    }),
+    { params: Promise.resolve({ planeId }) },
+  );
 
 describe('POST /api/planes/:planeId/fly', () => {
   it('rejects a missing/non-string destIcao and unknown fields with 400', async () => {
@@ -93,6 +102,7 @@ describe('POST /api/planes/:planeId/fly', () => {
       'fuelPricePerL',
       'packages',
       'planes',
+      'players', // v1.6.0 (ISS-115) — leaderboard rows ride on every snapshot
       'sellFraction',
       'simState',
     ]);

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

@@ -31,5 +31,5 @@ export async function POST(req: Request, ctx: { params: Promise<{ planeId: strin
   }
 
   const destIcao = input.destIcao;
-  return performAction((inst) => flyPlane(inst, planeId, destIcao));
+  return performAction(req, (inst, playerId) => flyPlane(inst, planeId, destIcao, playerId));
 }

app/api/planes/[planeId]/queue/cancel/route.ts

@@ -30,5 +30,5 @@ export async function POST(req: Request, ctx: { params: Promise<{ planeId: strin
   }
 
   const index = input.index as number;
-  return performAction((inst) => cancelQueuedLeg(inst, planeId, index));
+  return performAction(req, (inst, playerId) => cancelQueuedLeg(inst, planeId, index, playerId));
 }

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

@@ -31,5 +31,5 @@ export async function POST(req: Request, ctx: { params: Promise<{ planeId: strin
   }
 
   const destIcao = input.destIcao;
-  return performAction((inst) => queueLeg(inst, planeId, destIcao));
+  return performAction(req, (inst, playerId) => queueLeg(inst, planeId, destIcao, playerId));
 }

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

@@ -6,7 +6,7 @@ import { performAction, repairPlane } from '@/lib/game/actions';
 // repair is a free no-op (cost 0). 404 unknown id; 409 plane not grounded or insufficient funds.
 // On success returns the full state snapshot.
 
-export async function POST(_req: Request, ctx: { params: Promise<{ planeId: string }> }) {
+export async function POST(req: Request, ctx: { params: Promise<{ planeId: string }> }) {
   const { planeId } = await ctx.params;
-  return performAction((inst) => repairPlane(inst, planeId));
+  return performAction(req, (inst, playerId) => repairPlane(inst, planeId, playerId));
 }

app/api/register/route.test.ts

@@ -0,0 +1,75 @@
+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 { verifyPassword } from '@/lib/auth';
+import { STARTING_CASH, STARTING_REPUTATION } from '@/lib/game/seed';
+import { POST } from './route';
+
+// v1.1.0 (ISS-107) — register route tests. Same temp-DB pattern as the login route tests: the DB
+// singleton points at a throwaway file, and every created user is verified through verifyPassword().
+
+let dir: string;
+
+beforeAll(async () => {
+  dir = await fs.mkdtemp(path.join(os.tmpdir(), 'flight-register-api-'));
+  process.env.FLIGHT_DB_PATH = path.join(dir, 'register.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/register', { method: 'POST', body: JSON.stringify(body) }));
+
+describe('POST /api/register', () => {
+  it('rejects malformed bodies and bad credentials with 400', async () => {
+    for (const body of [
+      {}, // missing both fields
+      { username: 'ab', password: 'longenough' }, // too short
+      { username: 'a'.repeat(21), password: 'longenough' }, // too long
+      { username: 'bad user!', password: 'longenough' }, // bad charset (space + !)
+      { username: 'validuser', password: 'short' }, // password < 8 chars
+      { username: 'validuser', password: 'longenough', bogus: 1 }, // unknown field
+    ]) {
+      const res = await post(body);
+      expect(res.status).toBe(400);
+      expect(((await res.json()) as { error: string }).error).toBeTruthy();
+    }
+  });
+
+  it('creates users + players rows sharing one id, with the starter economy, and mints a session', async () => {
+    const res = await post({ username: 'NewUser42', password: 'correct-horse-1' });
+    expect(res.status).toBe(200);
+    const body = (await res.json()) as { sessionId: string; user: { username: string; admin: boolean } };
+    expect(body.user).toEqual({ username: 'newuser42', admin: false }); // input lowercased
+    expect(body.sessionId).toMatch(/^[0-9a-f-]{36}$/);
+
+    const inst = await getGameDb();
+    const userRow = inst.raw.exec('SELECT id, password_hash FROM users WHERE username = ?', ['newuser42'])[0].values[0];
+    const playerRow = inst.raw.exec('SELECT id, provider, cash, reputation FROM players WHERE username = ?', ['newuser42'])[0].values[0];
+    expect(String(playerRow[0])).toBe(String(userRow[0])); // one UUID for both rows
+    expect(verifyPassword('correct-horse-1', String(userRow[1]))).toBe(true);
+    expect(String(playerRow[1])).toBe('local');
+    expect(Number(playerRow[2])).toBe(STARTING_CASH);
+    expect(Number(playerRow[3])).toBe(STARTING_REPUTATION);
+
+    // v1.2.0 (ISS-108): onboarding — exactly one starter plane at EDDF, owned by the new player.
+    const planes = inst.raw.exec('SELECT id, owner_id, location_icao FROM planes WHERE owner_id = ?', [String(userRow[0])])[0].values;
+    expect(planes).toHaveLength(1);
+    expect(String(planes[0][2])).toBe('EDDF');
+
+    // The minted session resolves to the new user.
+    const sess = inst.raw.exec('SELECT user_id FROM sessions WHERE id = ?', [body.sessionId])[0].values[0];
+    expect(String(sess[0])).toBe(String(userRow[0]));
+  });
+
+  it('returns 409 when the username is taken (case-insensitively)', async () => {
+    await post({ username: 'taken-user', password: 'correct-horse-1' });
+    const res = await post({ username: 'Taken-User', password: 'different-pass-2' });
+    expect(res.status).toBe(409);
+    expect(((await res.json()) as { error: string }).error).toMatch(/already taken/i);
+  });
+});

app/api/register/route.ts

@@ -0,0 +1,82 @@
+import { randomUUID } from 'node:crypto';
+import * as schema from '@/lib/db/schema';
+import { getGameDb, persist } from '@/lib/db/client';
+import { createSession, hashPassword } from '@/lib/auth';
+import { loadAirportsGeoJson } from '@/lib/airports';
+import { buildStarterPlane, STARTING_CASH, STARTING_REPUTATION } from '@/lib/game/seed';
+
+// v1.1.0 (ISS-107) — POST /api/register
+//   body { username: string, password: string } (both required; unknown fields 400).
+//   Username: 3–20 chars of [a-z0-9_-], case-insensitive input stored lowercase → else 400.
+//   Password: min 8 chars → else 400. Creates the users row (scrypt via hashPassword — same
+//   digest shape verifyPassword() checks) AND a players row with the starter economy (the exact
+//   values seedEmpty() gives a fresh world). 409 when the username is taken. On success mints a
+//   session immediately and returns { sessionId, user } like /api/login — no second round-trip.
+
+const USERNAME_RE = /^[a-z0-9_-]{3,20}$/;
+
+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 = typeof input.username === 'string' ? input.username.toLowerCase() : '';
+  if (!USERNAME_RE.test(username)) {
+    return Response.json(
+      { error: 'username must be 3–20 characters of a-z, 0-9, _ or -' },
+      { status: 400 },
+    );
+  }
+  const password = input.password;
+  if (typeof password !== 'string' || password.length < 8) {
+    return Response.json({ error: 'password must be at least 8 characters' }, { status: 400 });
+  }
+
+  const inst = await getGameDb();
+  const taken = inst.raw.exec('SELECT 1 FROM users WHERE username = ?', [username]);
+  if (taken[0]?.values?.length) {
+    return Response.json({ error: 'username is already taken' }, { status: 409 });
+  }
+
+  // One UUID for both rows — the account and its player share an id; requireAuth still joins on username.
+  const id = randomUUID();
+  inst.raw.run('INSERT INTO users (id, username, password_hash, admin, created_at) VALUES (?, ?, ?, 0, ?)', [
+    id,
+    username,
+    hashPassword(password),
+    Date.now(),
+  ]);
+  await inst.db.insert(schema.players).values({
+    id,
+    provider: 'local',
+    username,
+    cash: STARTING_CASH,
+    reputation: STARTING_REPUTATION,
+  });
+  // v1.2.0 (ISS-108): onboarding — the new player's first login also grounds a starter plane at EDDF
+  // for them, reusing buildSeed's starter builder (same values as the fresh-install seed).
+  // ponytail: legacy players without planes (pre-v1.2.0 test mints) get none — out of scope here.
+  const fc = await loadAirportsGeoJson();
+  const starter = buildStarterPlane(
+    fc.features.map((f) => ({ icao: f.properties.icao, name: f.properties.name, lat: f.properties.lat, lon: f.properties.lon })),
+    randomUUID(),
+  );
+  const { queue, ...starterCols } = starter;
+  await inst.db.insert(schema.planes).values({ ...starterCols, ownerId: id, queue: JSON.stringify(queue ?? []) });
+  await persist(inst);
+
+  const sessionId = await createSession(inst, id);
+  return Response.json({ sessionId, user: { username, admin: false } });
+}

app/api/state/route.test.ts

@@ -2,12 +2,17 @@ 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 { eq } from 'drizzle-orm';
 import { loadAirportsGeoJson } from '@/lib/airports';
 import { haversineKm } from '@/lib/geo';
 import { FUEL_PRICE_PER_L, PLANE_TYPES, SELL_FRACTION } from '@/lib/game/catalog';
+import { createSession, hashPassword } from '@/lib/auth';
+import * as schema from '@/lib/db/schema';
+import { getGameDb } from '@/lib/db/client';
 import { GET } from './route';
 
 let dir: string;
+let sessionId: string;
 
 beforeAll(async () => {
   // Point the app's DB singleton at a throwaway file so this test never
@@ -15,8 +20,14 @@ beforeAll(async () => {
   // vitest gives each test file its own module registry (fresh singleton).
   dir = await fs.mkdtemp(path.join(os.tmpdir(), 'flight-state-'));
   process.env.FLIGHT_DB_PATH = path.join(dir, 'state.db');
+  // v1.1.0 (ISS-107): /api/state is session-guarded — mint a session for the seeded admin user
+  // (no password needed: createSession only inserts into sessions; the guard joins players on
+  // username → the 'local' row).
+  sessionId = await createSession(await getGameDb(), 'admin-kamilkrzywda');
 });
 
+const req = () => new Request('http://localhost/api/state', { headers: { 'X-Flight-Session': sessionId } });
+
 afterAll(async () => {
   delete process.env.FLIGHT_DB_PATH;
   await fs.rm(dir, { recursive: true, force: true });
@@ -24,7 +35,7 @@ afterAll(async () => {
 
 describe('GET /api/state', () => {
   it('returns 200 with the full snapshot shape', async () => {
-    const res = await GET();
+    const res = await GET(req());
     expect(res.status).toBe(200);
     expect(res.headers.get('content-type')).toContain('application/json');
 
@@ -35,6 +46,7 @@ describe('GET /api/state', () => {
       'fuelPricePerL',
       'packages',
       'planes',
+      'players', // v1.6.0 (ISS-115) — leaderboard rows ride on every snapshot
       'sellFraction',
       'simState',
     ]);
@@ -48,8 +60,8 @@ describe('GET /api/state', () => {
 
     const planes = body.planes as Array<Record<string, unknown>>;
     expect(planes.length).toBeGreaterThanOrEqual(1);
-    for (const key of ['id', 'model', 'status', 'fuel', 'maxFuel', 'locationIcao', 'locationName', 'destIcao', 'destName', 'lat', 'lon']) {
+    for (const key of ['id', 'model', 'status', 'fuel', 'maxFuel', 'locationIcao', 'locationName', 'destIcao', 'destName', 'lat', 'lon', 'ownerId', 'ownerName']) {
-      expect(planes[0], `plane.${key}`).toHaveProperty(key);
+      expect(planes[0], `plane.${key}`).toHaveProperty(key); // ownerId/ownerName: v1.4.0 (ISS-112)
     }
     expect(typeof planes[0].locationName).toBe('string');
     // The seeded starter is grounded — no flight destination yet.
@@ -58,8 +70,8 @@ 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', 'distanceKm', 'deadlineSimTime', 'status']) {
+    for (const key of ['id', 'originIcao', 'destIcao', 'reward', 'cargoType', 'weightKg', 'distanceKm', 'deadlineSimTime', 'status', 'carrierName']) {
-      expect(packages[0], `package.${key}`).toHaveProperty(key);
+      expect(packages[0], `package.${key}`).toHaveProperty(key); // carrierName: v1.4.0 (ISS-112)
     }
 
     // v0.48.0 (ISS-095): distanceKm is computed server-side — it must equal the haversine of the
@@ -75,13 +87,13 @@ describe('GET /api/state', () => {
   });
 
   it('is stable across repeated calls (same seeded DB)', async () => {
-    const a = ((await GET()).json()) as Promise<{ account: { cash: number } }>;
+    const a = ((await GET(req())).json()) as Promise<{ account: { cash: number } }>;
-    const b = ((await GET()).json()) as Promise<{ account: { cash: number } }>;
+    const b = ((await GET(req())).json()) as Promise<{ account: { cash: number } }>;
     expect((await b).account.cash).toBe((await a).account.cash);
   });
 
   it('exposes the catalog + economy constants matching lib/game/catalog.ts (v0.10.0)', async () => {
-    const body = ((await GET()).json()) as Promise<{
+    const body = ((await GET(req())).json()) as Promise<{
       catalog: Array<Record<string, unknown>>;
       fuelPricePerL: number;
       sellFraction: number;
@@ -104,4 +116,71 @@ describe('GET /api/state', () => {
     expect(snap.fuelPricePerL).toBe(FUEL_PRICE_PER_L);
     expect(snap.sellFraction).toBe(SELL_FRACTION);
   });
+
+  it('returns the SESSION player\'s economy in account, not the local one (v1.3.0, ISS-110)', async () => {
+    const inst = await getGameDb();
+    // A second account with a distinct economy — rows minted like /api/register does.
+    const id = 'test-player-b';
+    await inst.db.insert(schema.users).values({
+      id, username: 'e2e-owner-b', passwordHash: hashPassword('unused'), admin: false, createdAt: Date.now(),
+    });
+    await inst.db.insert(schema.players).values({
+      id, provider: 'local', username: 'e2e-owner-b', cash: 12_345.67, reputation: 42.5,
+    });
+    const sid = await createSession(inst, id);
+
+    const res = await GET(new Request('http://localhost/api/state', { headers: { 'X-Flight-Session': sid } }));
+    expect(res.status).toBe(200);
+    const body = (await res.json()) as { account: { cash: number; reputation: number } };
+    expect(body.account.cash).toBeCloseTo(12_345.67, 9); // the session player's row…
+    expect(body.account.reputation).toBeCloseTo(42.5, 9); // …not the seeded local account
+  });
+
+  it('carries ALL planes with owner info — other players\' planes included (v1.4.0, ISS-112)', async () => {
+    const inst = await getGameDb();
+    // A second player with a plane of their own — rows minted like /api/register does.
+    const id = 'test-player-c';
+    await inst.db.insert(schema.users).values({
+      id, username: 'e2e-owner-c', passwordHash: hashPassword('unused'), admin: false, createdAt: Date.now(),
+    });
+    await inst.db.insert(schema.players).values({
+      id, provider: 'local', username: 'e2e-owner-c', cash: 1000, reputation: 1,
+    });
+    const type = PLANE_TYPES.atr72;
+    await inst.db.insert(schema.planes).values({
+      id: 'plane-test-c', ownerId: id, model: 'atr72', status: 'available',
+      fuel: type.maxFuel, maxFuel: type.maxFuel, locationIcao: 'EDDF', lat: 50.03, lon: 8.56,
+    });
+
+    const res = await GET(req()); // the LOCAL session — still sees the whole world's fleet
+    expect(res.status).toBe(200);
+    const body = (await res.json()) as { planes: Array<{ id: string; ownerId: string; ownerName: string }> };
+    const starter = body.planes.find((p) => p.id === 'plane-starter');
+    expect(starter?.ownerId).toBe('local'); // seeded fleet backfilled to the local player…
+    expect(starter?.ownerName).toBe('kamilkrzywda'); // …and every row names its owner by username.
+    const foreign = body.planes.find((p) => p.id === 'plane-test-c');
+    expect(foreign?.ownerId).toBe(id);
+    expect(foreign?.ownerName).toBe('e2e-owner-c');
+  });
+
+  it('joins carrierName via package → planeId → planes.owner_id → players.username (v1.4.0, ISS-112)', async () => {
+    const inst = await getGameDb();
+    // Reuse the foreign player/plane from the previous test (same throwaway DB within this file).
+    const before = ((await GET(req())).json()) as Promise<{ packages: Array<Record<string, unknown>> }>;
+    const snapBefore = await before;
+    const openPkg = snapBefore.packages.find((p) => p.status === 'open')!;
+
+    // Assign it to the foreign player's plane directly (loadPackage does exactly this).
+    await inst.db.update(schema.packages)
+      .set({ status: 'loaded', planeId: 'plane-test-c' })
+      .where(eq(schema.packages.id, String(openPkg.id)));
+
+    const snap = ((await GET(req())).json()) as Promise<{ packages: Array<Record<string, unknown>> }>;
+    const after = await snap;
+    const assigned = after.packages.find((p) => p.id === openPkg.id)!;
+    expect(assigned.carrierName).toBe('e2e-owner-c'); // the carrying plane's owner…
+    for (const pkg of after.packages) { // …and every unassigned package stays null.
+      if (pkg.planeId == null) expect(pkg.carrierName, `package ${String(pkg.id)}`).toBeNull();
+    }
+  });
 });

app/api/state/route.ts

@@ -1,12 +1,19 @@
+import { requireAuth } from '@/lib/auth';
 import { tickNow } from '@/lib/sim/engine';
 import { getStateSnapshot } from '@/lib/game/state';
 
-export async function GET() {
+// v1.1.0 (ISS-107): guarded — 401 without a live X-Flight-Session.
+// v1.3.0 (ISS-110): `account` carries the SESSION player's economy row.
+// v1.4.0 (ISS-112): full shared-world snapshot — ALL planes with owner info, packages with
+// carrierName; same projection as the SSE frames, so poll and push can never drift.
+export async function GET(req: Request) {
+  const auth = await requireAuth(req);
+  if (!auth.ok) return auth.response;
   try {
     // Tick-on-read (v0.7.0): advance the sim clock before snapshotting so every
     // read reflects current game time (expiry/finalize/spawn run inside the tick).
     await tickNow();
-    return Response.json(await getStateSnapshot());
+    return Response.json(await getStateSnapshot(auth.player.id));
   } catch (err) {
     console.error('failed to load game state', err);
     return Response.json({ error: 'failed to load game state' }, { status: 500 });

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

@@ -1,5 +1,5 @@
 import { getGameDb, persist } from '@/lib/db/client';
-import * as schema from '@/lib/db/schema';
+import { LOCAL_PLAYER, getLocalPlayer, updateLocalPlayerEconomy } from '@/lib/db/localPlayer';
 import { getStateSnapshot } from '@/lib/game/state';
 import { tickNow } from '@/lib/sim/engine';
 
@@ -46,11 +46,12 @@ export async function POST(req: Request) {
   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];
+    // v1.3.0 (ISS-110): admin-style hook — no session, grants to the SEEDED local account (the
-    if (!account) throw new Error('account row missing');
+    // player the e2e suite plays via mint-player-session's default).
-    await inst.db.update(schema.account).set({ cash: Math.round((account.cash + amount) * 100) / 100 });
+    const player = await getLocalPlayer(inst);
+    await updateLocalPlayerEconomy(inst, { cash: Math.round((player.cash + amount) * 100) / 100 });
     await persist(inst);
-    return Response.json(await getStateSnapshot());
+    return Response.json(await getStateSnapshot(LOCAL_PLAYER.id));
   } catch (err) {
     console.error('test hook failed', err);
     return Response.json({ error: 'test hook failed' }, { status: 500 });

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

@@ -1,5 +1,6 @@
 import { randomInt, randomUUID } from 'node:crypto';
 import { getGameDb, persist } from '@/lib/db/client';
+import { getSharedWorldReputation } from '@/lib/db/localPlayer';
 import * as schema from '@/lib/db/schema';
 import { loadAirportsGeoJson } from '@/lib/airports';
 import { generatePackage, mulberry32 } from '@/lib/game/seed';
@@ -82,10 +83,9 @@ export async function POST(req: Request) {
     }
 
     const rng = mulberry32(randomInt(0, 2 ** 31));
-    // v0.38.0 (ISS-072): hook-created packages carry the LIVE account reputation — same job quality
+    // v0.38.0 (ISS-072): hook-created packages carry shared-world job quality — the same MAX-reputation
-    // as engine spawns; never force a fixed value here.
+    // rule as engine spawns (v1.5.0, ISS-111); never force a fixed value here.
-    const account = (await inst.db.select().from(schema.account))[0];
+    const reputation = await getSharedWorldReputation(inst);
-    if (!account) throw new Error('account row missing');
     const created = generatePackage({
       id: randomUUID(),
       airports,
@@ -97,7 +97,7 @@ export async function POST(req: Request) {
       weightKg: input.weightKg as number | undefined,
       // Omitted → force null (no roll) so existing e2e reward/rep assertions stay deterministic.
       special: input.special === undefined ? null : (input.special as string | null),
-      reputation: account.reputation,
+      reputation,
     });
     await inst.db.insert(schema.packages).values(created);
     await persist(inst);

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

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

app/api/test/mint-player-session/route.test.ts

@@ -0,0 +1,95 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { afterAll, beforeAll, describe, expect, it, vi } from 'vitest';
+import { getGameDb } from '@/lib/db/client';
+import { POST } from './route';
+
+// v1.1.0 (ISS-107) — the e2e session-mint hook. CI runs unit tests with FLIGHT_TEST_HOOKS=1 set
+// (docker-compose.ci.yml), so the gate test stubs the env explicitly instead of relying on absence.
+
+let dir: string;
+
+beforeAll(async () => {
+  dir = await fs.mkdtemp(path.join(os.tmpdir(), 'flight-mint-'));
+  process.env.FLIGHT_DB_PATH = path.join(dir, 'mint.db');
+});
+
+afterAll(async () => {
+  vi.unstubAllEnvs();
+  delete process.env.FLIGHT_DB_PATH;
+  await fs.rm(dir, { recursive: true, force: true });
+});
+
+const post = (body?: unknown) =>
+  POST(
+    new Request('http://localhost/api/test/mint-player-session', {
+      method: 'POST',
+      body: body === undefined ? undefined : JSON.stringify(body),
+    }),
+  );
+
+describe('POST /api/test/mint-player-session', () => {
+  it('404s when FLIGHT_TEST_HOOKS is not "1" (like its /api/test/* siblings)', async () => {
+    vi.stubEnv('FLIGHT_TEST_HOOKS', '');
+    const res = await post();
+    expect(res.status).toBe(404);
+  });
+
+  it('mints a session for the seeded local player by default (v1.2.0: e2e plays with backfilled planes)', async () => {
+    vi.stubEnv('FLIGHT_TEST_HOOKS', '1');
+    const res = await post(); // no body → DEFAULT_USERNAME 'kamilkrzywda'
+    expect(res.status).toBe(200);
+    const body = (await res.json()) as { sessionId: string };
+    expect(body.sessionId).toMatch(/^[0-9a-f-]{36}$/);
+
+    const inst = await getGameDb();
+    // The session resolves to the EXISTING admin user — no new users/players rows are created.
+    const sess = inst.raw.exec('SELECT user_id FROM sessions WHERE id = ?', [body.sessionId])[0].values[0];
+    expect(String(sess[0])).toBe('admin-kamilkrzywda');
+    expect(Number(inst.raw.exec('SELECT COUNT(*) FROM users')[0].values[0][0])).toBe(1);
+    expect(Number(inst.raw.exec('SELECT COUNT(*) FROM players')[0].values[0][0])).toBe(1);
+  });
+
+  it('creates a fresh test account WITH onboarding (starter plane at EDDF) for a custom username', async () => {
+    vi.stubEnv('FLIGHT_TEST_HOOKS', '1');
+    const res = await post({ username: 'e2e-tester' });
+    expect(res.status).toBe(200);
+    const body = (await res.json()) as { sessionId: string };
+
+    const inst = await getGameDb();
+    const userRow = inst.raw.exec("SELECT id FROM users WHERE username = 'e2e-tester'")[0].values[0];
+    expect(userRow.length).toBe(1);
+    const playerRow = inst.raw.exec("SELECT id, cash FROM players WHERE username = 'e2e-tester'")[0].values[0];
+    expect(String(playerRow[0])).toBe(String(userRow[0])); // one UUID for both rows
+
+    // v1.2.0 (ISS-108): the new test player gets a starter plane at EDDF owned by them.
+    const planes = inst.raw.exec('SELECT id, owner_id, location_icao FROM planes WHERE owner_id = ?', [String(userRow[0])])[0].values;
+    expect(planes).toHaveLength(1);
+    expect(String(planes[0][2])).toBe('EDDF');
+
+    // The minted session resolves to the new user.
+    const sess = inst.raw.exec('SELECT user_id FROM sessions WHERE id = ?', [body.sessionId])[0].values[0];
+    expect(String(sess[0])).toBe(String(userRow[0]));
+  });
+
+  it('is idempotent — re-minting an existing username mints another session, no duplicate rows or planes', async () => {
+    vi.stubEnv('FLIGHT_TEST_HOOKS', '1');
+    const count = async (sql: string) => Number((await getGameDb()).raw.exec(sql)[0].values[0][0]);
+    expect(await count("SELECT COUNT(*) FROM users WHERE username = 'e2e-tester'")).toBe(1);
+
+    const res = await post({ username: 'e2e-tester' });
+    expect(res.status).toBe(200);
+    expect(await count("SELECT COUNT(*) FROM users WHERE username = 'e2e-tester'")).toBe(1); // still one account…
+    expect(await count("SELECT COUNT(*) FROM planes p JOIN players pl ON p.owner_id = pl.id WHERE pl.username = 'e2e-tester'")).toBe(1); // …and exactly one onboarding plane
+  });
+
+  it('rejects bad usernames and unknown fields with 400', async () => {
+    vi.stubEnv('FLIGHT_TEST_HOOKS', '1');
+    for (const body of [{ username: 'x' }, { username: 'BAD USER!' }, { bogus: 1 }]) {
+      const res = await post(body);
+      expect(res.status).toBe(400);
+      expect(((await res.json()) as { error: string }).error).toBeTruthy();
+    }
+  });
+});

app/api/test/mint-player-session/route.ts

@@ -0,0 +1,89 @@
+import { randomUUID } from 'node:crypto';
+import * as schema from '@/lib/db/schema';
+import { getGameDb, persist } from '@/lib/db/client';
+import { createSession, hashPassword } from '@/lib/auth';
+import { loadAirportsGeoJson } from '@/lib/airports';
+import { buildStarterPlane, STARTING_CASH, STARTING_REPUTATION } from '@/lib/game/seed';
+
+// TEST-ONLY hook (v1.1.0, ISS-107) — mints a session for a test player so the e2e suite can hit
+// the guarded game routes WITHOUT any real credentials in test code (same reason as its sibling
+// /api/test/admin-session). Creates the users + players rows if missing — idempotent across
+// container restarts, since the CI DB volume persists. Disabled unless FLIGHT_TEST_HOOKS=1; every
+// other deployment 404s here, like its /api/test/* siblings.
+//
+// POST /api/test/mint-player-session
+//   body { username?: string } — defaults to 'kamilkrzywda' (v1.2.0, ISS-109: the e2e specs play
+//   with the seeded world's planes by id, so the minted session must resolve to the local player
+//   that owns them after the owner_id backfill); a custom username creates a fresh test account
+//   WITH onboarding (starter plane at EDDF) like /api/register. Must match the register rules when given.
+//   Returns { sessionId }.
+
+const DEFAULT_USERNAME = 'kamilkrzywda';
+// Test-only credential for the minted users row — e2e never logs in with it (sessions are minted
+// server-side); a fixed value keeps the row debuggable from the admin panel.
+const TEST_PASSWORD = 'e2e-mint-password-42';
+
+export async function POST(req: Request) {
+  if (process.env.FLIGHT_TEST_HOOKS !== '1') {
+    return Response.json({ error: 'test hooks disabled' }, { status: 404 });
+  }
+
+  let body: unknown = {};
+  try {
+    const text = await req.text();
+    body = text ? JSON.parse(text) : {};
+  } catch {
+    return Response.json({ error: 'invalid JSON body' }, { status: 400 });
+  }
+  if (typeof body !== 'object' || body === null || Array.isArray(body)) {
+    return Response.json({ error: 'body must be a JSON object' }, { status: 400 });
+  }
+  const input = body as Record<string, unknown>;
+  for (const key of Object.keys(input)) {
+    if (key !== 'username') {
+      return Response.json({ error: `unknown field "${key}"` }, { status: 400 });
+    }
+  }
+  let username = DEFAULT_USERNAME;
+  if (input.username !== undefined) {
+    if (typeof input.username !== 'string' || !/^[a-z0-9_-]{3,20}$/.test(input.username)) {
+      return Response.json(
+        { error: 'username must be 3–20 characters of a-z, 0-9, _ or -' },
+        { status: 400 },
+      );
+    }
+    username = input.username;
+  }
+
+  const inst = await getGameDb();
+  let res = inst.raw.exec('SELECT id FROM users WHERE username = ?', [username]);
+  let userId = res[0]?.values?.[0]?.[0];
+  if (typeof userId !== 'string') {
+    // New test account — one UUID for both rows, starter economy like a fresh world.
+    const id = randomUUID();
+    inst.raw.run('INSERT INTO users (id, username, password_hash, admin, created_at) VALUES (?, ?, ?, 0, ?)', [
+      id,
+      username,
+      hashPassword(TEST_PASSWORD),
+      Date.now(),
+    ]);
+    await inst.db.insert(schema.players).values({
+      id,
+      provider: 'local',
+      username,
+      cash: STARTING_CASH,
+      reputation: STARTING_REPUTATION,
+    });
+    // v1.2.0 (ISS-108): same onboarding as /api/register — a starter plane at EDDF owned by the new player.
+    const fc = await loadAirportsGeoJson();
+    const starter = buildStarterPlane(
+      fc.features.map((f) => ({ icao: f.properties.icao, name: f.properties.name, lat: f.properties.lat, lon: f.properties.lon })),
+      randomUUID(),
+    );
+    const { queue, ...starterCols } = starter;
+    await inst.db.insert(schema.planes).values({ ...starterCols, ownerId: id, queue: JSON.stringify(queue ?? []) });
+    userId = id;
+  }
+  const sessionId = await createSession(inst, userId); // persists the rows + session together
+  return Response.json({ sessionId });
+}

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

@@ -1,5 +1,5 @@
 import { getGameDb, persist } from '@/lib/db/client';
-import * as schema from '@/lib/db/schema';
+import { LOCAL_PLAYER, getLocalPlayer, updateLocalPlayerEconomy } from '@/lib/db/localPlayer';
 import { getStateSnapshot } from '@/lib/game/state';
 import { tickNow } from '@/lib/sim/engine';
 
@@ -42,11 +42,12 @@ export async function POST(req: Request) {
   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];
+    // v1.3.0 (ISS-110): admin-style hook — no session, stages the SEEDED local account (the player
-    if (!account) throw new Error('account row missing');
+    // the e2e suite plays via mint-player-session's default).
-    await inst.db.update(schema.account).set({ cash: Math.round(amount * 100) / 100 });
+    await getLocalPlayer(inst); // existence check — the snapshot below would fail anyway if it's gone
+    await updateLocalPlayerEconomy(inst, { cash: Math.round(amount * 100) / 100 });
     await persist(inst);
-    return Response.json(await getStateSnapshot());
+    return Response.json(await getStateSnapshot(LOCAL_PLAYER.id));
   } catch (err) {
     console.error('test hook failed', err);
     return Response.json({ error: 'test hook failed' }, { status: 500 });

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

@@ -1,5 +1,6 @@
 import { eq } from 'drizzle-orm';
 import { getGameDb, persist } from '@/lib/db/client';
+import { LOCAL_PLAYER } from '@/lib/db/localPlayer';
 import * as schema from '@/lib/db/schema';
 import { getStateSnapshot } from '@/lib/game/state';
 import { tickNow } from '@/lib/sim/engine';
@@ -57,7 +58,8 @@ export async function POST(req: Request) {
 
     await inst.db.update(schema.planes).set({ fuel }).where(eq(schema.planes.id, planeId));
     await persist(inst);
-    return Response.json(await getStateSnapshot());
+    // v1.3.0 (ISS-110): admin-style hook — no session; the snapshot reports the seeded local account.
+    return Response.json(await getStateSnapshot(LOCAL_PLAYER.id));
   } catch (err) {
     console.error('test hook failed', err);
     return Response.json({ error: 'test hook failed' }, { status: 500 });

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

@@ -1,5 +1,6 @@
 import { eq } from 'drizzle-orm';
 import { getGameDb, persist } from '@/lib/db/client';
+import { LOCAL_PLAYER } from '@/lib/db/localPlayer';
 import * as schema from '@/lib/db/schema';
 import { getStateSnapshot } from '@/lib/game/state';
 import { tickNow } from '@/lib/sim/engine';
@@ -74,7 +75,8 @@ export async function POST(req: Request) {
     if (repairUntilMs !== undefined) sets.repairUntilSimTime = Math.round(sim.clockMs + repairUntilMs);
     await inst.db.update(schema.planes).set(sets).where(eq(schema.planes.id, planeId));
     await persist(inst);
-    return Response.json(await getStateSnapshot());
+    // v1.3.0 (ISS-110): admin-style hook — no session; the snapshot reports the seeded local account.
+    return Response.json(await getStateSnapshot(LOCAL_PLAYER.id));
   } catch (err) {
     console.error('test hook failed', err);
     return Response.json({ error: 'test hook failed' }, { status: 500 });

app/globals.css

@@ -244,6 +244,15 @@ body {
   color: #bae6fd;
 }
 
+/* v1.4.0 (ISS-112): owner / carrier badge — whose plane or cargo this is in the shared world. */
+.owner-badge {
+  font-size: 11px;
+  padding: 1px 6px;
+  border-radius: 4px;
+  background: rgba(74, 222, 128, 0.15);
+  color: #bbf7d0;
+}
+
 .fuel-bar {
   height: 4px;
   border-radius: 2px;
@@ -727,3 +736,100 @@ body {
 .admin-row-actions {
   white-space: nowrap;
 }
+
+/* v1.6.0 (ISS-115) — leaderboard panel inside the generic modal, same table look as .admin-rows. */
+.leaderboard {
+  padding: 14px;
+  overflow-y: auto;
+}
+
+.leaderboard table {
+  width: 100%;
+  border-collapse: collapse;
+  font-size: 12px;
+  font-variant-numeric: tabular-nums;
+}
+
+.leaderboard th,
+.leaderboard td {
+  padding: 4px 6px;
+  text-align: left;
+  white-space: nowrap;
+  border-bottom: 1px solid rgba(148, 163, 184, 0.2);
+}
+
+.leaderboard th {
+  color: #94a3b8;
+  font-weight: 600;
+}
+
+/* v1.1.0 (ISS-107) — full-screen sign-in / create-account screen, same dark slate theme as the panes. */
+.sign-in {
+  position: fixed;
+  inset: 0;
+  z-index: 50;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  gap: 14px;
+  background: rgba(15, 23, 42, 0.97);
+  color: #f8fafc;
+}
+
+.sign-in h1 {
+  margin: 0;
+  font-size: 22px;
+  letter-spacing: 0.06em;
+}
+
+.sign-in form {
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+  width: 300px;
+  padding: 14px;
+  border: 1px solid rgba(148, 163, 184, 0.3);
+  border-radius: 6px;
+  background: rgba(30, 41, 59, 0.6);
+}
+
+.sign-in label {
+  font-size: 12px;
+  color: #cbd5e1;
+}
+
+.sign-in input {
+  font-size: 13px;
+  padding: 5px 8px;
+  border-radius: 4px;
+  border: 1px solid rgba(148, 163, 184, 0.4);
+  background: rgba(15, 23, 42, 0.9);
+  color: #f8fafc;
+}
+
+.sign-in .pane-btn {
+  margin-top: 6px;
+  padding: 5px 10px;
+}
+
+.sign-in-divider {
+  margin: 0;
+  font-size: 12px;
+  color: #94a3b8;
+}
+
+.sign-in-error {
+  margin: 0;
+  font-size: 13px;
+  color: #fca5a5;
+}
+
+.sign-in-loading {
+  position: absolute;
+  top: 50%;
+  left: 50%;
+  transform: translate(-50%, -50%);
+  margin: 0;
+  color: #cbd5e1;
+}

app/page.tsx

@@ -4,8 +4,10 @@ import dynamic from 'next/dynamic';
 import { useEffect, useRef, useState } from 'react';
 import LeftPane from '@/components/LeftPane';
 import RightPane from '@/components/RightPane';
+import SignInScreen from '@/components/SignInScreen';
 import ToastStack from '@/components/Toasts';
 import type { HoverTarget } from '@/components/hoverTypes';
+import { clearStoredSession, sessionHeaders, storedSession } from '@/lib/authClient';
 import { useGameState } from '@/lib/useGameState';
 import { useToasts } from '@/lib/useToasts';
 import { diffSnapshots } from '@/lib/deriveEvents';
@@ -13,6 +15,58 @@ import { diffSnapshots } from '@/lib/deriveEvents';
 const Map = dynamic(() => import('@/components/Map'), { ssr: false });
 
 export default function Home() {
+  // v1.1.0 (ISS-107): auth gate — null while checking the stored session on mount, then either
+  // the sign-in screen or the game shell. The shell only mounts once authenticated, so its state
+  // feed never polls an unauthenticated /api/state.
+  const [authed, setAuthed] = useState<boolean | null>(null);
+  // v1.10.0 (ISS-158): /api/me's `admin` flag — gates the top-bar Admin button in Map.
+  const [isAdmin, setIsAdmin] = useState(false);
+  // Bumped after a form sign-in so the probe below re-runs for the NEW session — isAdmin must
+  // track whoever just signed in, not the user probed on mount (or before the last logout).
+  const [probeKey, setProbeKey] = useState(0);
+
+  useEffect(() => {
+    const sid = storedSession();
+    if (!sid) {
+      setAuthed(false);
+      return;
+    }
+    let cancelled = false;
+    fetch('/api/me', { headers: sessionHeaders(sid), cache: 'no-store' })
+      .then(async (res) => {
+        if (cancelled) return;
+        if (!res.ok) clearStoredSession(); // stale/expired id — drop it and show sign-in
+        else setIsAdmin(Boolean(((await res.json()) as { admin?: boolean }).admin)); // v1.10.0 (ISS-158)
+        setAuthed(res.ok);
+      })
+      .catch(() => {
+        if (!cancelled) setAuthed(false); // network error → let the user try to sign in
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, [probeKey]);
+
+  if (authed === null) {
+    return (
+      <div className="app-shell">
+        <p data-testid="auth-checking" className="sign-in-loading">
+          Loading…
+        </p>
+      </div>
+    );
+  }
+  if (!authed) {
+    // v1.10.0 (ISS-158): re-probe /api/me for the new session instead of blindly flipping authed —
+    // isAdmin has to come from the user who just signed in.
+    return <SignInScreen onAuthed={() => setProbeKey((k) => k + 1)} />;
+  }
+
+  // The admin panel's Log out cleared the session — drop back to sign-in (ISS-107).
+  return <AppShell onLogout={() => setAuthed(false)} isAdmin={isAdmin} />;
+}
+
+function AppShell({ onLogout, isAdmin }: { onLogout: () => void; isAdmin: boolean }) {
   // 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.
@@ -49,7 +103,7 @@ export default function Home() {
       {/* 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 */}
-      <Map state={state} hovered={hovered} applySnapshot={applySnapshot} />
+      <Map state={state} hovered={hovered} applySnapshot={applySnapshot} onLogout={onLogout} isAdmin={isAdmin} />
       <RightPane state={state} loading={loading} applySnapshot={applySnapshot} onHover={setHovered} onError={onError} />
       <ToastStack toasts={toasts} onDismiss={dismiss} />
     </div>

components/AdminPanel.tsx

@@ -1,13 +1,12 @@
 'use client';
 
 import { useCallback, useEffect, useState } from 'react';
+import { clearStoredSession, sessionHeaders, storedSession, storeSession } from '../lib/authClient';
 
 // 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;
@@ -18,15 +17,7 @@ interface RowsData {
   rows: Array<Record<string, unknown>>;
 }
 
-function readSession(): string | null {
+export default function AdminPanel({ onLogout }: { onLogout?: () => void }) {
-  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);
@@ -45,15 +36,12 @@ export default function AdminPanel() {
   const [busy, setBusy] = useState(false);
   const [error, setError] = useState<string | null>(null);
 
-  const authHeaders = useCallback(
+  const authHeaders = useCallback((s: string) => sessionHeaders(s), []);
-    (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();
+    const stored = storedSession();
     if (!stored) {
       setChecking(false);
       return;
@@ -61,7 +49,7 @@ export default function AdminPanel() {
     fetch('/api/me', { headers: authHeaders(stored) })
       .then(async (res) => {
         if (!res.ok || cancelled) {
-          window.localStorage.removeItem(SESSION_STORAGE_KEY);
+          clearStoredSession();
           setSession(null);
           return;
         }
@@ -71,7 +59,7 @@ export default function AdminPanel() {
       })
       .catch(() => {
         if (!cancelled) {
-          window.localStorage.removeItem(SESSION_STORAGE_KEY);
+          clearStoredSession();
           setSession(null);
         }
       })
@@ -161,7 +149,7 @@ export default function AdminPanel() {
       return;
     }
     const body = (await res.json()) as { sessionId: string; user: Me };
-    window.localStorage.setItem(SESSION_STORAGE_KEY, body.sessionId);
+    storeSession(body.sessionId);
     setSession(body.sessionId);
     setMe(body.user);
     setUsername('');
@@ -170,7 +158,8 @@ export default function AdminPanel() {
 
   const logout = async () => {
     if (session) await fetch('/api/logout', { method: 'POST', headers: authHeaders(session) }).catch(() => undefined);
-    window.localStorage.removeItem(SESSION_STORAGE_KEY);
+    clearStoredSession();
+    onLogout?.(); // v1.1.0 (ISS-107): session gone → shell drops back to the sign-in screen
     setSession(null);
     setMe(null);
     setTable(null);

components/Leaderboard.tsx

@@ -0,0 +1,36 @@
+import { formatCash } from '@/lib/format';
+import type { PlayerSummary } from '@/lib/game/state';
+
+// v1.6.0 (ISS-115): leaderboard panel — every player in the world with cash, reputation and
+// plane count, rendered straight off the shared snapshot (no endpoint of its own). Sorted by
+// reputation desc; cash then username break ties deterministically so rows don't shuffle
+// between snapshots when two players share a reputation.
+export default function Leaderboard({ players }: { players: PlayerSummary[] }) {
+  const sorted = [...players].sort(
+    (a, b) => b.reputation - a.reputation || b.cash - a.cash || a.username.localeCompare(b.username),
+  );
+  return (
+    <div className="leaderboard">
+      <table data-testid="leaderboard-table">
+        <thead>
+          <tr>
+            <th>Player</th>
+            <th>Cash</th>
+            <th>Reputation</th>
+            <th>Planes</th>
+          </tr>
+        </thead>
+        <tbody>
+          {sorted.map((p) => (
+            <tr key={p.id} data-testid={`leaderboard-row-${p.id}`}>
+              <td>{p.username}</td>
+              <td>{formatCash(p.cash)}</td>
+              <td>{p.reputation}</td>
+              <td>{p.planeCount}</td>
+            </tr>
+          ))}
+        </tbody>
+      </table>
+    </div>
+  );
+}

components/LeftPane.tsx

@@ -157,6 +157,10 @@ export default function LeftPane({ state, loading, error, applySnapshot, onHover
                     >
                       <div className="plane-main">
                         <span className="plane-model">{PLANE_TYPES[p.model]?.name ?? p.model}</span>
+                        {/* v1.4.0 (ISS-112): the snapshot carries ALL planes — badge names the owner. */}
+                        <span data-testid={`plane-owner-${p.id}`} className="owner-badge" title={`Owned by ${p.ownerName}`}>
+                          {p.ownerName}
+                        </span>
                         {p.status === 'flying' ? (
                           <>
                             <span className="plane-status status-flying">in flight</span>

components/Map.tsx

@@ -13,6 +13,8 @@ import { weatherFor } from '../lib/weather';
 import { approxLocalTime } from '../lib/localTime';
 import Modal from './Modal';
 import AdminPanel from './AdminPanel';
+import Leaderboard from './Leaderboard';
+import { clearStoredSession, sessionHeaders } from '../lib/authClient';
 
 // v0.70.0 default view: null island [0,0] at zoom 2 — the world is 2048 px wide there and the
 // Africa+Europe bounding box (lat −35..+71, lon −18..+52) spans ~800 px vertically in Web Mercator,
@@ -69,11 +71,16 @@ interface MapProps {
   // ISS-010 (v0.18.0): push an action endpoint's full response snapshot into the shared
   // shell state — same callback RightPane receives, used by the airport popup's Relocate row.
   applySnapshot: (snapshot: StateSnapshot) => void;
+  // v1.1.0 (ISS-107): the admin panel's Log out cleared the session — tell the shell to drop back
+  // to the sign-in screen instead of leaving a signed-out user staring at a live dashboard.
+  onLogout?: () => void;
+  // v1.10.0 (ISS-158): /api/me says this session is an admin → show the top-bar Admin button.
+  isAdmin?: boolean;
 }
 
 // Named FlightMap (not Map): a component called `Map` would shadow the global
 // Map constructor inside its own body, breaking `new Map(...)` for the airport index.
-export default function FlightMap({ state, hovered, applySnapshot }: MapProps) {
+export default function FlightMap({ state, hovered, applySnapshot, onLogout, isAdmin = false }: MapProps) {
   const containerRef = useRef<HTMLDivElement>(null);
   const mapRef = useRef<maplibregl.Map | null>(null);
   // /api/airports is fetched at most once per page life: every styledata event
@@ -94,6 +101,8 @@ export default function FlightMap({ state, hovered, applySnapshot }: MapProps) {
   // 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);
+  // v1.6.0 (ISS-115): the leaderboard panel (top-bar button) — rows come from the polled snapshot.
+  const [leaderboardOpen, setLeaderboardOpen] = 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
@@ -295,7 +304,8 @@ export default function FlightMap({ state, hovered, applySnapshot }: MapProps) {
               const action = planeStatus === 'available' ? 'fly' : 'queue';
               const res = await fetch(`/api/planes/${planeId}/${action}`, {
                 method: 'POST',
-                headers: { 'Content-Type': 'application/json' },
+                // v1.1.0 (ISS-107): fly/queue are session-guarded — echo the stored id.
+                headers: { 'Content-Type': 'application/json', ...sessionHeaders() },
                 body: JSON.stringify({ destIcao: p.icao }),
                 cache: 'no-store',
               });
@@ -561,6 +571,14 @@ export default function FlightMap({ state, hovered, applySnapshot }: MapProps) {
     void localAssetsAvailable().then((available) => mapRef.current?.setStyle(styleUrlFor(id, available)));
   };
 
+  // v1.10.0 (ISS-157): top-bar Log out — same three steps as the admin panel's button: best-effort
+  // server-side session kill, drop the stored id, tell the shell to show sign-in again.
+  const onTopBarLogout = async () => {
+    await fetch('/api/logout', { method: 'POST', headers: sessionHeaders() }).catch(() => undefined);
+    clearStoredSession();
+    onLogout?.();
+  };
+
   return (
     <div className="map-wrap">
       <header data-testid="app-header" className="app-header">
@@ -584,14 +602,29 @@ export default function FlightMap({ state, hovered, applySnapshot }: MapProps) {
         <span data-testid="airport-count">
           {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). */}
+        {/* v1.6.0 (ISS-115): leaderboard panel entry point — right side of the top bar, opens a modal. */}
+        <button type="button" data-testid="leaderboard-btn" className="pane-btn" onClick={() => setLeaderboardOpen(true)}>
+          Leaderboard
+        </button>
+        {/* v0.71.0: admin panel entry point — right side of the top bar, opens a modal (no URL).
+            v1.10.0 (ISS-158): only for admins (/api/me `admin` flag) — hidden entirely otherwise. */}
+        {isAdmin && (
           <button type="button" data-testid="admin-btn" className="pane-btn" onClick={() => setAdminOpen(true)}>
             Admin
           </button>
+        )}
+        {/* v1.10.0 (ISS-157): Log out — last child, so the flex row puts it top-right of the bar. */}
+        <button type="button" data-testid="logout-btn" className="pane-btn" onClick={() => void onTopBarLogout()}>
+          Log out
+        </button>
       </header>
       <div ref={containerRef} data-testid="map" className="map-container" />
       <Modal open={adminOpen} onClose={() => setAdminOpen(false)} title="Admin">
-        <AdminPanel />
+        <AdminPanel onLogout={onLogout} />
+      </Modal>
+      {/* v1.6.0 (ISS-115): leaderboard — players from the shared snapshot, no extra endpoint. */}
+      <Modal open={leaderboardOpen} onClose={() => setLeaderboardOpen(false)} title="Leaderboard">
+        <Leaderboard players={state?.players ?? []} />
       </Modal>
     </div>
   );

components/RightPane.tsx

@@ -209,6 +209,12 @@ export default function RightPane({ state, loading, applySnapshot, onHover, onEr
                         {formatSpecialLabel(pkg.special)}
                       </span>
                     )}
+                    {/* v1.4.0 (ISS-112): carrier name — who is carrying this package; rendered only when set. */}
+                    {pkg.carrierName && (
+                      <span data-testid={`open-package-carrier-${pkg.id}`} className="owner-badge">
+                        {pkg.carrierName}
+                      </span>
+                    )}
                     {eligible.length > 0 ? (
                       <LoadControls
                         pkg={pkg}

components/SignInScreen.tsx

@@ -0,0 +1,78 @@
+'use client';
+
+import { useState } from 'react';
+import { storeSession } from '@/lib/authClient';
+
+// v1.1.0 (ISS-107) — full-screen sign-in / create-account screen shown when no valid session is
+// stored. Both forms POST the same shape ({username, password}); login mints a session for an
+// existing account, register creates one first and then mints it. On success the sessionId goes
+// to localStorage (via storeSession) and onAuthed() flips the shell back in.
+
+interface SignInScreenProps {
+  onAuthed: () => void;
+}
+
+export default function SignInScreen({ onAuthed }: SignInScreenProps) {
+  const [error, setError] = useState<string | null>(null);
+  const [busy, setBusy] = useState(false);
+
+  async function submit(e: React.FormEvent<HTMLFormElement>, path: '/api/login' | '/api/register') {
+    e.preventDefault();
+    if (busy) return;
+    setBusy(true);
+    setError(null);
+    try {
+      const form = new FormData(e.currentTarget);
+      const res = await fetch(path, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          username: String(form.get('username') ?? ''),
+          password: String(form.get('password') ?? ''),
+        }),
+        cache: 'no-store',
+      });
+      const data = (await res.json()) as { sessionId?: string; error?: string };
+      if (!res.ok || !data.sessionId) throw new Error(data.error ?? `HTTP ${res.status}`);
+      storeSession(data.sessionId);
+      onAuthed();
+    } catch (err) {
+      setError(err instanceof Error ? err.message : String(err));
+    } finally {
+      setBusy(false);
+    }
+  }
+
+  return (
+    <div className="sign-in">
+      <h1 data-testid="app-title">Flight Ops</h1>
+      {error !== null && (
+        <p data-testid="auth-error" role="alert" className="sign-in-error">
+          {error}
+        </p>
+      )}
+
+      <form data-testid="sign-in-form" onSubmit={(e) => void submit(e, '/api/login')}>
+        <label htmlFor="sign-in-username">Username</label>
+        <input id="sign-in-username" data-testid="sign-in-username" name="username" autoComplete="username" required />
+        <label htmlFor="sign-in-password">Password</label>
+        <input id="sign-in-password" data-testid="sign-in-password" name="password" type="password" autoComplete="current-password" required />
+        <button type="submit" data-testid="sign-in-submit" className="pane-btn" disabled={busy}>
+          Sign in
+        </button>
+      </form>
+
+      <p className="sign-in-divider">or</p>
+
+      <form data-testid="create-account-form" onSubmit={(e) => void submit(e, '/api/register')}>
+        <label htmlFor="register-username">Username (3–20 chars: a-z 0-9 _ -)</label>
+        <input id="register-username" name="username" autoComplete="off" required />
+        <label htmlFor="register-password">Password (at least 8 characters)</label>
+        <input id="register-password" name="password" type="password" autoComplete="new-password" required minLength={8} />
+        <button type="submit" data-testid="register-submit" className="pane-btn" disabled={busy}>
+          Create account
+        </button>
+      </form>
+    </div>
+  );
+}

components/right-pane.test.ts

@@ -27,6 +27,8 @@ function plane(over: Partial<PlaneState> & Pick<PlaneState, 'id'>): PlaneState {
     health: 100, // v0.39.0 (ISS-069) — full-health fixture default
     repairUntilSimTime: null,
     queue: [],
+    ownerId: 'local', // v1.4.0 (ISS-112) — owner info on every plane row
+    ownerName: 'kamilkrzywda',
     ...over,
   };
 }
@@ -48,6 +50,7 @@ function pkg(over: Partial<PackageState> & Pick<PackageState, 'id'>): PackageSta
     planeId: null,
     createdSimTime: 0,
     expiresRealMs: null, // v0.65.0 — wall-clock expiry; open fixtures override as needed
+    carrierName: null, // v1.4.0 (ISS-112) — unassigned by default in fixtures
     ...over,
   };
 }
@@ -57,6 +60,7 @@ function snap(planes: PlaneState[], packages: PackageState[] = []): StateSnapsho
     account: { cash: 0, reputation: 0 },
     simState: { clockMs: 0 },
     planes,
+    players: [], // v1.6.0 (ISS-115) — leaderboard rows; unused by the right pane
     packages,
     catalog: CATALOG,
     fuelPricePerL: 0.8,

e2e/actions.spec.ts

@@ -6,6 +6,11 @@ import { initialBearingDeg } from '../lib/geo';
 import { weatherFor } from '../lib/weather';
 import { windBurnFactor } from '../lib/sim/movement';
 
+import { authenticate } from './auth';
+
+// v1.1.0 (ISS-107): game routes are session-guarded — mint + apply a player session before every test.
+test.beforeEach(async ({ page }) => { await authenticate(page); });
+
 // v0.12.0 package model against the live origin (https://flight.dev.kkhost.pl):
 // the full core loop through the UI — hook creates a short package at EDDF → Load
 // via the right pane → click its destination in the on-board list (left pane since
@@ -15,6 +20,7 @@ import { windBurnFactor } from '../lib/sim/movement';
 // penalty. Mirrors lib/game/penalty.ts for exact-value assertions.
 
 const SCALE = 1000; // test rate for fast-forwarding legs — keeps flights to seconds of real time
+const FAST = 10_000; // pure arrival waits (no mid-leg observation) — LEMD-length legs land in ~1 s
 const WORLD = 24; // the fixed world rate (ISS-117) — must match lib/worldClock.ts
 const HUB = 'EDDF'; // Frankfurt Main — the seeded starter plane's home base (lib/game/seed.ts)
 
@@ -329,7 +335,7 @@ test('abandon while grounded deducts exactly the formula penalty', async ({ page
 });
 
 test('expired packages deliver and abandon with no reward and no penalty', async ({ page }) => {
-  test.setTimeout(480_000); // two ~10 s real-time legs at 1000× (HUB↔LEMD) plus expiry wait
+  test.setTimeout(480_000); // two ~1 s real-time legs at 10_000× (HUB↔LEMD) plus expiry wait
   await flyHomeViaApi(page);
 
   // A: load, let it expire while loaded, then FLY to its destination — arrival must
@@ -345,12 +351,12 @@ test('expired packages deliver and abandon with no reward and no penalty', async
   }
 
   // A fully grounded fleet freezes the world clock (#135) — put the starter in repair for the expiry
-  // window so scale 1000 can fast-forward past both deadlines quickly. The €1.5k repair cost is why
+  // window so scale 10_000 can fast-forward past both deadlines quickly. The €1.5k repair cost is why
   // the cash/rep baseline below is captured AFTER deactivateWorld, not before it.
   await activateWorld(page);
   try {
     // Fast-forward past both deadlines — the tick flips loaded → expired (slot kept).
-    await setScale(page, SCALE);
+    await setScale(page, FAST);
     let s = await getState(page);
     await expect.poll(async () => ((await getState(page)).packages.find((p) => p.id === pkgA.id)!.status), { timeout: 30_000 }).toBe('expired');
     s = await getState(page);
@@ -382,9 +388,9 @@ test('expired packages deliver and abandon with no reward and no penalty', async
   expect(s.packages.find((p) => p.id === pkgB.id)!.status).toBe('abandoned');
   expect(s.account.cash).toBe(cashBeforeAbandon); // free — expired abandons cost nothing
 
-  // Restore: top up + fly home at SCALE.
+  // Restore: top up + fly home at FAST (pure arrival wait).
   await setFuelFull(page, 'plane-starter');
-  await setScale(page, SCALE);
+  await setScale(page, FAST);
   const homeRes = await page.request.post('/api/planes/plane-starter/fly', { data: { destIcao: HUB } });
   expect(homeRes.ok()).toBeTruthy();
   await expect.poll(async () => ((await getState(page)).planes.find((p) => p.id === 'plane-starter')!.locationIcao), { timeout: 240_000 }).toBe(HUB);

e2e/admin.spec.ts

@@ -1,12 +1,13 @@
 import { expect, test } from '@playwright/test';
 
-// v0.71.0 — Admin panel e2e: top-bar button → modal with login form; wrong credentials show an
+// v0.71.0 — Admin panel e2e: top-bar button → modal; wrong credentials show an error; a session
-// error; a session minted by the /api/test/admin-session hook (FLIGHT_TEST_HOOKS=1) authenticates
+// minted by the /api/test/admin-session hook (FLIGHT_TEST_HOOKS=1) authenticates WITHOUT the real
-// WITHOUT the real admin password ever appearing in test code; then the generic DB grid is
+// admin password ever appearing in test code; then the generic DB grid is exercised end-to-end:
-// exercised end-to-end: table list → edit + save a cell (verified by an independent re-fetch) →
+// table list → edit + save a cell (verified by an independent re-fetch) → add a row → delete it →
-// add a row → delete it → logout back to the login form.
+// logout. v1.1.0 (ISS-107): the whole app now sits behind the sign-in screen — unauthenticated
+// visitors see IT instead of the shell, and logout drops back to it.
 
-const SESSION_KEY = 'flight.session'; // must match components/AdminPanel.tsx
+const SESSION_KEY = 'flight.session'; // must match lib/authClient.ts
 
 async function mintAdminSession(page: import('@playwright/test').Page): Promise<string> {
   const res = await page.request.post('/api/test/admin-session');
@@ -14,31 +15,32 @@ async function mintAdminSession(page: import('@playwright/test').Page): Promise<
   return ((await res.json()) as { sessionId: string }).sessionId;
 }
 
-test('admin panel: login form, wrong-creds error, session auth, DB grid CRUD, logout', async ({ page }) => {
+test('admin panel: sign-in gate, 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.
+  // --- Unauthenticated → the sign-in screen replaces the whole shell (v1.1.0, ISS-107).
-  await adminBtn.click();
+  const signIn = page.getByTestId('sign-in-form');
-  const dialog = page.locator('[role="dialog"]');
+  await expect(signIn).toBeVisible({ timeout: 30_000 });
-  await expect(dialog).toBeVisible();
+  await expect(page.getByTestId('app-header')).toHaveCount(0);
-  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('sign-in-username').fill('kamilkrzywda');
-  await page.getByTestId('admin-password').fill('wrong-password-on-purpose');
+  await page.getByTestId('sign-in-password').fill('wrong-password-on-purpose');
-  await page.getByTestId('admin-login-submit').click();
+  await page.getByTestId('sign-in-submit').click();
-  await expect(page.getByTestId('admin-error')).toBeVisible({ timeout: 10_000 });
+  await expect(page.getByTestId('auth-error')).toBeVisible({ timeout: 10_000 });
 
-  // --- Authenticate via the test hook + localStorage, then reopen the panel.
+  // --- Authenticate via the test hook + localStorage, then reload into the shell.
   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]);
+  // The independent re-fetch below goes through page.request → needs the header at context level.
+  await page.context().setExtraHTTPHeaders({ 'X-Flight-Session': sessionId });
   await page.reload();
+  const adminBtn = page.getByTestId('admin-btn');
   await expect(adminBtn).toBeVisible({ timeout: 30_000 });
+
+  // --- Open the modal: stored session is valid → straight to the table list.
   await adminBtn.click();
 
   // --- Authenticated admin → table list including packages and users.
@@ -104,8 +106,8 @@ test('admin panel: login form, wrong-creds error, session auth, DB grid CRUD, lo
   await page.getByTestId(`admin-delete-${addedIdx}`).click();
   await expect.poll(findUserRow, { timeout: 15_000 }).toBe(-1);
 
-  // --- Logout returns to the login form.
+  // --- Logout drops back to the sign-in screen (v1.1.0, ISS-107 — onLogout unmounts the shell).
   await page.getByTestId('admin-logout').click();
-  await expect(page.getByTestId('admin-username')).toBeVisible({ timeout: 10_000 });
+  await expect(page.getByTestId('sign-in-form')).toBeVisible({ timeout: 10_000 });
   await expect(tables).toBeHidden();
 });

e2e/api.spec.ts

@@ -13,7 +13,7 @@ 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 seventeen endpoints and the package.json version', async ({ page }) => {
+test('GET /api/openapi serves the spec with all eighteen 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');
@@ -38,6 +38,7 @@ test('GET /api/openapi serves the spec with all seventeen endpoints and the pack
     '/api/planes/{planeId}/queue',
     '/api/planes/{planeId}/queue/cancel',
     '/api/planes/{planeId}/repair', // v0.39.0 (ISS-069)
+    '/api/register', // v1.1.0 (ISS-107) — self-service account creation
     '/api/state',
     '/api/version',
   ]);

e2e/auth.ts

@@ -0,0 +1,34 @@
+import type { Page } from '@playwright/test';
+import { expect } from '@playwright/test';
+
+// v1.1.0 (ISS-107) — session helpers for the e2e suite. Every game route is now session-guarded, so
+// each spec authenticates in a beforeEach: mint a player session server-side via the test hook
+// (FLIGHT_TEST_HOOKS=1; no real credentials in test code), then apply it BOTH ways the client uses —
+// localStorage for the app's own fetches (lib/authClient.ts reads it) and context extraHTTPHeaders
+// so page.request.* calls in specs carry X-Flight-Session too.
+
+export const SESSION_KEY = 'flight.session'; // must match lib/authClient.ts
+
+// v1.7.0 (ISS-116): optional username — mints a SECOND account with onboarding (the route has
+// supported the override since v1.1.0; this helper just never forwarded it). No arg = the suite's
+// usual local player, exactly as before.
+export async function mintPlayerSession(page: Page, username?: string): Promise<string> {
+  const res = await page.request.post('/api/test/mint-player-session', { data: username ? { username } : {} });
+  expect(res.status(), 'mint-player-session hook should be enabled in the CI stack (FLIGHT_TEST_HOOKS=1)').toBe(200);
+  return ((await res.json()) as { sessionId: string }).sessionId;
+}
+
+export async function applySession(page: Page, sessionId: string): Promise<void> {
+  await page.context().setExtraHTTPHeaders({ 'X-Flight-Session': sessionId });
+  // Runs before every navigation's scripts — the app reads the session from localStorage on load.
+  await page.addInitScript(
+    ([key, sid]) => window.localStorage.setItem(key, sid),
+    [SESSION_KEY, sessionId],
+  );
+}
+
+export async function authenticate(page: Page): Promise<string> {
+  const sessionId = await mintPlayerSession(page);
+  await applySession(page, sessionId);
+  return sessionId;
+}

e2e/events.spec.ts

@@ -15,8 +15,14 @@ interface StateBody {
 // (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 () => {
+test('GET /api/events streams state snapshots over SSE', async ({ request }) => {
-  const res = await fetch(`${baseUrl}/api/events`, { headers: { Accept: 'text/event-stream' } });
+  // v1.1.0 (ISS-107): the stream is session-guarded — EventSource cannot set headers, so the client
+  // passes ?session= (requireAuthSse). Mint one via the test hook and use exactly that path.
+  const mint = await request.post('/api/test/mint-player-session');
+  expect(mint.status(), 'mint-player-session hook should be enabled in the CI stack (FLIGHT_TEST_HOOKS=1)').toBe(200);
+  const { sessionId } = (await mint.json()) as { sessionId: string };
+
+  const res = await fetch(`${baseUrl}/api/events?session=${sessionId}`, { 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();

e2e/hover.spec.ts

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

e2e/maintenance.spec.ts

@@ -3,6 +3,11 @@ import { expect, test } from '@playwright/test';
 // v0.39.0 (ISS-069) — maintenance: expectations use the real balance constants.
 import { REPAIR_COST } from '../lib/game/catalog';
 
+import { authenticate } from './auth';
+
+// v1.1.0 (ISS-107): game routes are session-guarded — mint + apply a player session before every test.
+test.beforeEach(async ({ page }) => { await authenticate(page); });
+
 // v0.39.0 (ISS-069), reworked in v0.45.0 (ISS-089) — maintenance visible flow against the live
 // origin: health is shown per plane in the fleet list; forcing it to 0 via the set-health hook shows
 // the "broken" pill and blocks dispatch with a 409 that mutates nothing; clicking Repair deducts

e2e/map-interactions.spec.ts

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

e2e/map.spec.ts

@@ -2,6 +2,11 @@ import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { test, expect, type Page } from '@playwright/test';
 
+import { authenticate } from './auth';
+
+// v1.1.0 (ISS-107): game routes are session-guarded — mint + apply a player session before every test.
+test.beforeEach(async ({ page }) => { await authenticate(page); });
+
 const APP_URL = '/';
 
 // Read at test time so the assertion tracks package.json automatically.
@@ -73,6 +78,17 @@ test('header shows the app version sourced from package.json', async ({ page })
   );
 });
 
+// v1.10.0 (ISS-157): top-bar Log out — same drop-to-sign-in as the admin panel's button
+// (mirrors e2e/admin.spec.ts' logout assertion).
+test('top bar Log out drops back to the sign-in screen', async ({ page }) => {
+  await page.goto(APP_URL);
+  const header = page.getByTestId('app-header');
+  await expect(header).toBeVisible({ timeout: 30_000 });
+  await page.getByTestId('logout-btn').click();
+  await expect(page.getByTestId('sign-in-form')).toBeVisible({ timeout: 10_000 });
+  await expect(header).toHaveCount(0);
+});
+
 test('clicking an airport marker opens a popup with name and ICAO', async ({ page }) => {
   await page.goto(APP_URL);
   await waitForAirportCount(page);

e2e/multiplayer.spec.ts

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

e2e/panes.spec.ts

@@ -1,5 +1,10 @@
 import { test, expect, type Page } from '@playwright/test';
 
+import { authenticate } from './auth';
+
+// v1.1.0 (ISS-107): game routes are session-guarded — mint + apply a player session before every test.
+test.beforeEach(async ({ page }) => { await authenticate(page); });
+
 // 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).
 

e2e/queue.spec.ts

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

e2e/relocation.spec.ts

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

e2e/right-pane.spec.ts

@@ -9,6 +9,11 @@ import { fuelAtWeighted, guaranteedRangeKm, windBurnFactor } from '../lib/sim/mo
 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';
 
+import { authenticate } from './auth';
+
+// v1.1.0 (ISS-107): game routes are session-guarded — mint + apply a player session before every test.
+test.beforeEach(async ({ page }) => { await authenticate(page); });
+
 // v0.12.0 — right Jobs & Market pane against the live origin: open packages render with
 // names/reward/deadline and Load (UI click) binds one to the starter; the on-board list
 // (moved to the left pane in v0.20.0, ISS-021) shows loaded packages with fly-to-destination +

e2e/sim.spec.ts

@@ -4,6 +4,11 @@ import { test, expect, type Page } from '@playwright/test';
 // pool, at EDDF.
 import { POOL_TARGET_PER_AIRPORT as POOL_TARGET } from '../lib/game/seed';
 
+import { authenticate } from './auth';
+
+// v1.1.0 (ISS-107): game routes are session-guarded — mint + apply a player session before every test.
+test.beforeEach(async ({ page }) => { await authenticate(page); });
+
 // v0.52.0 (ISS-117), finalized in #135: fixed world clock against the live origin — a fully
 // grounded fleet freezes the clock, background-tick advance at a raised rate while something is
 // active, package expiry via the FLIGHT_TEST_HOOKS hooks (enabled in docker-compose.yml), and

e2e/state.spec.ts

@@ -2,6 +2,11 @@ import { execSync } from 'node:child_process';
 import path from 'node:path';
 import { test, expect } from '@playwright/test';
 
+import { authenticate } from './auth';
+
+// v1.1.0 (ISS-107): game routes are session-guarded — mint + apply a player session before every test.
+test.beforeEach(async ({ page }) => { await authenticate(page); });
+
 // Repo root — docker-compose.yml lives here; `docker compose restart` runs on
 // this host (the test runner), browsers stay remote. CI points E2E_COMPOSE_ARGS at the
 // isolated stack file + project (-f docker-compose.ci.yml -p flight-ci) instead of the default one.

e2e/toasts.spec.ts

@@ -1,6 +1,11 @@
 import type { Page } from '@playwright/test';
 import { expect, test } from '@playwright/test';
 
+import { authenticate } from './auth';
+
+// v1.1.0 (ISS-107): game routes are session-guarded — mint + apply a player session before every test.
+test.beforeEach(async ({ page }) => { await authenticate(page); });
+
 // v0.17.0 — ISS-008: action errors surface as toasts at the map's right edge (clear of the
 // right pane, in addition to the inline pane error) and game events appear as info toasts via
 // snapshot diffing; the left-pane Time section offers an explicit "Enable notifications" opt-in

e2e/two-planes.spec.ts

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

lib/auth.test.ts

@@ -0,0 +1,87 @@
+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, hashPassword, requireAuth, verifyPassword } from './auth';
+
+// v1.1.0 (ISS-107) — the session guard every game route funnels through. Same temp-DB pattern as
+// the other API tests: FLIGHT_DB_PATH points at a throwaway file, fresh singleton per test file.
+
+let dir: string;
+
+beforeAll(async () => {
+  dir = await fs.mkdtemp(path.join(os.tmpdir(), 'flight-auth-'));
+  process.env.FLIGHT_DB_PATH = path.join(dir, 'auth.db');
+});
+
+afterAll(async () => {
+  delete process.env.FLIGHT_DB_PATH;
+  await fs.rm(dir, { recursive: true, force: true });
+});
+
+const reqWith = (sessionId?: string) =>
+  new Request('http://localhost/api/state', { headers: sessionId ? { 'X-Flight-Session': sessionId } : {} });
+
+describe('hashPassword / verifyPassword', () => {
+  it('round-trips a password through the stored digest', () => {
+    const hash = hashPassword('correct-horse-battery-staple');
+    expect(hash).toMatch(/^[0-9a-f]{32}\$/); // 16-byte hex salt + 32-byte scrypt, like the seeded admin's
+    expect(verifyPassword('correct-horse-battery-staple', hash)).toBe(true);
+  });
+
+  it('rejects a wrong password and malformed digests', () => {
+    const hash = hashPassword('some-password');
+    expect(verifyPassword('other-password', hash)).toBe(false);
+    expect(verifyPassword('x', 'not-a-digest')).toBe(false);
+    expect(verifyPassword('x', '')).toBe(false);
+  });
+});
+
+describe('requireAuth', () => {
+  it('401s when the header is missing or the session id is unknown', async () => {
+    for (const req of [reqWith(), reqWith('no-such-session')]) {
+      const guard = await requireAuth(req);
+      expect(guard.ok).toBe(false);
+      if (!guard.ok) {
+        expect(guard.response.status).toBe(401);
+        expect(((await guard.response.json()) as { error: string }).error).toMatch(/authentication required/i);
+      }
+    }
+  });
+
+  it('401s an expired session', async () => {
+    const inst = await getGameDb();
+    inst.raw.run("INSERT INTO sessions (id, user_id, expires_at) VALUES ('expired-sess', 'admin-kamilkrzywda', ?)", [Date.now() - 1]);
+    const guard = await requireAuth(reqWith('expired-sess'));
+    expect(guard.ok).toBe(false);
+    if (!guard.ok) expect(guard.response.status).toBe(401);
+  });
+
+  it('resolves the seeded admin session to the local player row (joined on username)', async () => {
+    const inst = await getGameDb();
+    const sessionId = await createSession(inst, 'admin-kamilkrzywda');
+    const guard = await requireAuth(reqWith(sessionId));
+    expect(guard.ok).toBe(true);
+    if (guard.ok) {
+      expect(guard.user.username).toBe('kamilkrzywda');
+      expect(guard.player.id).toBe('local'); // the v1.0.0 migration's local player row
+      expect(guard.player.cash).toBe(20_000); // starter economy from the seed
+    }
+  });
+
+  it('500s when the account has no players row (broken data, not a client error)', async () => {
+    const inst = await getGameDb();
+    inst.raw.run("INSERT INTO users (id, username, password_hash, admin, created_at) VALUES ('user-no-player', 'no-player-user', ?, 0, ?)", [
+      hashPassword('whatever-123'),
+      Date.now(),
+    ]);
+    const sessionId = await createSession(inst, 'user-no-player');
+    const guard = await requireAuth(reqWith(sessionId));
+    expect(guard.ok).toBe(false);
+    if (!guard.ok) {
+      expect(guard.response.status).toBe(500);
+      expect(((await guard.response.json()) as { error: string }).error).toMatch(/player row missing/i);
+    }
+  });
+});

lib/auth.ts

@@ -1,5 +1,6 @@
-import { randomUUID, scryptSync, timingSafeEqual } from 'node:crypto';
+import { randomBytes, randomUUID, scryptSync, timingSafeEqual } from 'node:crypto';
 import { getGameDb, persist, type GameDb } from '@/lib/db/client';
+import type { PlayerRow } from './db/schema';
 
 // 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
@@ -32,6 +33,15 @@ export function verifyPassword(password: string, storedHash: string): boolean {
   }
 }
 
+// Hash a plaintext password into the "salt$hex" scrypt digest verifyPassword() checks — the same
+// call shape as the seeded admin's digest (v0.72.0): 16-byte hex salt passed to scryptSync as a
+// plain string, 32-byte hash. Used by /api/register and the test mint hook so every stored hash
+// verifies through verifyPassword().
+export function hashPassword(password: string): string {
+  const salt = randomBytes(16).toString('hex');
+  return `${salt}$${scryptSync(password, salt, 32).toString('hex')}`;
+}
+
 // 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> {
@@ -46,11 +56,8 @@ export async function createSession(inst: GameDb, userId: string): Promise<strin
   return id;
 }
 
-// Resolve the X-Flight-Session header to a live (non-expired) user, or null.
+// Resolve a session id to a live (non-expired) user, or null.
-export async function currentUser(req: Request): Promise<AuthUser | null> {
+async function resolveSession(inst: GameDb, sessionId: string): 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()],
@@ -60,6 +67,47 @@ export async function currentUser(req: Request): Promise<AuthUser | null> {
   return { id: String(row[0]), username: String(row[1]), admin: Number(row[2]) === 1 };
 }
 
+// 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;
+  return resolveSession(await getGameDb(), sessionId);
+}
+
+export type AuthGuard =
+  | { ok: true; inst: GameDb; user: AuthUser; player: PlayerRow }
+  | { ok: false; response: Response };
+
+// v1.1.0 (ISS-107): guard for every game route — resolves the session to its user AND that
+// user's players row (joined on username, so the seeded kamilkrzywda maps to id 'local').
+// 401 when the session is missing/unknown/expired; 500 if the account has no player row
+// (register and the mint hook always create both together — a miss means broken data).
+async function finishAuth(user: AuthUser | null): Promise<AuthGuard> {
+  if (!user) return { ok: false, response: Response.json({ error: 'authentication required' }, { status: 401 }) };
+  const inst = await getGameDb();
+  const res = inst.raw.exec('SELECT id, provider, username, cash, reputation FROM players WHERE username = ?', [user.username]);
+  const row = res[0]?.values?.[0];
+  if (!row) return { ok: false, response: Response.json({ error: 'player row missing for this account' }, { status: 500 }) };
+  return {
+    ok: true,
+    inst,
+    user,
+    player: { id: String(row[0]), provider: String(row[1]), username: String(row[2]), cash: Number(row[3]), reputation: Number(row[4]) },
+  };
+}
+
+export async function requireAuth(req: Request): Promise<AuthGuard> {
+  return finishAuth(await currentUser(req));
+}
+
+// /api/events only — EventSource cannot set headers, so the SSE route also accepts the session as a
+// ?session= query parameter (private infra; every other game route is header-only).
+export async function requireAuthSse(req: Request): Promise<AuthGuard> {
+  const sessionId = req.headers.get(SESSION_HEADER) ?? new URL(req.url).searchParams.get('session');
+  if (!sessionId) return finishAuth(null);
+  return finishAuth(await resolveSession(await getGameDb(), sessionId));
+}
+
 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.

lib/authClient.ts

@@ -0,0 +1,34 @@
+'use client';
+
+// v1.1.0 (ISS-107) — client-side session handling shared by every authenticated fetcher, the
+// sign-in screen and the admin panel. The server mints sessions at /api/login + /api/register;
+// we only store the id in localStorage and echo it back as X-Flight-Session.
+
+export const SESSION_STORAGE_KEY = 'flight.session';
+
+export function storedSession(): string | null {
+  if (typeof window === 'undefined') return null;
+  try {
+    return window.localStorage.getItem(SESSION_STORAGE_KEY);
+  } catch {
+    return null; // storage blocked (private mode) — treat as signed out
+  }
+}
+
+// Headers for an authenticated fetch. Empty object when no session is stored, so callers can
+// spread it into their existing header objects without branching.
+export function sessionHeaders(session: string | null = storedSession()): Record<string, string> {
+  return session ? { 'X-Flight-Session': session } : {};
+}
+
+export function storeSession(sessionId: string): void {
+  window.localStorage.setItem(SESSION_STORAGE_KEY, sessionId);
+}
+
+export function clearStoredSession(): void {
+  try {
+    window.localStorage.removeItem(SESSION_STORAGE_KEY);
+  } catch {
+    // storage blocked — nothing to clear
+  }
+}

lib/db/client.test.ts

@@ -2,12 +2,17 @@ import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import initSqlJs from 'sql.js';
+import { eq } from 'drizzle-orm';
 import { afterAll, beforeAll, describe, expect, it } from 'vitest';
 import { WORLD_TIME_SCALE } from '@/lib/worldClock';
-import { STARTING_CLOCK_MS } from '@/lib/game/seed';
+import { STARTING_CASH, STARTING_CLOCK_MS, STARTING_REPUTATION } from '@/lib/game/seed';
 import { openGameDb, persist } from './client';
+import { getLocalPlayer, updateLocalPlayerEconomy } from './localPlayer';
 import * as schema from './schema';
 
+// v1.0.0 (ISS-105): the local player row every fresh/migrated world must carry.
+const LOCAL_PLAYER_ROW = { id: 'local', provider: 'local', username: 'kamilkrzywda' };
+
 // The v0.6.0 DDL — used to build a "legacy" DB file for the migration test.
 const LEGACY_DDL = `
 CREATE TABLE planes (
@@ -84,6 +89,40 @@ CREATE TABLE sim_state (
 );
 `;
 
+// The v1.1.0 DDL — the last schema before ownership (ISS-109); used to build a "pre-v1.2.0" DB
+// file for the owner_id backfill migration test.
+const PRE_OWNERSHIP_DDL = `
+CREATE TABLE planes (
+  id TEXT PRIMARY KEY NOT NULL,
+  model TEXT NOT NULL,
+  status TEXT NOT NULL,
+  fuel REAL NOT NULL,
+  max_fuel REAL NOT NULL,
+  location_icao TEXT NOT NULL,
+  dest_icao TEXT,
+  lat REAL NOT NULL,
+  lon REAL NOT NULL,
+  departure_sim_time INTEGER,
+  queue TEXT NOT NULL DEFAULT '[]',
+  health REAL NOT NULL DEFAULT 100,
+  repair_until_sim_time INTEGER
+);
+CREATE TABLE players (
+  id TEXT PRIMARY KEY NOT NULL,
+  provider TEXT NOT NULL,
+  username TEXT NOT NULL,
+  cash REAL NOT NULL,
+  reputation REAL NOT NULL
+);
+CREATE TABLE sim_state (
+  clock_ms INTEGER NOT NULL,
+  time_scale REAL NOT NULL,
+  paused INTEGER NOT NULL,
+  last_real_tick_ms INTEGER NOT NULL DEFAULT 0,
+  last_selected_time_scale REAL NOT NULL DEFAULT 1
+);
+`;
+
 let dir: string;
 
 beforeAll(async () => {
@@ -110,8 +149,13 @@ describe('openGameDb', () => {
     expect(packages.length).toBeGreaterThanOrEqual(8);
     expect(packages.every((p) => p.status === 'open')).toBe(true);
 
-    const account = (await inst.db.select().from(schema.account))[0];
+    // v1.0.0 (ISS-105): the singleton economy is now a seeded local player row…
-    expect(account?.cash).toBeGreaterThan(0);
+    expect(await getLocalPlayer(inst)).toEqual({ ...LOCAL_PLAYER_ROW, cash: STARTING_CASH, reputation: STARTING_REPUTATION });
+    // …and fresh DBs never create an `account` table.
+    const tables = new Set(
+      inst.raw.exec("SELECT name FROM sqlite_master WHERE type='table'")[0].values.map((r) => String(r[0])),
+    );
+    expect(tables.has('account')).toBe(false);
     const sim = (await inst.db.select().from(schema.simState))[0];
     // ISS-117: fresh worlds start at the year-2000 game clock with the fixed world rate.
     expect(sim?.clockMs).toBe(STARTING_CLOCK_MS);
@@ -126,25 +170,25 @@ describe('openGameDb', () => {
     const file = path.join(dir, 'reopen.db');
     const first = await openGameDb(file);
     const packages1 = (await first.db.select().from(schema.packages)).map((p) => p.id).sort();
-    const account1 = (await first.db.select().from(schema.account))[0];
+    const player1 = await getLocalPlayer(first);
 
     // Simulate a process restart: brand-new instance over the same file.
     const second = await openGameDb(file);
     const packages2 = (await second.db.select().from(schema.packages)).map((p) => p.id).sort();
     expect(packages2).toEqual(packages1);
-    expect((await second.db.select().from(schema.account))[0]).toEqual(account1);
+    expect(await getLocalPlayer(second)).toEqual(player1);
   });
 
   it('persist() durably saves writes made after open', async () => {
     const file = path.join(dir, 'write.db');
     const inst = await openGameDb(file);
 
-    await inst.db.update(schema.account).set({ cash: 12345 });
+    await updateLocalPlayerEconomy(inst, { cash: 12345 });
     await persist(inst);
 
     // A fresh instance over the same file sees the update.
     const reloaded = await openGameDb(file);
-    expect((await reloaded.db.select().from(schema.account))[0]?.cash).toBe(12345);
+    expect((await getLocalPlayer(reloaded)).cash).toBe(12345);
   });
 
   it('migrates a pre-v0.7.0 database: adds new columns and fixes last_real_tick_ms', async () => {
@@ -161,8 +205,8 @@ describe('openGameDb', () => {
 
     const inst = await openGameDb(file);
 
-    // Not re-seeded (account row exists)…
+    // Not re-seeded (the legacy account row was migrated into the local player)…
-    expect((await inst.db.select().from(schema.account))[0]?.cash).toBe(20000);
+    expect((await getLocalPlayer(inst)).cash).toBe(20000);
     // …but the new columns exist and are usable…
     const plane = (await inst.db.select().from(schema.planes))[0];
     expect(plane?.departureSimTime ?? null).toBeNull();
@@ -194,8 +238,8 @@ describe('openGameDb', () => {
 
     const inst = await openGameDb(file);
 
-    // Wallet + sim clock survive byte-identical…
+    // Wallet (migrated into the local player) + sim clock survive byte-identical…
-    expect((await inst.db.select().from(schema.account))[0]).toEqual({ cash: 54020.34, reputation: 62.57 });
+    expect(await getLocalPlayer(inst)).toEqual({ ...LOCAL_PLAYER_ROW, cash: 54020.34, reputation: 62.57 });
     expect((await inst.db.select().from(schema.simState))[0]?.clockMs).toBe(1_789_706_016_605);
 
     // …the in-flight plane is reset to GROUNDED at its locationIcao (it "lands" back where it took off)…
@@ -223,7 +267,10 @@ describe('openGameDb', () => {
   });
 
   // v0.71.0: the seeded admin row — hash-only, idempotent across every open().
-  const ADMIN_HASH = '8dbed630b49a15073e8be571367c1858$0e5207dae2e3c813a7172a5f610fd47a90e8ff17513180ab1e0a7779c3766ef0';
+  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');
@@ -254,8 +301,40 @@ describe('openGameDb', () => {
     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.
+    // The game world is untouched by the seed (its account row migrated to the local player).
-    expect((await inst.db.select().from(schema.account))[0]?.cash).toBe(20000);
+    expect((await getLocalPlayer(inst)).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 () => {
@@ -280,4 +359,58 @@ describe('openGameDb', () => {
     expect(plane.status).toBe('flying');
     expect(plane.destIcao).toBe('LEMD');
   });
+
+  it('migrates a pre-v1.0.0 database: copies the singleton account into the local player and drops it', async () => {
+    // Minimal legacy file — just an `account` table; open() creates everything else from DDL.
+    const SQL = await initSqlJs();
+    const raw = new SQL.Database();
+    raw.exec(`CREATE TABLE account (cash REAL NOT NULL, reputation REAL NOT NULL)`);
+    raw.exec(`INSERT INTO account VALUES (77123.45, 88.5)`);
+    const file = path.join(dir, 'pre-v1.db');
+    await fs.writeFile(file, Buffer.from(raw.export()));
+
+    const inst = await openGameDb(file);
+    expect(await getLocalPlayer(inst)).toEqual({ ...LOCAL_PLAYER_ROW, cash: 77123.45, reputation: 88.5 });
+    let tables = new Set(
+      inst.raw.exec("SELECT name FROM sqlite_master WHERE type='table'")[0].values.map((r) => String(r[0])),
+    );
+    expect(tables.has('account')).toBe(false);
+
+    // Second open is a no-op (idempotent): the row survives unchanged, still exactly one player.
+    const second = await openGameDb(file);
+    expect(await getLocalPlayer(second)).toEqual({ ...LOCAL_PLAYER_ROW, cash: 77123.45, reputation: 88.5 });
+    tables = new Set(
+      second.raw.exec("SELECT name FROM sqlite_master WHERE type='table'")[0].values.map((r) => String(r[0])),
+    );
+    expect(tables.has('account')).toBe(false);
+    expect(Number(second.raw.exec('SELECT COUNT(*) FROM players')[0].values[0][0])).toBe(1);
+  });
+
+  it('migrates a pre-v1.2.0 database: backfills planes.owner_id to the local player (one-shot)', async () => {
+    // A v1.1.0-era file: two planes without owner_id, the seeded local player row, live sim clock.
+    const SQL = await initSqlJs();
+    const raw = new SQL.Database();
+    raw.exec(PRE_OWNERSHIP_DDL);
+    raw.exec(`INSERT INTO planes VALUES ('plane-starter', 'atr72', 'available', 6300, 6300, 'EDDF', NULL, 50.03, 8.57, NULL, '[]', 100, NULL)`);
+    raw.exec(`INSERT INTO planes VALUES ('plane-bought', 'atr72', 'available', 6300, 6300, 'LEMD', NULL, 40.4, -3.6, NULL, '[]', 100, NULL)`);
+    raw.exec(`INSERT INTO players VALUES ('local', 'local', 'kamilkrzywda', 54020.34, 62.57)`);
+    raw.exec('INSERT INTO sim_state VALUES (1789706016605, 1, 0, 1789718713288, 1)');
+    const file = path.join(dir, 'pre-ownership.db');
+    await fs.writeFile(file, Buffer.from(raw.export()));
+
+    const inst = await openGameDb(file);
+
+    // Every legacy plane is backfilled to the local player…
+    const owners = (await inst.db.select().from(schema.planes)).map((p) => p.ownerId).sort();
+    expect(owners).toEqual(['local', 'local']);
+    // …and the world was NOT re-seeded (the players row already existed).
+    expect(await getLocalPlayer(inst)).toEqual({ ...LOCAL_PLAYER_ROW, cash: 54020.34, reputation: 62.57 });
+
+    // Second open is a no-op: an owner change made after the migration survives a reopen.
+    await inst.db.update(schema.planes).set({ ownerId: 'someone-else' }).where(eq(schema.planes.id, 'plane-bought'));
+    await persist(inst);
+    const second = await openGameDb(file);
+    const owners2 = (await second.db.select().from(schema.planes)).map((p) => p.ownerId).sort();
+    expect(owners2).toEqual(['local', 'someone-else']);
+  });
 });

lib/db/client.ts

@@ -5,6 +5,7 @@ import { drizzle, type SQLJsDatabase } from 'drizzle-orm/sql-js';
 import initSqlJs, { type Database as RawSqlJsDatabase } from 'sql.js';
 import { loadAirportsGeoJson } from '@/lib/airports';
 import { buildSeed, mulberry32 } from '@/lib/game/seed';
+import { LOCAL_PLAYER } from './localPlayer';
 import * as schema from './schema';
 
 // SQLite via sql.js (WASM) — no native compilation, so it builds and runs in the
@@ -22,6 +23,9 @@ export interface GameDb {
 const DDL = `
 CREATE TABLE IF NOT EXISTS planes (
   id TEXT PRIMARY KEY NOT NULL,
+  -- v1.2.0 (ISS-109): owner's players.id — ownership checks in lib/game/actions.ts; legacy rows
+  -- backfill to 'local' via the guarded ALTER below (migrateColumns).
+  owner_id TEXT NOT NULL,
   model TEXT NOT NULL,
   status TEXT NOT NULL,
   fuel REAL NOT NULL,
@@ -51,7 +55,12 @@ CREATE TABLE IF NOT EXISTS packages (
   created_real_ms INTEGER NOT NULL DEFAULT 0,
   slot_free_at_real_ms INTEGER
 );
-CREATE TABLE IF NOT EXISTS account (
+-- v1.0.0 (ISS-105): per-player economy — replaces the singleton account table; the local
+-- single-player row is seeded by seedEmpty() or migrated from account in open().
+CREATE TABLE IF NOT EXISTS players (
+  id TEXT PRIMARY KEY NOT NULL,
+  provider TEXT NOT NULL,
+  username TEXT NOT NULL,
   cash REAL NOT NULL,
   reputation REAL NOT NULL
 );
@@ -79,7 +88,10 @@ CREATE TABLE IF NOT EXISTS sessions (
 
 // 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.
-const ADMIN_SEED_HASH = '8dbed630b49a15073e8be571367c1858$0e5207dae2e3c813a7172a5f610fd47a90e8ff17513180ab1e0a7779c3766ef0';
+// 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.
@@ -90,6 +102,13 @@ function seedAdminUser(raw: RawSqlJsDatabase): void {
      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
@@ -143,6 +162,12 @@ function migrateColumns(raw: RawSqlJsDatabase): void {
     raw.exec('ALTER TABLE sim_state ADD COLUMN last_selected_time_scale REAL NOT NULL DEFAULT 1');
     raw.exec('UPDATE sim_state SET last_selected_time_scale = time_scale');
   }
+  // v1.2.0 (ISS-109): plane ownership — pre-v1.2.0 rows backfill to the seeded local player, so a
+  // migrated world's planes all belong to 'local' exactly as before (the column is NOT NULL with a
+  // constant default, which SQLite applies to every existing row at ALTER time).
+  if (!cols('planes').has('owner_id')) {
+    raw.exec(`ALTER TABLE planes ADD COLUMN owner_id TEXT NOT NULL DEFAULT 'local'`);
+  }
 }
 
 // v0.12.0 one-time migration: contracts world → packages world. Detected by the
@@ -172,6 +197,17 @@ function migrateContractsToPackages(raw: RawSqlJsDatabase): void {
   raw.exec('DROP TABLE contracts');
 }
 
+// v1.0.0 (ISS-105) one-time migration: singleton `account` row → seeded local player, then drop
+// the table. Detected by sqlite_master like migrateContractsToPackages — fresh DBs never have
+// `account`, so this runs exactly once per legacy file and is a no-op on later opens.
+function migrateAccountToPlayers(raw: RawSqlJsDatabase): void {
+  raw.run(
+    'INSERT INTO players (id, provider, username, cash, reputation) SELECT ?, ?, ?, cash, reputation FROM account',
+    [LOCAL_PLAYER.id, LOCAL_PLAYER.provider, LOCAL_PLAYER.username],
+  );
+  raw.exec('DROP TABLE account');
+}
+
 // FLIGHT_DB_PATH override exists so unit tests can point at a temp file instead
 // of the real ./db/flight.db.
 export function defaultDbPath(): string {
@@ -199,12 +235,18 @@ async function open(file: string): Promise<GameDb> {
   if (tables.has('contracts')) {
     migrateContractsToPackages(raw);
   }
+  // v1.0.0 (ISS-105): legacy files still carry the singleton `account` table — copy its row into a
+  // seeded local player and drop it. The players-empty guard makes this idempotent even if a file
+  // somehow had both tables; fresh DBs never have `account`, so this runs exactly once per file.
+  const playerCount = Number(raw.exec('SELECT COUNT(*) FROM players')[0].values[0]?.[0] ?? 0);
+  if (tables.has('account') && playerCount === 0) {
+    migrateAccountToPlayers(raw);
+  }
 
   const instance: GameDb = { db: drizzle(raw, { schema }), raw, file };
 
-  // First-run seed: only when the DB is empty (no account row yet).
+  // First-run seed: only when the DB is empty (no player row yet).
-  const res = raw.exec('SELECT COUNT(*) FROM account');
+  if (playerCount === 0 && !tables.has('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);
   }
@@ -234,9 +276,11 @@ async function seedEmpty(instance: GameDb): Promise<void> {
 
   // SeedPlane.queue is a string[]; the column stores it as JSON text.
   const { queue, ...planeCols } = data.plane;
-  await instance.db.insert(schema.planes).values({ ...planeCols, queue: JSON.stringify(queue ?? []) });
+  // v1.2.0 (ISS-109): the fresh-install starter plane belongs to the seeded local player.
+  await instance.db.insert(schema.planes).values({ ...planeCols, ownerId: LOCAL_PLAYER.id, queue: JSON.stringify(queue ?? []) });
   await instance.db.insert(schema.packages).values(data.packages);
-  await instance.db.insert(schema.account).values(data.account);
+  // v1.0.0 (ISS-105): the singleton economy now lives in a seeded local player row.
+  await instance.db.insert(schema.players).values({ ...LOCAL_PLAYER, cash: data.account.cash, reputation: data.account.reputation });
   await instance.db.insert(schema.simState).values(data.simState);
   await persist(instance);
 }

lib/db/localPlayer.ts

@@ -0,0 +1,49 @@
+import { eq, max } from 'drizzle-orm';
+import type { GameDb } from './client';
+import * as schema from './schema';
+
+// v1.0.0 (ISS-105): single-player economy access — resolves the seeded local player row. As of
+// v1.3.0 (ISS-110) every per-player read/write goes through getPlayer/updatePlayerEconomy below;
+// these 'local' helpers remain ONLY for env-gated /api/test/* admin hooks that stage the SEEDED
+// account with no acting session. Since v1.4.0 (ISS-112) even the SSE broadcast is per-player, and
+// since v1.5.0 (ISS-111) shared-world job quality reads getSharedWorldReputation instead of a row.
+
+export const LOCAL_PLAYER = { id: 'local', provider: 'local', username: 'kamilkrzywda' } as const;
+
+export async function getLocalPlayer(inst: GameDb): Promise<schema.PlayerRow> {
+  const [row] = await inst.db.select().from(schema.players).where(eq(schema.players.id, LOCAL_PLAYER.id));
+  if (!row) throw new Error('local player row missing');
+  return row;
+}
+
+export async function updateLocalPlayerEconomy(
+  inst: GameDb,
+  patch: { cash?: number; reputation?: number },
+): Promise<void> {
+  await inst.db.update(schema.players).set(patch).where(eq(schema.players.id, LOCAL_PLAYER.id));
+}
+
+// v1.2.0 (ISS-109), standard path since v1.3.0 (ISS-110): actions, engine delivery/top-up and
+// session-scoped snapshots thread the acting player's id through and read/write THAT row; the
+// 'local' helpers above are reserved for world-level reads with no acting session.
+export async function getPlayer(inst: GameDb, id: string): Promise<schema.PlayerRow> {
+  const [row] = await inst.db.select().from(schema.players).where(eq(schema.players.id, id));
+  if (!row) throw new Error(`player ${id} missing`);
+  return row;
+}
+
+export async function updatePlayerEconomy(
+  inst: GameDb,
+  id: string,
+  patch: { cash?: number; reputation?: number },
+): Promise<void> {
+  await inst.db.update(schema.players).set(patch).where(eq(schema.players.id, id));
+}
+
+// v1.5.0 (ISS-111), the #101 decision point resolved: shared-world job quality is the MAX
+// reputation across ALL player rows — spawned pool packages scale to the best-progressed player so
+// nobody is stuck on low-rep jobs. 0 when there are no players (repRate floors at ×1 either way).
+export async function getSharedWorldReputation(inst: GameDb): Promise<number> {
+  const [row] = await inst.db.select({ m: max(schema.players.reputation) }).from(schema.players);
+  return row?.m ?? 0;
+}

lib/db/schema.ts

@@ -6,6 +6,10 @@ import { integer, real, sqliteTable, text } from 'drizzle-orm/sqlite-core';
 
 export const planes = sqliteTable('planes', {
   id: text('id').primaryKey().notNull(),
+  // v1.2.0 (ISS-109): owner's players.id — every plane action requires the session player to own
+  // the plane (403 otherwise). Legacy rows backfill to 'local' in open(); fresh installs and
+  // onboarding stamp it explicitly on insert.
+  ownerId: text('owner_id').notNull(),
   model: text('model').notNull(),
   // v0.39.0 (ISS-069): 'repairing' = grounded in the shop until repairUntilSimTime passes; the
   // engine flips it back to 'available' on a tick. All status guards key off 'available'.
@@ -66,7 +70,13 @@ export const packages = sqliteTable('packages', {
   slotFreeAtRealMs: integer('slot_free_at_real_ms'),
 });
 
-export const account = sqliteTable('account', {
+// v1.0.0 (ISS-105): per-player economy — replaces the singleton `account` table. The local
+// single-player row (id 'local') is seeded on first run / migrated from `account` by open();
+// all pre-multiplayer code reaches it via lib/db/localPlayer.ts only.
+export const players = sqliteTable('players', {
+  id: text('id').primaryKey().notNull(),
+  provider: text('provider').notNull(),
+  username: text('username').notNull(),
   cash: real('cash').notNull(),
   reputation: real('reputation').notNull(),
 });
@@ -104,7 +114,7 @@ export const sessions = sqliteTable('sessions', {
 
 export type PlaneRow = typeof planes.$inferSelect;
 export type PackageRow = typeof packages.$inferSelect;
-export type AccountRow = typeof account.$inferSelect;
+export type PlayerRow = typeof players.$inferSelect;
 export type SimStateRow = typeof simState.$inferSelect;
 export type UserRow = typeof users.$inferSelect;
 export type SessionRow = typeof sessions.$inferSelect;

lib/deriveEvents.test.ts

@@ -25,6 +25,8 @@ const basePlane = (id: string): PlaneState => ({
   health: 100, // v0.39.0 (ISS-069) — full-health fixture default
   repairUntilSimTime: null,
   queue: [],
+  ownerId: 'local', // v1.4.0 (ISS-112) — owner info on every plane row
+  ownerName: 'kamilkrzywda',
 });
 
 const basePackage = (id: string): PackageState => ({
@@ -44,12 +46,14 @@ const basePackage = (id: string): PackageState => ({
   status: 'open',
   planeId: null,
   createdSimTime: 0,
+  carrierName: null, // v1.4.0 (ISS-112) — unassigned by default in fixtures
 });
 
 const snapshot = (over: Partial<StateSnapshot> = {}): StateSnapshot => ({
   account: { cash: 20_000, reputation: 10 },
   simState: { clockMs: 0 },
   planes: [basePlane('plane-starter')],
+  players: [], // v1.6.0 (ISS-115) — leaderboard rows; unused by the event diffing
   packages: [],
   catalog: CATALOG,
   fuelPricePerL: 0.8,
@@ -64,7 +68,7 @@ describe('diffSnapshots', () => {
     expect(diffSnapshots(prev, next)).toEqual([]);
   });
 
-  it('returns [] for the first snapshot (no baseline — no "new package" spam on page load)', () => {
+  it('returns [] for the first snapshot (no baseline to diff against)', () => {
     const next = snapshot({ packages: [basePackage('pkg-1'), basePackage('pkg-2')] });
     expect(diffSnapshots(null, next)).toEqual([]);
   });
@@ -113,14 +117,6 @@ describe('diffSnapshots', () => {
     expect(fromLoaded).toEqual([{ kind: 'info', message: 'Package expired: Frankfurt → Madrid–Barajas' }]);
   });
 
-  it('emits a new-package event for ids only in the next snapshot', () => {
-    const prev = snapshot({ packages: [basePackage('pkg-1')] });
-    const next = snapshot({ packages: [basePackage('pkg-1'), basePackage('pkg-2')] });
-    expect(diffSnapshots(prev, next)).toEqual([
-      { kind: 'info', message: 'New package available: Frankfurt → Madrid–Barajas' },
-    ]);
-  });
-
   it('emits bought/sold events when the plane id set changes (with the model name)', () => {
     const bought = diffSnapshots(
       snapshot(),

lib/deriveEvents.ts

@@ -15,8 +15,7 @@ export interface GameEvent {
 const planeName = (model: string): string => PLANE_TYPES[model]?.name ?? model;
 
 export function diffSnapshots(prev: StateSnapshot | null, next: StateSnapshot): GameEvent[] {
-  // No baseline yet (first snapshot after load) — nothing to compare against. Emitting a
+  // No baseline yet (first snapshot after load) — nothing to diff against, so no events.
-  // "new package" event for every existing row would spam the stack on page load.
   if (prev === null) return [];
 
   const events: GameEvent[] = [];
@@ -40,16 +39,12 @@ export function diffSnapshots(prev: StateSnapshot | null, next: StateSnapshot):
     }
   }
 
-  // Packages: delivered (loaded → delivered, reward paid out in the same tick), expired
+  // Packages: delivered (loaded → delivered, reward paid out in the same tick) and expired
-  // (open|loaded → expired), newly appeared (id only in next — terminal packages are never
+  // (open|loaded → expired). Ids that appear for the first time emit nothing.
-  // deleted, so an id appearing is always a genuinely new one).
   const prevPackages = new Map(prev.packages.map((p) => [p.id, p]));
   for (const pkg of next.packages) {
     const before = prevPackages.get(pkg.id);
-    if (!before) {
+    if (!before) continue;
-      events.push({ kind: 'info', message: `New package available: ${pkg.originName} → ${pkg.destName}` });
-      continue;
-    }
     if (before.status === 'loaded' && pkg.status === 'delivered') {
       events.push({ kind: 'info', message: `Package delivered: +${formatCash(pkg.reward)}` });
     } else if ((before.status === 'open' || before.status === 'loaded') && pkg.status === 'expired') {

lib/game/actions.test.ts

@@ -5,6 +5,7 @@ import { eq } from 'drizzle-orm';
 import { afterAll, beforeAll, describe, expect, it, vi } from 'vitest';
 import { openGameDb, type GameDb } from '@/lib/db/client';
 import * as schema from '@/lib/db/schema';
+import { getPlayer, getLocalPlayer, updateLocalPlayerEconomy, updatePlayerEconomy } from '@/lib/db/localPlayer';
 import { loadAirportsGeoJson } from '@/lib/airports';
 import { haversineKm, initialBearingDeg } from '@/lib/geo';
 import { weatherFor } from '@/lib/weather';
@@ -21,7 +22,7 @@ import {
   repRate,
   SELL_FRACTION,
 } from './catalog';
-import { HUB_ICAO, STARTING_CLOCK_MS } from './seed';
+import { HUB_ICAO, STARTING_CASH, STARTING_CLOCK_MS, STARTING_REPUTATION } from './seed';
 import {
   abandonPackage,
   buyPlane,
@@ -93,7 +94,7 @@ describe('loadPackage', () => {
     const inst = await freshDb('load-ok.db');
     await insertOpenPackage(inst);
 
-    await loadPackage(inst, 'p-open', 'plane-starter'); // seeded starter is grounded at EDDF
+    await loadPackage(inst, 'p-open', 'plane-starter', 'local'); // seeded starter is grounded at EDDF
 
     const row = (await inst.db.select().from(schema.packages).where(eq(schema.packages.id, 'p-open')))[0];
     expect(row.status).toBe('loaded');
@@ -106,19 +107,19 @@ describe('loadPackage', () => {
       const inst = await freshDb(`load-${status}.db`);
       await insertOpenPackage(inst, 'p-x', { status });
 
-      await expectActionError(loadPackage(inst, 'p-x', 'plane-starter'), 409, new RegExp(status));
+      await expectActionError(loadPackage(inst, 'p-x', 'plane-starter', 'local'), 409, new RegExp(status));
     },
   );
 
   it('rejects an unknown package id with 404', async () => {
     const inst = await freshDb('load-punknown.db');
-    await expectActionError(loadPackage(inst, 'nope', 'plane-starter'), 404);
+    await expectActionError(loadPackage(inst, 'nope', 'plane-starter', 'local'), 404);
   });
 
   it('rejects an unknown plane id with 404', async () => {
     const inst = await freshDb('load-ghost.db');
     await insertOpenPackage(inst);
-    await expectActionError(loadPackage(inst, 'p-open', 'ghost'), 404);
+    await expectActionError(loadPackage(inst, 'p-open', 'ghost', 'local'), 404);
   });
 
   it('rejects a flying plane with 409', async () => {
@@ -128,7 +129,7 @@ describe('loadPackage', () => {
       .set({ status: 'flying', departureSimTime: T0, destIcao: 'LEMD' })
       .where(eq(schema.planes.id, 'plane-starter'));
 
-    await expectActionError(loadPackage(inst, 'p-open', 'plane-starter'), 409);
+    await expectActionError(loadPackage(inst, 'p-open', 'plane-starter', 'local'), 409);
   });
 
   it('rejects a plane that is not at the origin with 409', async () => {
@@ -136,7 +137,7 @@ describe('loadPackage', () => {
     await insertOpenPackage(inst); // originates at EDDF
     await inst.db.update(schema.planes).set({ locationIcao: 'LEMD' }).where(eq(schema.planes.id, 'plane-starter'));
 
-    await expectActionError(loadPackage(inst, 'p-open', 'plane-starter'), 409, /at LEMD/);
+    await expectActionError(loadPackage(inst, 'p-open', 'plane-starter', 'local'), 409, /at LEMD/);
   });
 
   it('rejects loading when the plane has no payload room (maxPayloadKg from catalog)', async () => {
@@ -148,7 +149,7 @@ describe('loadPackage', () => {
       await insertOpenPackage(inst, `p-fill-${i}`, { status: 'loaded', planeId: 'plane-starter', weightKg: chunk });
     }
 
-    await expectActionError(loadPackage(inst, 'p-new', 'plane-starter'), 409, /no payload room/i);
+    await expectActionError(loadPackage(inst, 'p-new', 'plane-starter', 'local'), 409, /no payload room/i);
   });
 
   it('counts expired packages as occupying their payload too', async () => {
@@ -159,7 +160,7 @@ describe('loadPackage', () => {
     await insertOpenPackage(inst, 'p-loaded-half', { status: 'loaded', planeId: 'plane-starter', weightKg: half });
     await insertOpenPackage(inst, 'p-expired-slot', { status: 'expired', planeId: 'plane-starter', weightKg: half });
 
-    await expectActionError(loadPackage(inst, 'p-new', 'plane-starter'), 409, /no payload room/i);
+    await expectActionError(loadPackage(inst, 'p-new', 'plane-starter', 'local'), 409, /no payload room/i);
   });
 });
 
@@ -167,7 +168,7 @@ describe('flyPlane', () => {
   it('sets flying + departure at current clock + dest_icao + origin coords', async () => {
     const inst = await freshDb('fly-ok.db');
 
-    await flyPlane(inst, 'plane-starter', 'LEMD');
+    await flyPlane(inst, 'plane-starter', 'LEMD', 'local');
 
     const plane = (await inst.db.select().from(schema.planes))[0];
     expect(plane.status).toBe('flying');
@@ -187,38 +188,38 @@ describe('flyPlane', () => {
       .set({ status: 'flying', departureSimTime: T0, destIcao: 'LEMD' })
       .where(eq(schema.planes.id, 'plane-starter'));
 
-    await expectActionError(flyPlane(inst, 'plane-starter', 'EDDM'), 409);
+    await expectActionError(flyPlane(inst, 'plane-starter', 'EDDM', 'local'), 409);
   });
 
   it('rejects an unknown plane id with 404', async () => {
     const inst = await freshDb('fly-ghost.db');
-    await expectActionError(flyPlane(inst, 'ghost', 'LEMD'), 404);
+    await expectActionError(flyPlane(inst, 'ghost', 'LEMD', 'local'), 404);
   });
 
   it('rejects an ICAO not in the airport dataset with 400', async () => {
     const inst = await freshDb('fly-unknownicao.db');
-    await expectActionError(flyPlane(inst, 'plane-starter', 'ZZZZ'), 400, /unknown airport/);
+    await expectActionError(flyPlane(inst, 'plane-starter', 'ZZZZ', 'local'), 400, /unknown airport/);
   });
 
   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 fuelBefore = PLANE_TYPES.atr72.maxFuel; // seeded full tank
     await inst.db.update(schema.planes).set({ health: 0 }).where(eq(schema.planes.id, 'plane-starter'));
-    const cashBefore = (await inst.db.select().from(schema.account))[0].cash;
+    const cashBefore = (await getLocalPlayer(inst)).cash;
 
-    await expectActionError(flyPlane(inst, 'plane-starter', 'LEMD'), 409, /broken \(health 0\)/);
+    await expectActionError(flyPlane(inst, 'plane-starter', 'LEMD', 'local'), 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
+    expect((await getLocalPlayer(inst)).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
+    await flyPlane(inst, 'plane-starter', 'LEMD', 'local'); // no 409 — worn is not broken
 
     const plane = (await inst.db.select().from(schema.planes))[0];
     expect(plane.status).toBe('flying');
@@ -249,10 +250,10 @@ describe('flyPlane', () => {
     const startFuel = Math.round(required / 2); // partial tank below the requirement
     await inst.db.update(schema.planes).set({ fuel: startFuel }).where(eq(schema.planes.id, 'plane-starter'));
     // Elevated rep → non-zero discount rate; expectations computed with the SAME helpers flyPlane uses.
-    await inst.db.update(schema.account).set({ reputation: 30 });
+    await updateLocalPlayerEconomy(inst, { reputation: 30 });
-    const cashBefore = (await inst.db.select().from(schema.account))[0].cash;
+    const cashBefore = (await getLocalPlayer(inst)).cash;
 
-    await flyPlane(inst, 'plane-starter', 'LEMD');
+    await flyPlane(inst, 'plane-starter', 'LEMD', 'local');
 
     const rate = repRate(30, FUEL_DISCOUNT_PER_REP, MAX_FUEL_DISCOUNT);
     expect(rate).toBeGreaterThan(0); // sanity pin on the formula input
@@ -263,22 +264,22 @@ describe('flyPlane', () => {
     const plane = (await inst.db.select().from(schema.planes))[0];
     expect(plane.status).toBe('flying');
     expect(plane.fuel).toBeCloseTo(target, 6); // topped up to exactly the 150% target…
-    const account = (await inst.db.select().from(schema.account))[0];
+    const player = await getLocalPlayer(inst);
-    expect(account.cash).toBeCloseTo(cashBefore - expectedCost, 6); // …at exactly the rep-discounted cost
+    expect(player.cash).toBeCloseTo(cashBefore - expectedCost, 6); // …at exactly the rep-discounted cost
   });
 
   it('is a free no-op when the tank already covers the 150% target (cash unchanged)', async () => {
     const inst = await freshDb('fly-autorefuel-full.db'); // seeded starter is full at EDDF
     const required = await adjustedRequiredForHubToLemd();
     expect(required * 1.5).toBeLessThan(PLANE_TYPES.atr72.maxFuel); // sanity: the target stays below a full tank
-    const cashBefore = (await inst.db.select().from(schema.account))[0].cash;
+    const cashBefore = (await getLocalPlayer(inst)).cash;
 
-    await flyPlane(inst, 'plane-starter', 'LEMD');
+    await flyPlane(inst, 'plane-starter', 'LEMD', 'local');
 
     const plane = (await inst.db.select().from(schema.planes))[0];
     expect(plane.status).toBe('flying');
     expect(plane.fuel).toBe(PLANE_TYPES.atr72.maxFuel); // untouched…
-    expect((await inst.db.select().from(schema.account))[0].cash).toBe(cashBefore); // …and free
+    expect((await getLocalPlayer(inst)).cash).toBe(cashBefore); // …and free
   });
 
   it('rejects dispatch with 409 insufficient funds when cash cannot cover the top-up — nothing mutated', async () => {
@@ -286,9 +287,9 @@ describe('flyPlane', () => {
     const required = await adjustedRequiredForHubToLemd();
     const startFuel = Math.round(required / 2);
     await inst.db.update(schema.planes).set({ fuel: startFuel }).where(eq(schema.planes.id, 'plane-starter'));
-    await inst.db.update(schema.account).set({ cash: 0 });
+    await updateLocalPlayerEconomy(inst, { cash: 0 });
 
-    await expectActionError(flyPlane(inst, 'plane-starter', 'LEMD'), 409, /insufficient funds/i);
+    await expectActionError(flyPlane(inst, 'plane-starter', 'LEMD', 'local'), 409, /insufficient funds/i);
 
     const plane = (await inst.db.select().from(schema.planes))[0];
     expect(plane.status).toBe('available'); // still grounded…
@@ -300,17 +301,17 @@ describe('flyPlane', () => {
     // UNNT ↔ LPPD are ~7670 km apart — far beyond the ATR's range, so no top-up can make it flyable.
     await inst.db.update(schema.planes).set({ locationIcao: 'UNNT' }).where(eq(schema.planes.id, 'plane-starter'));
 
-    await expectActionError(flyPlane(inst, 'plane-starter', 'LPPD'), 409, /insufficient fuel/i);
+    await expectActionError(flyPlane(inst, 'plane-starter', 'LPPD', 'local'), 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', 'LEMD', 'local');
-    await queueLeg(inst, 'plane-starter', 'EHAM');
+    await queueLeg(inst, 'plane-starter', 'EHAM', 'local');
 
-    await flyPlane(inst, 'plane-starter', 'LEMD'); // the first queued leg
+    await flyPlane(inst, 'plane-starter', 'LEMD', 'local'); // the first queued leg
 
     const plane = (await inst.db.select().from(schema.planes))[0];
     expect(plane.status).toBe('flying');
@@ -320,10 +321,10 @@ describe('flyPlane', () => {
 
   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', 'LEMD', 'local');
-    await queueLeg(inst, 'plane-starter', 'EHAM');
+    await queueLeg(inst, 'plane-starter', 'EHAM', 'local');
 
-    await flyPlane(inst, 'plane-starter', 'EHAM'); // not the first queued leg — an override
+    await flyPlane(inst, 'plane-starter', 'EHAM', 'local'); // not the first queued leg — an override
 
     const plane = (await inst.db.select().from(schema.planes))[0];
     expect(plane.status).toBe('flying');
@@ -336,11 +337,11 @@ describe('queueLeg (v0.25.0, ISS-043)', () => {
   it('appends legs to the queue in order and persists them as JSON', async () => {
     const inst = await freshDb('qleg-ok.db');
 
-    await queueLeg(inst, 'plane-starter', 'LEMD');
+    await queueLeg(inst, 'plane-starter', 'LEMD', 'local');
     let plane = (await inst.db.select().from(schema.planes))[0];
     expect(JSON.parse(plane.queue)).toEqual(['LEMD']);
 
-    await queueLeg(inst, 'plane-starter', 'EHAM'); // pre-building a route
+    await queueLeg(inst, 'plane-starter', 'EHAM', 'local'); // pre-building a route
     plane = (await inst.db.select().from(schema.planes))[0];
     expect(JSON.parse(plane.queue)).toEqual(['LEMD', 'EHAM']); // order preserved
   });
@@ -351,7 +352,7 @@ describe('queueLeg (v0.25.0, ISS-043)', () => {
       .set({ status: 'flying', departureSimTime: T0, destIcao: 'LEMD' })
       .where(eq(schema.planes.id, 'plane-starter'));
 
-    await queueLeg(inst, 'plane-starter', 'EHAM');
+    await queueLeg(inst, 'plane-starter', 'EHAM', 'local');
 
     const plane = (await inst.db.select().from(schema.planes))[0];
     expect(plane.status).toBe('flying'); // still on its active leg…
@@ -361,19 +362,19 @@ describe('queueLeg (v0.25.0, ISS-043)', () => {
 
   it('rejects an unknown plane id with 404', async () => {
     const inst = await freshDb('qleg-ghost.db');
-    await expectActionError(queueLeg(inst, 'ghost', 'LEMD'), 404);
+    await expectActionError(queueLeg(inst, 'ghost', 'LEMD', 'local'), 404);
   });
 
   it('rejects an ICAO not in the airport dataset with 400', async () => {
     const inst = await freshDb('qleg-unknownicao.db');
-    await expectActionError(queueLeg(inst, 'plane-starter', 'ZZZZ'), 400, /unknown airport/);
+    await expectActionError(queueLeg(inst, 'plane-starter', 'ZZZZ', 'local'), 400, /unknown airport/);
   });
 
   it('rejects a destination already in the queue with 409 (ISS-065)', async () => {
     const inst = await freshDb('qleg-dup.db');
-    await queueLeg(inst, 'plane-starter', 'LEMD');
+    await queueLeg(inst, 'plane-starter', 'LEMD', 'local');
 
-    await expectActionError(queueLeg(inst, 'plane-starter', 'LEMD'), 409, /already in the flight queue/);
+    await expectActionError(queueLeg(inst, 'plane-starter', 'LEMD', 'local'), 409, /already in the flight queue/);
 
     const plane = (await inst.db.select().from(schema.planes))[0];
     expect(JSON.parse(plane.queue)).toEqual(['LEMD']); // rejected leg not appended
@@ -385,7 +386,7 @@ describe('queueLeg (v0.25.0, ISS-043)', () => {
       .set({ status: 'flying', departureSimTime: T0, destIcao: 'LEMD' })
       .where(eq(schema.planes.id, 'plane-starter'));
 
-    await expectActionError(queueLeg(inst, 'plane-starter', 'LEMD'), 409, /already flying to LEMD/);
+    await expectActionError(queueLeg(inst, 'plane-starter', 'LEMD', 'local'), 409, /already flying to LEMD/);
 
     const plane = (await inst.db.select().from(schema.planes))[0];
     expect(JSON.parse(plane.queue)).toEqual([]); // rejected leg not appended
@@ -393,8 +394,8 @@ describe('queueLeg (v0.25.0, ISS-043)', () => {
 
   it('still appends a different known airport with success (ISS-065 sanity)', async () => {
     const inst = await freshDb('qleg-dupother.db');
-    await queueLeg(inst, 'plane-starter', 'LEMD');
+    await queueLeg(inst, 'plane-starter', 'LEMD', 'local');
-    await expect(queueLeg(inst, 'plane-starter', 'EHAM')).resolves.toBeUndefined();
+    await expect(queueLeg(inst, 'plane-starter', 'EHAM', 'local')).resolves.toBeUndefined();
 
     const plane = (await inst.db.select().from(schema.planes))[0];
     expect(JSON.parse(plane.queue)).toEqual(['LEMD', 'EHAM']);
@@ -404,11 +405,11 @@ describe('queueLeg (v0.25.0, ISS-043)', () => {
 describe('cancelQueuedLeg (v0.25.0, ISS-043)', () => {
   it('removes the leg at the given index and keeps the rest in order', async () => {
     const inst = await freshDb('qcancel-ok.db');
-    await queueLeg(inst, 'plane-starter', 'LEMD');
+    await queueLeg(inst, 'plane-starter', 'LEMD', 'local');
-    await queueLeg(inst, 'plane-starter', 'EHAM');
+    await queueLeg(inst, 'plane-starter', 'EHAM', 'local');
-    await queueLeg(inst, 'plane-starter', 'EDDV');
+    await queueLeg(inst, 'plane-starter', 'EDDV', 'local');
 
-    await cancelQueuedLeg(inst, 'plane-starter', 1); // drop EHAM (the middle leg)
+    await cancelQueuedLeg(inst, 'plane-starter', 1, 'local'); // drop EHAM (the middle leg)
 
     const plane = (await inst.db.select().from(schema.planes))[0];
     expect(JSON.parse(plane.queue)).toEqual(['LEMD', 'EDDV']);
@@ -416,19 +417,19 @@ describe('cancelQueuedLeg (v0.25.0, ISS-043)', () => {
 
   it('rejects an out-of-range index with 400', async () => {
     const inst = await freshDb('qcancel-oob.db');
-    await queueLeg(inst, 'plane-starter', 'LEMD'); // one leg → only index 0 is valid
+    await queueLeg(inst, 'plane-starter', 'LEMD', 'local'); // one leg → only index 0 is valid
-    await expectActionError(cancelQueuedLeg(inst, 'plane-starter', 1), 400);
+    await expectActionError(cancelQueuedLeg(inst, 'plane-starter', 1, 'local'), 400);
-    await expectActionError(cancelQueuedLeg(inst, 'plane-starter', -1), 400);
+    await expectActionError(cancelQueuedLeg(inst, 'plane-starter', -1, 'local'), 400);
   });
 
   it('rejects cancelling from an empty queue with 400', async () => {
     const inst = await freshDb('qcancel-empty.db'); // seeded starter has no queued legs
-    await expectActionError(cancelQueuedLeg(inst, 'plane-starter', 0), 400);
+    await expectActionError(cancelQueuedLeg(inst, 'plane-starter', 0, 'local'), 400);
   });
 
   it('rejects an unknown plane id with 404', async () => {
     const inst = await freshDb('qcancel-ghost.db');
-    await expectActionError(cancelQueuedLeg(inst, 'ghost', 0), 404);
+    await expectActionError(cancelQueuedLeg(inst, 'ghost', 0, 'local'), 404);
   });
 });
 
@@ -441,7 +442,7 @@ describe('abandonPackage', () => {
     const inst = await freshDb(name);
     // Always insert OPEN and load it through the real action…
     await insertOpenPackage(inst, 'p-ab', { reward: REWARD, createdSimTime: STARTING_CLOCK_MS, deadlineSimTime: STARTING_CLOCK_MS + WINDOW_MS });
-    await loadPackage(inst, 'p-ab', 'plane-starter');
+    await loadPackage(inst, 'p-ab', 'plane-starter', 'local');
     // …then flip to expired in place (what the tick would do once the deadline passes).
     if (status === 'expired') {
       await inst.db.update(schema.packages).set({ status: 'expired' }).where(eq(schema.packages.id, 'p-ab'));
@@ -451,23 +452,23 @@ describe('abandonPackage', () => {
 
   it('charges exactly 15% of the payout right after creation (clock at createdSimTime)', async () => {
     const inst = await setupLoaded('ab-start.db');
-    const cashBefore = (await inst.db.select().from(schema.account))[0].cash;
+    const cashBefore = (await getLocalPlayer(inst)).cash;
 
-    const { penalty } = await abandonPackage(inst, 'p-ab');
+    const { penalty } = await abandonPackage(inst, 'p-ab', 'local');
 
     expect(penalty).toBe(Math.round(REWARD * 0.15 * 100) / 100);
     const row = (await inst.db.select().from(schema.packages).where(eq(schema.packages.id, 'p-ab')))[0];
     expect(row.status).toBe('abandoned');
     expect(row.planeId).toBeNull(); // slot freed
-    const account = (await inst.db.select().from(schema.account))[0];
+    const player = await getLocalPlayer(inst);
-    expect(account.cash).toBeCloseTo(cashBefore - penalty, 6);
+    expect(player.cash).toBeCloseTo(cashBefore - penalty, 6);
   });
 
   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: STARTING_CLOCK_MS + WINDOW_MS / 2 }); // runAction ticks first in prod
 
-    const { penalty } = await abandonPackage(inst, 'p-ab');
+    const { penalty } = await abandonPackage(inst, 'p-ab', 'local');
 
     expect(penalty).toBe(Math.round(REWARD * (0.15 + 0.45 * 0.5) * 100) / 100);
   });
@@ -480,31 +481,31 @@ describe('abandonPackage', () => {
       const inst = await setupLoaded(name);
       await inst.db.update(schema.simState).set({ clockMs: clock });
 
-      const { penalty } = await abandonPackage(inst, 'p-ab');
+      const { penalty } = await abandonPackage(inst, 'p-ab', 'local');
       expect(penalty).toBe(Math.round(REWARD * 0.6 * 100) / 100);
     }
   });
 
   it('is free for an already-expired package', async () => {
     const inst = await setupLoaded('ab-expired.db', 'expired');
-    const cashBefore = (await inst.db.select().from(schema.account))[0].cash;
+    const cashBefore = (await getLocalPlayer(inst)).cash;
 
-    const { penalty } = await abandonPackage(inst, 'p-ab');
+    const { penalty } = await abandonPackage(inst, 'p-ab', 'local');
 
     expect(penalty).toBe(0);
-    expect((await inst.db.select().from(schema.account))[0].cash).toBe(cashBefore);
+    expect((await getLocalPlayer(inst)).cash).toBe(cashBefore);
     const row = (await inst.db.select().from(schema.packages).where(eq(schema.packages.id, 'p-ab')))[0];
     expect(row.status).toBe('abandoned');
   });
 
   it('floors cash at €0 — no debt', async () => {
     const inst = await setupLoaded('ab-floor.db');
-    await inst.db.update(schema.account).set({ cash: 10 }); // penalty is 150 > 10
+    await updateLocalPlayerEconomy(inst, { cash: 10 }); // penalty is 150 > 10
 
-    const { penalty } = await abandonPackage(inst, 'p-ab');
+    const { penalty } = await abandonPackage(inst, 'p-ab', 'local');
 
     expect(penalty).toBe(150);
-    expect((await inst.db.select().from(schema.account))[0].cash).toBe(0);
+    expect((await getLocalPlayer(inst)).cash).toBe(0);
   });
 
   it('rejects abandoning while the plane is in flight with 409', async () => {
@@ -513,32 +514,32 @@ describe('abandonPackage', () => {
       .set({ status: 'flying', departureSimTime: T0, destIcao: 'LEMD' })
       .where(eq(schema.planes.id, 'plane-starter'));
 
-    await expectActionError(abandonPackage(inst, 'p-ab'), 409, /in flight/i);
+    await expectActionError(abandonPackage(inst, 'p-ab', 'local'), 409, /in flight/i);
   });
 
   it.each(['open', 'delivered', 'abandoned'] as const)('rejects a %s package with 409', async (status) => {
     const inst = await freshDb(`ab-${status}.db`);
     await insertOpenPackage(inst, 'p-x', { status });
 
-    await expectActionError(abandonPackage(inst, 'p-x'), 409, new RegExp(status));
+    await expectActionError(abandonPackage(inst, 'p-x', 'local'), 409, new RegExp(status));
   });
 
   it('rejects an unknown id with 404', async () => {
     const inst = await freshDb('ab-unknown.db');
-    await expectActionError(abandonPackage(inst, 'nope'), 404);
+    await expectActionError(abandonPackage(inst, 'nope', 'local'), 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');
-    await inst.db.update(schema.account).set({ cash: 500_000 });
+    await updateLocalPlayerEconomy(inst, { cash: 500_000 });
 
     const before = (await inst.db.select().from(schema.planes)).length;
-    const { planeId } = await buyPlane(inst, 'atr72');
+    const { planeId } = await buyPlane(inst, 'atr72', 'local');
 
-    const account = (await inst.db.select().from(schema.account))[0];
+    const player = await getLocalPlayer(inst);
-    expect(account.cash).toBe(500_000 - PLANE_TYPES.atr72.price);
+    expect(player.cash).toBe(500_000 - PLANE_TYPES.atr72.price);
 
     const planes = await inst.db.select().from(schema.planes);
     expect(planes.length).toBe(before + 1);
@@ -556,44 +557,44 @@ describe('buyPlane', () => {
 
   it('rejects an unknown catalog model with 400', async () => {
     const inst = await freshDb('buy-unknown.db');
-    await expectActionError(buyPlane(inst, 'boeing747'), 400, /unknown plane model/);
+    await expectActionError(buyPlane(inst, 'boeing747', 'local'), 400, /unknown plane model/);
   });
 
   it('rejects the purchase when cash is below the price with 409', async () => {
     const inst = await freshDb('buy-poor.db'); // seeded cash is 20k < 200k
-    await expectActionError(buyPlane(inst, 'atr72'), 409, /insufficient funds/i);
+    await expectActionError(buyPlane(inst, 'atr72', 'local'), 409, /insufficient funds/i);
   });
 
   it('deducts the reputation-scaled cost at elevated rep (v0.38.0)', async () => {
     const inst = await freshDb('buy-rep.db');
     // rep 30 → rate exactly 0.2 → ATR costs 160k, not 200k.
-    await inst.db.update(schema.account).set({ cash: 500_000, reputation: 30 });
+    await updateLocalPlayerEconomy(inst, { cash: 500_000, reputation: 30 });
 
     const before = (await inst.db.select().from(schema.planes)).length;
-    await buyPlane(inst, 'atr72');
+    await buyPlane(inst, 'atr72', 'local');
 
     const rate = repRate(30, PLANE_DISCOUNT_PER_REP, MAX_PLANE_DISCOUNT);
     expect(rate).toBeCloseTo(0.2, 12); // sanity pin on the formula input
     const expectedCost = Math.round(PLANE_TYPES.atr72.price * (1 - rate) * 100) / 100;
     expect(expectedCost).toBe(160_000); // 200k × 0.8 — exact value pin
-    const account = (await inst.db.select().from(schema.account))[0];
+    const player = await getLocalPlayer(inst);
-    expect(account.cash).toBeCloseTo(500_000 - expectedCost, 6);
+    expect(player.cash).toBeCloseTo(500_000 - expectedCost, 6);
     expect((await inst.db.select().from(schema.planes)).length).toBe(before + 1);
   });
 
   it('buys with cash between the discounted and full price; rejects below the discounted cost (v0.38.0)', async () => {
     const inst = await freshDb('buy-boundary.db');
     // rep 30 → discounted cost 160k: 170k is enough now, though it was not before v0.38.0.
-    await inst.db.update(schema.account).set({ cash: 170_000, reputation: 30 });
+    await updateLocalPlayerEconomy(inst, { cash: 170_000, reputation: 30 });
 
-    const { planeId } = await buyPlane(inst, 'atr72');
+    const { planeId } = await buyPlane(inst, 'atr72', 'local');
     expect(planeId).toBeTruthy(); // the old full-price check would have rejected this
-    const account = (await inst.db.select().from(schema.account))[0];
+    const player = await getLocalPlayer(inst);
-    expect(account.cash).toBeCloseTo(170_000 - 160_000, 6);
+    expect(player.cash).toBeCloseTo(170_000 - 160_000, 6);
 
     const inst2 = await freshDb('buy-boundary-poor.db'); // just below the discounted cost
-    await inst2.db.update(schema.account).set({ cash: 159_999.99, reputation: 30 });
+    await updateLocalPlayerEconomy(inst2, { cash: 159_999.99, reputation: 30 });
-    await expectActionError(buyPlane(inst2, 'atr72'), 409, /insufficient funds/i);
+    await expectActionError(buyPlane(inst2, 'atr72', 'local'), 409, /insufficient funds/i);
   });
 });
 
@@ -602,16 +603,16 @@ describe('sellPlane', () => {
     const inst = await freshDb('sell-ok.db');
     // A second plane so the starter is not "the last remaining one".
     await inst.db.insert(schema.planes).values({
-      id: 'plane-extra', model: 'atr72', status: 'available', fuel: 100, maxFuel: PLANE_TYPES.atr72.maxFuel,
+      id: 'plane-extra', ownerId: 'local', model: 'atr72', status: 'available', fuel: 100, maxFuel: PLANE_TYPES.atr72.maxFuel,
       locationIcao: HUB_ICAO, destIcao: null, lat: 50, lon: 8, departureSimTime: null,
     });
-    const cashBefore = (await inst.db.select().from(schema.account))[0].cash;
+    const cashBefore = (await getLocalPlayer(inst)).cash;
 
-    const { payout } = await sellPlane(inst, 'plane-extra');
+    const { payout } = await sellPlane(inst, 'plane-extra', 'local');
 
     expect(payout).toBe(Math.round(PLANE_TYPES.atr72.price * SELL_FRACTION * 100) / 100);
-    const account = (await inst.db.select().from(schema.account))[0];
+    const player = await getLocalPlayer(inst);
-    expect(account.cash).toBeCloseTo(cashBefore + payout, 6);
+    expect(player.cash).toBeCloseTo(cashBefore + payout, 6);
     const ids = (await inst.db.select().from(schema.planes)).map((p) => p.id);
     expect(ids).not.toContain('plane-extra'); // row deleted
     expect(ids).toContain('plane-starter');
@@ -620,22 +621,22 @@ describe('sellPlane', () => {
   it('rejects selling a flying plane with 409', async () => {
     const inst = await freshDb('sell-flying.db');
     await inst.db.insert(schema.planes).values({
-      id: 'plane-extra', model: 'atr72', status: 'flying', fuel: 100, maxFuel: PLANE_TYPES.atr72.maxFuel,
+      id: 'plane-extra', ownerId: 'local', model: 'atr72', status: 'flying', fuel: 100, maxFuel: PLANE_TYPES.atr72.maxFuel,
       locationIcao: HUB_ICAO, destIcao: 'LEMD', lat: 50, lon: 8, departureSimTime: T0,
     });
 
-    await expectActionError(sellPlane(inst, 'plane-extra'), 409, /flying/);
+    await expectActionError(sellPlane(inst, 'plane-extra', 'local'), 409, /flying/);
   });
 
   it('rejects selling a grounded plane that still carries cargo with 409 (v0.28.0)', async () => {
     const inst = await freshDb('sell-cargo.db');
     await inst.db.insert(schema.planes).values({
-      id: 'plane-extra', model: 'atr72', status: 'available', fuel: 100, maxFuel: PLANE_TYPES.atr72.maxFuel,
+      id: 'plane-extra', ownerId: 'local', model: 'atr72', status: 'available', fuel: 100, maxFuel: PLANE_TYPES.atr72.maxFuel,
       locationIcao: HUB_ICAO, destIcao: null, lat: 50, lon: 8, departureSimTime: null,
     });
     await insertOpenPackage(inst, 'p-loaded', { status: 'loaded', planeId: 'plane-extra' });
 
-    await expectActionError(sellPlane(inst, 'plane-extra'), 409, /carrying cargo/);
+    await expectActionError(sellPlane(inst, 'plane-extra', 'local'), 409, /carrying cargo/);
     const ids = (await inst.db.select().from(schema.planes)).map((p) => p.id);
     expect(ids).toContain('plane-extra'); // row untouched — the cargo stays bound to a real plane
   });
@@ -643,24 +644,24 @@ describe('sellPlane', () => {
   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,
+      id: 'plane-extra', ownerId: 'local', 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 queueLeg(inst, 'plane-extra', 'LEMD', 'local');
 
-    await expectActionError(sellPlane(inst, 'plane-extra'), 409, /cancel queued legs first/);
+    await expectActionError(sellPlane(inst, 'plane-extra', 'local'), 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/);
+    await expectActionError(sellPlane(inst, 'plane-starter', 'local'), 409, /last remaining/);
   });
 
   it('rejects an unknown id with 404', async () => {
     const inst = await freshDb('sell-unknown.db');
-    await expectActionError(sellPlane(inst, 'ghost'), 404);
+    await expectActionError(sellPlane(inst, 'ghost', 'local'), 404);
   });
 });
 
@@ -668,31 +669,31 @@ describe('repairPlane (v0.39.0, ISS-069; gradual since v0.45.0, ISS-089)', () =>
   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;
+    const cashBefore = (await getLocalPlayer(inst)).cash;
 
-    const { cost } = await repairPlane(inst, 'plane-starter');
+    const { cost } = await repairPlane(inst, 'plane-starter', 'local');
 
     expect(cost).toBe(REPAIR_COST);
     const plane = (await inst.db.select().from(schema.planes))[0];
     expect(plane.status).toBe('repairing');
     expect(plane.health).toBe(42); // NOT restored yet — the engine's finishRepairs pass heals it gradually…
     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];
+    const player = await getLocalPlayer(inst);
-    expect(account.cash).toBeCloseTo(cashBefore - REPAIR_COST, 6);
+    expect(player.cash).toBeCloseTo(cashBefore - REPAIR_COST, 6);
   });
 
   it('is a free no-op when health is already full', async () => {
     const inst = await freshDb('repair-full.db'); // seeded starter at 100
-    const cashBefore = (await inst.db.select().from(schema.account))[0].cash;
+    const cashBefore = (await getLocalPlayer(inst)).cash;
 
-    const { cost } = await repairPlane(inst, 'plane-starter');
+    const { cost } = await repairPlane(inst, 'plane-starter', 'local');
 
     expect(cost).toBe(0);
     const plane = (await inst.db.select().from(schema.planes))[0];
     expect(plane.status).toBe('available'); // not grounded…
     expect(plane.health).toBe(100);
     expect(plane.repairUntilSimTime ?? null).toBeNull(); // …and no gate set
-    expect((await inst.db.select().from(schema.account))[0].cash).toBe(cashBefore);
+    expect((await getLocalPlayer(inst)).cash).toBe(cashBefore);
   });
 
   it('rejects a flying plane with 409', async () => {
@@ -701,7 +702,7 @@ describe('repairPlane (v0.39.0, ISS-069; gradual since v0.45.0, ISS-089)', () =>
       .set({ status: 'flying', departureSimTime: T0, destIcao: 'LEMD' })
       .where(eq(schema.planes.id, 'plane-starter'));
 
-    await expectActionError(repairPlane(inst, 'plane-starter'), 409, /only grounded planes can be repaired/);
+    await expectActionError(repairPlane(inst, 'plane-starter', 'local'), 409, /only grounded planes can be repaired/);
   });
 
   it('rejects a plane that is already repairing with 409', async () => {
@@ -710,35 +711,116 @@ describe('repairPlane (v0.39.0, ISS-069; gradual since v0.45.0, ISS-089)', () =>
       .set({ status: 'repairing', repairUntilSimTime: T0 + REPAIR_DURATION_MS })
       .where(eq(schema.planes.id, 'plane-starter'));
 
-    await expectActionError(repairPlane(inst, 'plane-starter'), 409, /only grounded planes can be repaired/);
+    await expectActionError(repairPlane(inst, 'plane-starter', 'local'), 409, /only grounded planes can be repaired/);
   });
 
   it('blocks load/fly/sell while repairing (the existing status guards)', async () => {
     const inst = await freshDb('repair-blocks.db');
     await inst.db.update(schema.planes).set({ health: 50 }).where(eq(schema.planes.id, 'plane-starter'));
-    await repairPlane(inst, 'plane-starter');
+    await repairPlane(inst, 'plane-starter', 'local');
 
     await insertOpenPackage(inst); // open package at the hub — loadable if the plane were grounded
-    await expectActionError(loadPackage(inst, 'p-open', 'plane-starter'), 409, /repairing/);
+    await expectActionError(loadPackage(inst, 'p-open', 'plane-starter', 'local'), 409, /repairing/);
-    await expectActionError(flyPlane(inst, 'plane-starter', 'LEMD'), 409, /repairing/);
+    await expectActionError(flyPlane(inst, 'plane-starter', 'LEMD', 'local'), 409, /repairing/);
     // A second plane so the "last remaining" guard cannot fire before the status one.
     await inst.db.insert(schema.planes).values({
-      id: 'plane-extra', model: 'atr72', status: 'available', fuel: 100, maxFuel: PLANE_TYPES.atr72.maxFuel,
+      id: 'plane-extra', ownerId: 'local', model: 'atr72', status: 'available', fuel: 100, maxFuel: PLANE_TYPES.atr72.maxFuel,
       locationIcao: HUB_ICAO, destIcao: null, lat: 50, lon: 8, departureSimTime: null,
     });
-    await expectActionError(sellPlane(inst, 'plane-starter'), 409, /repairing/);
+    await expectActionError(sellPlane(inst, 'plane-starter', 'local'), 409, /repairing/);
   });
 
   it('rejects the repair when cash is below REPAIR_COST with 409', async () => {
     const inst = await freshDb('repair-poor.db');
     await inst.db.update(schema.planes).set({ health: 50 }).where(eq(schema.planes.id, 'plane-starter'));
-    await inst.db.update(schema.account).set({ cash: REPAIR_COST - 1 });
+    await updateLocalPlayerEconomy(inst, { cash: REPAIR_COST - 1 });
 
-    await expectActionError(repairPlane(inst, 'plane-starter'), 409, /insufficient funds/i);
+    await expectActionError(repairPlane(inst, 'plane-starter', 'local'), 409, /insufficient funds/i);
   });
 
   it('rejects an unknown id with 404', async () => {
     const inst = await freshDb('repair-unknown.db');
-    await expectActionError(repairPlane(inst, 'ghost'), 404);
+    await expectActionError(repairPlane(inst, 'ghost', 'local'), 404);
+  });
+});
+
+describe('ownership (v1.2.0, ISS-109)', () => {
+  // A second player row so per-player economy reads don't throw; the seeded starter is owned by 'local'.
+  async function addPlayerB(inst: GameDb): Promise<void> {
+    await inst.db.insert(schema.players).values({ id: 'b', provider: 'local', username: 'player-b', cash: STARTING_CASH, reputation: STARTING_REPUTATION });
+  }
+
+  it('rejects every plane action with 403 when the session player does not own the plane', async () => {
+    const inst = await freshDb('own-403.db');
+    await addPlayerB(inst);
+    await insertOpenPackage(inst, 'p-own');
+
+    await expectActionError(loadPackage(inst, 'p-own', 'plane-starter', 'b'), 403, /not your plane/);
+    await expectActionError(flyPlane(inst, 'plane-starter', 'LEMD', 'b'), 403, /not your plane/);
+    await expectActionError(queueLeg(inst, 'plane-starter', 'LEMD', 'b'), 403, /not your plane/);
+    await expectActionError(cancelQueuedLeg(inst, 'plane-starter', 0, 'b'), 403, /not your plane/);
+
+    // Load as the owner first so abandon has a bound package to check…
+    await loadPackage(inst, 'p-own', 'plane-starter', 'local');
+    await expectActionError(abandonPackage(inst, 'p-own', 'b'), 403, /not your plane/);
+
+    await expectActionError(sellPlane(inst, 'plane-starter', 'b'), 403, /not your plane/);
+    await inst.db.update(schema.planes).set({ health: 50 }).where(eq(schema.planes.id, 'plane-starter'));
+    await expectActionError(repairPlane(inst, 'plane-starter', 'b'), 403, /not your plane/);
+
+    // Nothing was mutated by the rejected attempts.
+    const plane = (await inst.db.select().from(schema.planes))[0];
+    expect(plane.status).toBe('available');
+    expect(JSON.parse(plane.queue)).toEqual([]);
+    expect((await getLocalPlayer(inst)).cash).toBe(STARTING_CASH); // no money moved for either player
+  });
+
+  it('rejects actions on another player\'s plane with 403 too (both directions)', async () => {
+    const inst = await freshDb('own-403-rev.db');
+    await addPlayerB(inst);
+    await inst.db.insert(schema.planes).values({
+      id: 'plane-b', ownerId: 'b', model: 'atr72', status: 'available', fuel: 100, maxFuel: PLANE_TYPES.atr72.maxFuel,
+      locationIcao: HUB_ICAO, destIcao: null, lat: 50, lon: 8, departureSimTime: null,
+    });
+
+    await expectActionError(flyPlane(inst, 'plane-b', 'LEMD', 'local'), 403, /not your plane/);
+    await expectActionError(sellPlane(inst, 'plane-b', 'local'), 403, /not your plane/);
+  });
+
+  it('enforces the last-plane guard per owner — not on the world total', async () => {
+    const inst = await freshDb('own-lastplane.db');
+    await addPlayerB(inst);
+    // 'b' owns two planes; 'local' only the starter. World total: three.
+    for (const id of ['plane-b1', 'plane-b2']) {
+      await inst.db.insert(schema.planes).values({
+        id, ownerId: 'b', model: 'atr72', status: 'available', fuel: 100, maxFuel: PLANE_TYPES.atr72.maxFuel,
+        locationIcao: HUB_ICAO, destIcao: null, lat: 50, lon: 8, departureSimTime: null,
+      });
+    }
+
+    // Selling local's only plane is still forbidden even though the world has three planes…
+    await expectActionError(sellPlane(inst, 'plane-starter', 'local'), 409, /last remaining/);
+    // …while b can sell one of their two.
+    const cashBefore = (await getPlayer(inst, 'b')).cash;
+    const { payout } = await sellPlane(inst, 'plane-b1', 'b');
+
+    expect(payout).toBe(Math.round(PLANE_TYPES.atr72.price * SELL_FRACTION * 100) / 100);
+    expect((await getPlayer(inst, 'b')).cash).toBeCloseTo(cashBefore + payout, 6); // b's own wallet pays out…
+    expect((await getLocalPlayer(inst)).cash).toBe(STARTING_CASH); // …local's is untouched
+    const ids = (await inst.db.select().from(schema.planes)).map((p) => p.id).sort();
+    expect(ids).toEqual(['plane-b2', 'plane-starter']); // b1 gone; local's starter untouched
+  });
+
+  it('stamps the buyer as owner and debits their own cash (not the local player\'s)', async () => {
+    const inst = await freshDb('own-buy.db');
+    await addPlayerB(inst);
+    await updatePlayerEconomy(inst, 'b', { cash: 500_000 });
+
+    const { planeId } = await buyPlane(inst, 'atr72', 'b');
+
+    const bought = (await inst.db.select().from(schema.planes).where(eq(schema.planes.id, planeId)))[0];
+    expect(bought.ownerId).toBe('b');
+    expect((await getPlayer(inst, 'b')).cash).toBe(500_000 - PLANE_TYPES.atr72.price);
+    expect((await getLocalPlayer(inst)).cash).toBe(STARTING_CASH); // local untouched
   });
 });

lib/game/actions.ts

@@ -1,6 +1,8 @@
 import { randomUUID } from 'node:crypto';
 import { and, eq, inArray } from 'drizzle-orm';
+import { requireAuth } from '@/lib/auth';
 import * as schema from '@/lib/db/schema';
+import { getPlayer, updatePlayerEconomy } from '@/lib/db/localPlayer';
 import { persist, type GameDb } from '@/lib/db/client';
 import { loadAirportsGeoJson } from '@/lib/airports';
 import { haversineKm, initialBearingDeg } from '@/lib/geo';
@@ -33,6 +35,7 @@ import { HUB_ICAO } from './seed';
 //   404 — unknown entity id
 //   409 — valid ids but the current state forbids the action (wrong package/plane
 //         status, plane not at origin, no payload room, insufficient fuel/funds, last plane)
+//   403 — v1.2.0 (ISS-109): the session player does not own the plane
 //   400 — bad input that isn't an existence problem (unknown airport/model)
 
 export class GameActionError extends Error {
@@ -52,13 +55,18 @@ async function airportByIcao(icao: string): Promise<{ icao: string; lat: number;
   return { icao: f.properties.icao, lat: f.properties.lat, lon: f.properties.lon };
 }
 
+// v1.2.0 (ISS-109): every plane action requires the session player to own the plane — 403 otherwise.
+function assertPlaneOwner(plane: schema.PlaneRow, playerId: string): void {
+  if (plane.ownerId !== playerId) throw new GameActionError(403, 'not your plane');
+}
+
 // --- Load (POST /api/packages/:id/load {planeId}) ---
 
 // open → loaded, bound to the plane. The plane must be GROUNDED at the package's
 // origin with enough payload room (v0.27.0: used kg = sum of weightKg over packages
 // 'loaded' or 'expired' on it — expired cargo keeps occupying its space until
 // delivered/abandoned).
-export async function loadPackage(inst: GameDb, packageId: string, planeId: string): Promise<void> {
+export async function loadPackage(inst: GameDb, packageId: string, planeId: string, playerId: string): Promise<void> {
   const [pkgRows, planeRows] = await Promise.all([
     inst.db.select().from(schema.packages).where(eq(schema.packages.id, packageId)),
     inst.db.select().from(schema.planes).where(eq(schema.planes.id, planeId)),
@@ -70,6 +78,7 @@ export async function loadPackage(inst: GameDb, packageId: string, planeId: stri
   }
   const plane = planeRows[0];
   if (!plane) throw new GameActionError(404, `plane ${planeId} not found`);
+  assertPlaneOwner(plane, playerId); // v1.2.0 (ISS-109): 403 on foreign planes
   if (plane.status !== 'available') {
     throw new GameActionError(409, `plane is ${plane.status}, only grounded planes can load cargo`);
   }
@@ -109,10 +118,11 @@ export async function loadPackage(inst: GameDb, packageId: string, planeId: stri
 // doesn't fit even a full tank still 409s (insufficient fuel), and an unaffordable top-up 409s
 // 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> {
+export async function flyPlane(inst: GameDb, planeId: string, destIcao: string, playerId: string): Promise<void> {
   const planeRows = await inst.db.select().from(schema.planes).where(eq(schema.planes.id, planeId));
   const plane = planeRows[0];
   if (!plane) throw new GameActionError(404, `plane ${planeId} not found`);
+  assertPlaneOwner(plane, playerId); // v1.2.0 (ISS-109): 403 on foreign planes
   if (plane.status !== 'available') {
     throw new GameActionError(409, `plane is ${plane.status}, only grounded planes can fly`);
   }
@@ -140,11 +150,11 @@ export async function flyPlane(inst: GameDb, planeId: string, destIcao: string):
   // any mutation, so a 409 leaves fuel and cash untouched.
   const target = Math.min(plane.maxFuel, Math.max(plane.fuel, requiredL * 1.5));
   const liters = Math.max(0, target - plane.fuel);
-  const account = (await inst.db.select().from(schema.account))[0];
+  // v1.2.0 (ISS-109): the acting player's own economy pays for the top-up (they own the plane).
-  if (!account) throw new Error('account row missing');
+  const player = await getPlayer(inst, playerId);
-  const cost = Math.round(liters * FUEL_PRICE_PER_L * (1 - repRate(account.reputation, FUEL_DISCOUNT_PER_REP, MAX_FUEL_DISCOUNT)) * 100) / 100;
+  const cost = Math.round(liters * FUEL_PRICE_PER_L * (1 - repRate(player.reputation, FUEL_DISCOUNT_PER_REP, MAX_FUEL_DISCOUNT)) * 100) / 100;
-  if (cost > 0 && account.cash < cost) {
+  if (cost > 0 && player.cash < cost) {
-    throw new GameActionError(409, `insufficient funds: refueling costs ${cost}, you have ${Math.round(account.cash)}`);
+    throw new GameActionError(409, `insufficient funds: refueling costs ${cost}, you have ${Math.round(player.cash)}`);
   }
   // Backstop: a leg that doesn't fit even a full tank is unflyable (target caps at maxFuel).
   if (requiredL > target) {
@@ -173,7 +183,7 @@ export async function flyPlane(inst: GameDb, planeId: string, destIcao: string):
     })
     .where(eq(schema.planes.id, planeId));
   if (cost > 0) {
-    await inst.db.update(schema.account).set({ cash: Math.round((account.cash - cost) * 100) / 100 });
+    await updatePlayerEconomy(inst, playerId, { cash: Math.round((player.cash - cost) * 100) / 100 });
   }
   await persist(inst);
 }
@@ -185,10 +195,11 @@ export async function flyPlane(inst: GameDb, planeId: string, destIcao: string):
 // active leg still starts via flyPlane, and queued legs chain on landing when fuel
 // covers them (lib/sim/engine.ts deliverPackages). Validation: known plane, ICAO
 // in the airport dataset.
-export async function queueLeg(inst: GameDb, planeId: string, destIcao: string): Promise<void> {
+export async function queueLeg(inst: GameDb, planeId: string, destIcao: string, playerId: string): Promise<void> {
   const planeRows = await inst.db.select().from(schema.planes).where(eq(schema.planes.id, planeId));
   const plane = planeRows[0];
   if (!plane) throw new GameActionError(404, `plane ${planeId} not found`);
+  assertPlaneOwner(plane, playerId); // v1.2.0 (ISS-109): 403 on foreign planes
 
   const fc = await loadAirportsGeoJson();
   if (!fc.features.some((f) => f.properties.icao === destIcao)) {
@@ -215,10 +226,11 @@ export async function queueLeg(inst: GameDb, planeId: string, destIcao: string):
 // Remove a NOT-yet-started leg from the queue by index. Only queued legs are
 // cancellable — the active in-flight leg (destIcao) is never affected. Validation:
 // known plane, integer index within [0, queue.length).
-export async function cancelQueuedLeg(inst: GameDb, planeId: string, index: number): Promise<void> {
+export async function cancelQueuedLeg(inst: GameDb, planeId: string, index: number, playerId: string): Promise<void> {
   const planeRows = await inst.db.select().from(schema.planes).where(eq(schema.planes.id, planeId));
   const plane = planeRows[0];
   if (!plane) throw new GameActionError(404, `plane ${planeId} not found`);
+  assertPlaneOwner(plane, playerId); // v1.2.0 (ISS-109): 403 on foreign planes
 
   const queue = parseIcaoQueue(plane.queue);
   if (index < 0 || index >= queue.length) {
@@ -235,7 +247,7 @@ export async function cancelQueuedLeg(inst: GameDb, planeId: string, index: numb
 // scaling with time pressure (15% at creation → 60% at the deadline, see
 // lib/game/penalty.ts); an already-expired package abandons for free. Cash never
 // goes below €0. The slot is freed immediately.
-export async function abandonPackage(inst: GameDb, packageId: string): Promise<{ penalty: number }> {
+export async function abandonPackage(inst: GameDb, packageId: string, playerId: string): Promise<{ penalty: number }> {
   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`);
@@ -247,6 +259,7 @@ export async function abandonPackage(inst: GameDb, packageId: string): Promise<{
     ? (await inst.db.select().from(schema.planes).where(eq(schema.planes.id, pkg.planeId)))[0]
     : undefined;
   if (!plane) throw new GameActionError(409, `package ${packageId} is not bound to a plane`);
+  assertPlaneOwner(plane, playerId); // v1.2.0 (ISS-109): 403 on foreign planes (via the bound plane)
   if (plane.status !== 'available') {
     throw new GameActionError(409, `the plane is in flight — packages can only be abandoned while it is grounded`);
   }
@@ -255,9 +268,9 @@ export async function abandonPackage(inst: GameDb, packageId: string): Promise<{
   if (!sim) throw new Error('sim_state row missing');
   const penalty = abandonPenalty(pkg, sim.clockMs);
 
-  const account = (await inst.db.select().from(schema.account))[0];
+  // v1.2.0 (ISS-109): the acting player's own economy pays the penalty.
-  if (!account) throw new Error('account row missing');
+  const player = await getPlayer(inst, playerId);
-  await inst.db.update(schema.account).set({ cash: Math.max(0, Math.round((account.cash - penalty) * 100) / 100) });
+  await updatePlayerEconomy(inst, playerId, { cash: Math.max(0, Math.round((player.cash - penalty) * 100) / 100) });
   await inst.db.update(schema.packages).set({ status: 'abandoned', planeId: null }).where(eq(schema.packages.id, packageId));
   await persist(inst);
   return { penalty };
@@ -268,16 +281,16 @@ export async function abandonPackage(inst: GameDb, packageId: string): Promise<{
 // Buy a catalog model at its reputation-scaled price (v0.38.0, ISS-072 — discount grows with
 // reputation, exactly full price at the starting value); it arrives 'available' with a full tank
 // at the home base (EDDF).
-export async function buyPlane(inst: GameDb, model: string): Promise<{ planeId: string }> {
+export async function buyPlane(inst: GameDb, model: string, playerId: string): Promise<{ planeId: string }> {
   const type = PLANE_TYPES[model];
   if (!type) throw new GameActionError(400, `unknown plane model "${model}"`);
 
-  const account = (await inst.db.select().from(schema.account))[0];
+  // v1.2.0 (ISS-109): the buyer's own economy pays and becomes the owner of the delivered plane.
-  if (!account) throw new Error('account row missing');
+  const player = await getPlayer(inst, playerId);
   // v0.38.0 (ISS-072): the EFFECTIVE cost drives both the funds check and the deduction.
-  const cost = Math.round(type.price * (1 - repRate(account.reputation, PLANE_DISCOUNT_PER_REP, MAX_PLANE_DISCOUNT)) * 100) / 100;
+  const cost = Math.round(type.price * (1 - repRate(player.reputation, PLANE_DISCOUNT_PER_REP, MAX_PLANE_DISCOUNT)) * 100) / 100;
-  if (account.cash < cost) {
+  if (player.cash < cost) {
-    throw new GameActionError(409, `insufficient funds: a ${type.name} costs ${cost}, you have ${Math.round(account.cash)}`);
+    throw new GameActionError(409, `insufficient funds: a ${type.name} costs ${cost}, you have ${Math.round(player.cash)}`);
   }
 
   const fc = await loadAirportsGeoJson();
@@ -287,6 +300,7 @@ export async function buyPlane(inst: GameDb, model: string): Promise<{ planeId:
   const planeId = randomUUID();
   await inst.db.insert(schema.planes).values({
     id: planeId,
+    ownerId: playerId, // v1.2.0 (ISS-109): the buyer owns what they buy
     model,
     status: 'available',
     fuel: type.maxFuel, // full tank on delivery
@@ -298,7 +312,7 @@ export async function buyPlane(inst: GameDb, model: string): Promise<{ planeId:
     departureSimTime: null,
     health: 100, // new planes arrive at full health (v0.39.0, ISS-069)
   });
-  await inst.db.update(schema.account).set({ cash: Math.round((account.cash - cost) * 100) / 100 });
+  await updatePlayerEconomy(inst, playerId, { cash: Math.round((player.cash - cost) * 100) / 100 });
   await persist(inst);
   return { planeId };
 }
@@ -307,10 +321,11 @@ export async function buyPlane(inst: GameDb, model: string): Promise<{ planeId:
 
 // Sell a grounded plane for SELL_FRACTION of its catalog price. The last
 // remaining plane can never be sold — the company needs at least one aircraft.
-export async function sellPlane(inst: GameDb, planeId: string): Promise<{ payout: number }> {
+export async function sellPlane(inst: GameDb, planeId: string, playerId: string): Promise<{ payout: number }> {
   const rows = await inst.db.select().from(schema.planes).where(eq(schema.planes.id, planeId));
   const plane = rows[0];
   if (!plane) throw new GameActionError(404, `plane ${planeId} not found`);
+  assertPlaneOwner(plane, playerId); // v1.2.0 (ISS-109): 403 on foreign planes
   if (plane.status !== 'available') {
     throw new GameActionError(409, `plane is ${plane.status}, only grounded planes can be sold`);
   }
@@ -329,17 +344,18 @@ export async function sellPlane(inst: GameDb, planeId: string): Promise<{ payout
     throw new GameActionError(409, 'the plane has queued legs — cancel queued legs first');
   }
 
-  const all = await inst.db.select().from(schema.planes);
+  // v1.2.0 (ISS-109): the guard is PER OWNER — you can't sell your last plane even if other
-  if (all.length <= 1) throw new GameActionError(409, 'cannot sell the last remaining plane');
+  // players' planes exist in the world, and selling one of two of yours is fine.
+  const owned = await inst.db.select({ id: schema.planes.id }).from(schema.planes).where(eq(schema.planes.ownerId, playerId));
+  if (owned.length <= 1) throw new GameActionError(409, 'cannot sell the last remaining plane');
 
   const type = PLANE_TYPES[plane.model];
   if (!type) throw new Error(`unknown plane model ${plane.model}`); // → 500, cannot happen for seeded data
   const payout = Math.round(type.price * SELL_FRACTION * 100) / 100;
 
   await inst.db.delete(schema.planes).where(eq(schema.planes.id, planeId));
-  const account = (await inst.db.select().from(schema.account))[0];
+  const player = await getPlayer(inst, playerId);
-  if (!account) throw new Error('account row missing');
+  await updatePlayerEconomy(inst, playerId, { cash: Math.round((player.cash + payout) * 100) / 100 });
-  await inst.db.update(schema.account).set({ cash: Math.round((account.cash + payout) * 100) / 100 });
   await persist(inst);
   return { payout };
 }
@@ -352,10 +368,11 @@ export async function sellPlane(inst: GameDb, planeId: string): Promise<{ payout
 // 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 }> {
+export async function repairPlane(inst: GameDb, planeId: string, playerId: string): Promise<{ cost: number }> {
   const rows = await inst.db.select().from(schema.planes).where(eq(schema.planes.id, planeId));
   const plane = rows[0];
   if (!plane) throw new GameActionError(404, `plane ${planeId} not found`);
+  assertPlaneOwner(plane, playerId); // v1.2.0 (ISS-109): 403 on foreign planes
   if (plane.status !== 'available') {
     throw new GameActionError(409, `plane is ${plane.status}, only grounded planes can be repaired`);
   }
@@ -364,17 +381,17 @@ export async function repairPlane(inst: GameDb, planeId: string): Promise<{ cost
 
   const sim = (await inst.db.select().from(schema.simState))[0];
   if (!sim) throw new Error('sim_state row missing');
-  const account = (await inst.db.select().from(schema.account))[0];
+  // v1.2.0 (ISS-109): the owner's own economy pays for the repair.
-  if (!account) throw new Error('account row missing');
+  const player = await getPlayer(inst, playerId);
-  if (account.cash < REPAIR_COST) {
+  if (player.cash < REPAIR_COST) {
-    throw new GameActionError(409, `insufficient funds: repair costs ${REPAIR_COST}, you have ${Math.round(account.cash)}`);
+    throw new GameActionError(409, `insufficient funds: repair costs ${REPAIR_COST}, you have ${Math.round(player.cash)}`);
   }
 
   // Health is NOT set here — the engine's finishRepairs pass heals it gradually along the gate.
   await inst.db.update(schema.planes)
     .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 updatePlayerEconomy(inst, playerId, { cash: Math.round((player.cash - REPAIR_COST) * 100) / 100 });
   await persist(inst);
   return { cost: REPAIR_COST };
 }
@@ -385,10 +402,17 @@ export async function repairPlane(inst: GameDb, planeId: string): Promise<{ cost
 // game time — then respond with the FULL current state snapshot (same shape as
 // GET /api/state), so clients never need a follow-up poll. GameActionError maps to
 // its own status + {error}; anything unexpected is a 500.
-export async function performAction(fn: (inst: GameDb) => Promise<unknown>): Promise<Response> {
+// v1.1.0 (ISS-107): every action route funnels through here, so the requireAuth guard lives in ONE
+// place — 401 before any game mutation when the X-Flight-Session header is missing/unknown/expired.
+// v1.2.0 (ISS-109): fn receives the session player's id as its second argument and threads it into
+// the action for ownership checks + per-player economy — routes stay a pure pass-through.
+export async function performAction(req: Request, fn: (inst: GameDb, playerId: string) => Promise<unknown>): Promise<Response> {
+  const auth = await requireAuth(req);
+  if (!auth.ok) return auth.response;
   try {
-    await runAction(fn);
+    await runAction((inst) => fn(inst, auth.player.id));
-    return Response.json(await getStateSnapshot());
+    // v1.3.0 (ISS-110): the response snapshot carries the ACTING player's economy in `account`.
+    return Response.json(await getStateSnapshot(auth.player.id));
   } catch (err) {
     if (err instanceof GameActionError) {
       return Response.json({ error: err.message }, { status: err.status });

lib/game/seed.ts

@@ -360,19 +360,14 @@ function pickHub(airports: SeedAirport[]): SeedAirport {
   return airports.find((a) => a.icao === HUB_ICAO) ?? airports[0];
 }
 
-export function buildSeed(input: {
+// v1.2.0 (ISS-108): the starter plane, extracted from buildSeed so per-player onboarding can reuse
-  airports: SeedAirport[];
+// it — same values as the fresh-install seed's plane (no RNG draws), only the id differs. The
-  rng: Rng;
+// caller stamps ownership (planes.owner_id) at insert time; this stays a pure SeedPlane.
-  nowMs: number;
+export function buildStarterPlane(airports: SeedAirport[], id: string): SeedPlane {
-}): SeedData {
-  const { airports, rng, nowMs } = input;
-  if (airports.length < 2) throw new Error('seed needs at least two airports');
-
   const type = PLANE_TYPES[STARTER_MODEL];
   const hub = pickHub(airports);
-
+  return {
-  const plane: SeedPlane = {
+    id,
-    id: 'plane-starter',
     model: STARTER_MODEL,
     status: 'available',
     fuel: type.maxFuel, // starts full
@@ -384,6 +379,18 @@ export function buildSeed(input: {
     queue: [], // no queued legs on first run (v0.25.0)
     health: 100, // full health on first run (v0.39.0, ISS-069)
   };
+}
+
+export function buildSeed(input: {
+  airports: SeedAirport[];
+  rng: Rng;
+  nowMs: number;
+}): SeedData {
+  const { airports, rng, nowMs } = input;
+  if (airports.length < 2) throw new Error('seed needs at least two airports');
+
+  const plane = buildStarterPlane(airports, 'plane-starter');
+  const hub = pickHub(airports);
 
   // v0.65.0: the seed market is a full pool at the starter's home hub — the same per-airport
   // composition (POOL_BANDS) the runtime spawner maintains, so first run looks like any other tick.

lib/game/state.test.ts

@@ -1,5 +1,12 @@
-import { describe, expect, it } from 'vitest';
+import fs from 'node:fs/promises';
-import { SSE_PACKAGE_STATUSES, sseFrame, type PackageState, type StateSnapshot } from './state';
+import os from 'node:os';
+import path from 'node:path';
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+import * as schema from '@/lib/db/schema';
+import { getGameDb } from '@/lib/db/client';
+import { PLANE_TYPES } from './catalog';
+import { STARTING_CASH, STARTING_REPUTATION } from './seed';
+import { getStateSnapshot, 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.
 
@@ -20,6 +27,7 @@ const pkg = (status: PackageState['status'], id: string): PackageState => ({
   status,
   planeId: null,
   createdSimTime: 0,
+  carrierName: null, // v1.4.0 (ISS-112) — unassigned by default in fixtures
 });
 
 const snapshot = (packages: PackageState[]): StateSnapshot => ({
@@ -29,6 +37,7 @@ const snapshot = (packages: PackageState[]): StateSnapshot => ({
   fuelPricePerL: 0.8,
   sellFraction: 0.5,
   planes: [],
+  players: [], // v1.6.0 (ISS-115) — leaderboard rows; empty in these sseFrame fixtures
   packages,
 });
 
@@ -59,3 +68,48 @@ describe('sseFrame', () => {
     expect([...SSE_PACKAGE_STATUSES].sort()).toEqual(['expired', 'loaded', 'open']);
   });
 });
+
+// v1.6.0 (ISS-115) — the snapshot's players array: one row per player with cash/reputation and
+// how many planes they own. Runs against a throwaway seeded DB via the app singleton, exactly
+// like the /api/state route tests (fresh module registry per file ⇒ fresh singleton).
+describe('getStateSnapshot players', () => {
+  let dir: string;
+
+  beforeAll(async () => {
+    dir = await fs.mkdtemp(path.join(os.tmpdir(), 'flight-snapshot-players-'));
+    process.env.FLIGHT_DB_PATH = path.join(dir, 'players.db');
+    await getGameDb(); // seeds the local player + starter plane
+  });
+
+  afterAll(async () => {
+    delete process.env.FLIGHT_DB_PATH;
+    await fs.rm(dir, { recursive: true, force: true });
+  });
+
+  it('single-player regression guard — one row for the seeded local account', async () => {
+    const snap = await getStateSnapshot('local');
+    expect(snap.players).toEqual([
+      { id: 'local', username: 'kamilkrzywda', cash: STARTING_CASH, reputation: STARTING_REPUTATION, planeCount: 1 },
+    ]);
+  });
+
+  it('two players — cash/reputation/planeCount per owner (v1.6.0, ISS-115)', async () => {
+    const inst = await getGameDb();
+    // A second account with a distinct economy and two planes of its own — rows minted like /api/register does.
+    await inst.db.insert(schema.players).values({ id: 'b', provider: 'local', username: 'player-b', cash: 5_000, reputation: 3 });
+    const type = PLANE_TYPES.atr72;
+    for (const id of ['plane-b-1', 'plane-b-2']) {
+      await inst.db.insert(schema.planes).values({
+        id, ownerId: 'b', model: 'atr72', status: 'available',
+        fuel: type.maxFuel, maxFuel: type.maxFuel, locationIcao: 'EDDF', lat: 50.03, lon: 8.56,
+      });
+    }
+
+    const snap = await getStateSnapshot('b'); // any session sees the whole world's players
+    expect(snap.players).toHaveLength(2);
+    const local = snap.players.find((p) => p.id === 'local')!;
+    expect(local).toEqual({ id: 'local', username: 'kamilkrzywda', cash: STARTING_CASH, reputation: STARTING_REPUTATION, planeCount: 1 }); // starter still counted once…
+    const b = snap.players.find((p) => p.id === 'b')!;
+    expect(b).toEqual({ id: 'b', username: 'player-b', cash: 5_000, reputation: 3, planeCount: 2 }); // …and both of B's planes count for B.
+  });
+});

lib/game/state.ts

@@ -2,6 +2,7 @@ import { loadAirportsGeoJson } from '@/lib/airports';
 import { haversineKm, initialBearingDeg } from '@/lib/geo';
 import { weatherFor } from '@/lib/weather';
 import { getGameDb } from '@/lib/db/client';
+import { getPlayer } from '@/lib/db/localPlayer';
 import * as schema from '@/lib/db/schema';
 import { catalogEntries, FUEL_PRICE_PER_L, PLANE_TYPES, SELL_FRACTION, type CatalogEntry } from './catalog';
 import { fuelAtWeighted, progressAt, positionAt, windBurnFactor } from '@/lib/sim/movement';
@@ -36,6 +37,10 @@ export interface PlaneState {
   health: number;
   // Sim-clock epoch ms when an active repair finishes (v0.39.0, ISS-069); null when not in repair.
   repairUntilSimTime: number | null;
+  // v1.4.0 (ISS-112): owner info — the snapshot carries ALL planes (shared world), so every row
+  // names its owner (players.id + username) and the panes can tell whose plane is whose.
+  ownerId: string;
+  ownerName: string;
 }
 
 // Parse the planes.queue JSON column into an ICAO list (v0.25.0). Guards against
@@ -87,6 +92,19 @@ export interface PackageState {
   // 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;
+  // v1.4.0 (ISS-112): carrier name — players.username of planes.owner_id via planeId, so an
+  // assigned package shows WHO is carrying it in the shared world; null when unassigned.
+  carrierName: string | null;
+}
+
+// v1.6.0 (ISS-115): per-player summary for the leaderboard panel — rides on every snapshot
+// (GET /api/state + SSE frames), so no new endpoint is needed. planeCount = planes owned.
+export interface PlayerSummary {
+  id: string;
+  username: string;
+  cash: number;
+  reputation: number;
+  planeCount: number;
 }
 
 export interface StateSnapshot {
@@ -95,6 +113,9 @@ export interface StateSnapshot {
   // only the clock itself is reported here.
   simState: { clockMs: number };
   planes: PlaneState[];
+  // v1.6.0 (ISS-115): leaderboard data — one row per player, projected from the same players +
+  // planes reads as everything else in this snapshot (no extra query).
+  players: PlayerSummary[];
   packages: PackageState[];
   // Market reference data (v0.10.0) — static per build, sent with every snapshot so
   // the client can compute buy/sell previews without a separate endpoint.
@@ -113,20 +134,29 @@ 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> {
+// v1.3.0 (ISS-110): the snapshot's `account` field is the ACTING SESSION player's row — same
-  const { db } = await getGameDb();
+// shape as before ({cash, reputation}), sourced per-player. v1.4.0 (ISS-112): this IS the shared
+// projection for every surface that serves state — GET /api/state, action responses, the SSE
+// connect frame and each tick's broadcast all call it with a player id (the broadcast projects
+// once PER CONNECTED SESSION), so no two surfaces can drift. Planes are ALL planes in the world,
+// each carrying owner info; packages carry carrierName when assigned to a plane.
+export async function getStateSnapshot(playerId: string): Promise<StateSnapshot> {
+  const inst = await getGameDb();
+  const { db } = inst;
   // NOTE: use plain select(), not the relational db.query.* API — in drizzle-orm
   // 0.45.x the sql-js driver drops the result mapper for relational queries and
   // returns raw rows keyed by SQL column names (snake_case, no type decoding).
-  const [accountRows, simRows, planeRows, packageRows] = await Promise.all([
+  const [player, simRows, planeRows, packageRows, playerRows] = await Promise.all([
-    db.select().from(schema.account),
+    getPlayer(inst, playerId),
     db.select().from(schema.simState),
     db.select().from(schema.planes),
     db.select().from(schema.packages),
+    // v1.4.0 (ISS-112): one players read serves both owner joins — plane rows via ownerId and
+    // package carrier names via planeId → planes.owner_id → players.username.
+    db.select().from(schema.players),
   ]);
-  const accountRow = accountRows[0];
   const simRow = simRows[0];
-  if (!accountRow || !simRow) throw new Error('game state missing account/sim_state row');
+  if (!simRow) throw new Error('game state missing sim_state row');
 
   const fc = await loadAirportsGeoJson();
   const nameByIcao = new Map(fc.features.map((f) => [f.properties.icao, f.properties.name]));
@@ -144,6 +174,15 @@ export async function getStateSnapshot(): Promise<StateSnapshot> {
   // body entirely, so clients never see jobs they could not dispatch.
   const pool = poolAirports(planeRows);
 
+  // v1.4.0 (ISS-112): owner joins — every plane row names its owner; a package's carrier is the
+  // username of ITS PLANE'S owner (planeId → planes.owner_id → players.username), null when unassigned.
+  const usernameByPlayerId = new Map(playerRows.map((pl) => [pl.id, pl.username]));
+  const planeById = new Map(planeRows.map((p) => [p.id, p]));
+
+  // v1.6.0 (ISS-115): leaderboard — count owned planes per player from the rows already loaded above.
+  const planeCountByOwner = new Map<string, number>();
+  for (const p of planeRows) planeCountByOwner.set(p.ownerId, (planeCountByOwner.get(p.ownerId) ?? 0) + 1);
+
   // 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.
   const livePlane = (p: schema.PlaneRow) => {
@@ -169,7 +208,7 @@ export async function getStateSnapshot(): Promise<StateSnapshot> {
   };
 
   return {
-    account: { cash: accountRow.cash, reputation: accountRow.reputation },
+    account: { cash: player.cash, reputation: player.reputation },
     simState: { clockMs: simRow.clockMs },
     catalog: catalogEntries(),
     fuelPricePerL: FUEL_PRICE_PER_L,
@@ -192,8 +231,18 @@ export async function getStateSnapshot(): Promise<StateSnapshot> {
         queue: parseIcaoQueue(p.queue),
         health: p.health, // v0.39.0 (ISS-069) — stored value; wear accumulates at landing only
         repairUntilSimTime: p.repairUntilSimTime,
+        ownerId: p.ownerId, // v1.4.0 (ISS-112)
+        ownerName: usernameByPlayerId.get(p.ownerId) ?? p.ownerId, // missing players row → raw id, never a crash
       };
     }),
+    // v1.6.0 (ISS-115): leaderboard rows — every player in the world with their economy + fleet size.
+    players: playerRows.map((pl) => ({
+      id: pl.id,
+      username: pl.username,
+      cash: pl.cash,
+      reputation: pl.reputation,
+      planeCount: planeCountByOwner.get(pl.id) ?? 0,
+    })),
     packages: packageRows.filter((p) => p.status !== 'open' || pool.has(p.originIcao)).map((p) => ({
         id: p.id,
         originIcao: p.originIcao,
@@ -211,6 +260,11 @@ export async function getStateSnapshot(): Promise<StateSnapshot> {
         planeId: p.planeId,
         createdSimTime: p.createdSimTime,
         expiresRealMs: p.status === 'open' ? p.createdRealMs + JOB_LIFETIME_MS : null,
+        // v1.4.0 (ISS-112): carrier = the CARRYING PLANE's owner — unassigned packages stay null.
+        carrierName: (() => {
+          const plane = p.planeId ? planeById.get(p.planeId) : undefined;
+          return plane ? usernameByPlayerId.get(plane.ownerId) ?? plane.ownerId : null;
+        })(),
       })),
   };
 }

lib/mapData.test.ts

@@ -36,6 +36,7 @@ function snapshot(overrides: Partial<StateSnapshot> = {}): StateSnapshot {
     account: { cash: 0, reputation: 0 },
     simState: { clockMs: 0 },
     planes: [],
+    players: [], // v1.6.0 (ISS-115) — leaderboard rows; unused by the map projections
     packages: [],
     catalog: [
       { model: 'atr72', label: 'ATR 72-600', price: 200_000, maxFuel: 6300, burnPerKm: 1.75, emptyWeightKg: 9_300, speedKmh: 510, maxPayloadKg: 4_800 },
@@ -55,8 +56,8 @@ describe('planesGeoJson', () => {
     const fc = planesGeoJson(
       snapshot({
         planes: [
-          { id: 'plane-starter', model: 'atr72', status: 'available', fuel: 6300, maxFuel: 6300, locationIcao: 'EDDF', locationName: 'Frankfurt Main Airport', destIcao: null, destName: null, departureSimTime: null, lat: 50.03, lon: 8.56, health: 100, repairUntilSimTime: null, queue: [] },
+          { id: 'plane-starter', model: 'atr72', status: 'available', fuel: 6300, maxFuel: 6300, locationIcao: 'EDDF', locationName: 'Frankfurt Main Airport', destIcao: null, destName: null, departureSimTime: null, lat: 50.03, lon: 8.56, health: 100, repairUntilSimTime: null, queue: [], ownerId: 'local', ownerName: 'kamilkrzywda' },
-          { 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: [] },
+          { 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: [], ownerId: 'local', ownerName: 'kamilkrzywda' },
         ],
       }),
       AIRPORTS, // non-crossing leg — the unwrap is a no-op, positions stay as polled
@@ -83,7 +84,7 @@ describe('planesGeoJson', () => {
       snapshot({
         catalog: [],
         planes: [
-          { 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: [] },
+          { 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: [], ownerId: 'local', ownerName: 'kamilkrzywda' },
         ],
       }),
       AIRPORTS,
@@ -95,7 +96,7 @@ describe('planesGeoJson', () => {
     const fc = planesGeoJson(
       snapshot({
         planes: [
-          { 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: [] },
+          { 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: [], ownerId: 'local', ownerName: 'kamilkrzywda' },
         ],
       }),
       AIRPORTS, // no destIcao — the unwrap guard skips it, position stays as polled
@@ -113,7 +114,7 @@ describe('planesGeoJson — antimeridian marker unwrap (ISS-124 v0.58.0)', () =>
     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: [] },
+          { 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: [], ownerId: 'local', ownerName: 'kamilkrzywda' },
         ],
       }),
       AIRPORTS,
@@ -127,7 +128,7 @@ describe('planesGeoJson — antimeridian marker unwrap (ISS-124 v0.58.0)', () =>
     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: [] },
+          { 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: [], ownerId: 'local', ownerName: 'kamilkrzywda' },
         ],
       }),
       AIRPORTS,
@@ -148,7 +149,7 @@ describe('planesGeoJson — antimeridian marker unwrap (ISS-124 v0.58.0)', () =>
       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: [] },
+            { 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: [], ownerId: 'local', ownerName: 'kamilkrzywda' },
           ],
         }),
         AIRPORTS,
@@ -161,7 +162,7 @@ describe('planesGeoJson — antimeridian marker unwrap (ISS-124 v0.58.0)', () =>
     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: [] },
+          { 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: [], ownerId: 'local', ownerName: 'kamilkrzywda' },
         ],
       }),
       AIRPORTS,
@@ -173,7 +174,7 @@ describe('planesGeoJson — antimeridian marker unwrap (ISS-124 v0.58.0)', () =>
     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: [] },
+          { 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: [], ownerId: 'local', ownerName: 'kamilkrzywda' },
         ],
       }),
       AIRPORTS,
@@ -185,7 +186,7 @@ describe('planesGeoJson — antimeridian marker unwrap (ISS-124 v0.58.0)', () =>
     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: [] },
+          { 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: [], ownerId: 'local', ownerName: 'kamilkrzywda' },
         ],
       }),
       AIRPORTS,
@@ -197,7 +198,7 @@ describe('planesGeoJson — antimeridian marker unwrap (ISS-124 v0.58.0)', () =>
     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: [] },
+          { 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: [], ownerId: 'local', ownerName: 'kamilkrzywda' },
         ],
       }),
       AIRPORTS,
@@ -217,7 +218,7 @@ describe('routesGeoJson (v0.12.0 — one line per flying plane\'s current leg)',
     const fc = routesGeoJson(
       snapshot({
         planes: [
-          { id: 'p1', model: 'atr72', status: 'available', fuel: 1, maxFuel: 2, locationIcao: 'EDDF', locationName: 'F', destIcao: null, destName: null, departureSimTime: null, lat: 50.03, lon: 8.56, health: 100, repairUntilSimTime: null, queue: [] },
+          { id: 'p1', model: 'atr72', status: 'available', fuel: 1, maxFuel: 2, locationIcao: 'EDDF', locationName: 'F', destIcao: null, destName: null, departureSimTime: null, lat: 50.03, lon: 8.56, health: 100, repairUntilSimTime: null, queue: [], ownerId: 'local', ownerName: 'kamilkrzywda' },
         ],
       }),
       AIRPORTS,
@@ -229,7 +230,7 @@ describe('routesGeoJson (v0.12.0 — one line per flying plane\'s current leg)',
     const fc = routesGeoJson(
       snapshot({
         planes: [
-          { id: 'p1', model: 'atr72', status: 'flying', fuel: 1, maxFuel: 2, locationIcao: 'EDDF', locationName: 'F', destIcao: 'EHAM', destName: 'A', departureSimTime: 0, lat: 51, lon: 9, health: 100, repairUntilSimTime: null, queue: [] },
+          { id: 'p1', model: 'atr72', status: 'flying', fuel: 1, maxFuel: 2, locationIcao: 'EDDF', locationName: 'F', destIcao: 'EHAM', destName: 'A', departureSimTime: 0, lat: 51, lon: 9, health: 100, repairUntilSimTime: null, queue: [], ownerId: 'local', ownerName: 'kamilkrzywda' },
         ],
       }),
       AIRPORTS,
@@ -246,7 +247,7 @@ describe('routesGeoJson (v0.12.0 — one line per flying plane\'s current leg)',
     const fc = routesGeoJson(
       snapshot({
         planes: [
-          { id: 'p1', model: 'atr72', status: 'flying', fuel: 1, maxFuel: 2, locationIcao: 'ZZZZ', locationName: '?', destIcao: 'EDDV', destName: 'H', departureSimTime: 0, lat: 0, lon: 0, health: 100, repairUntilSimTime: null, queue: [] },
+          { id: 'p1', model: 'atr72', status: 'flying', fuel: 1, maxFuel: 2, locationIcao: 'ZZZZ', locationName: '?', destIcao: 'EDDV', destName: 'H', departureSimTime: 0, lat: 0, lon: 0, health: 100, repairUntilSimTime: null, queue: [], ownerId: 'local', ownerName: 'kamilkrzywda' },
         ],
       }),
       AIRPORTS,
@@ -258,8 +259,8 @@ describe('routesGeoJson (v0.12.0 — one line per flying plane\'s current leg)',
     const fc = routesGeoJson(
       snapshot({
         planes: [
-          { id: 'p1', model: 'atr72', status: 'flying', fuel: 1, maxFuel: 2, locationIcao: 'EDDF', locationName: 'F', destIcao: 'EDDV', destName: 'H', departureSimTime: 0, lat: 51, lon: 9, health: 100, repairUntilSimTime: null, queue: [] },
+          { id: 'p1', model: 'atr72', status: 'flying', fuel: 1, maxFuel: 2, locationIcao: 'EDDF', locationName: 'F', destIcao: 'EDDV', destName: 'H', departureSimTime: 0, lat: 51, lon: 9, health: 100, repairUntilSimTime: null, queue: [], ownerId: 'local', ownerName: 'kamilkrzywda' },
-          { id: 'p2', model: 'atr72', status: 'flying', fuel: 1, maxFuel: 2, locationIcao: 'EDDV', locationName: 'H', destIcao: 'EHAM', destName: 'A', departureSimTime: 0, lat: 52.4, lon: 9.6, health: 100, repairUntilSimTime: null, queue: [] },
+          { id: 'p2', model: 'atr72', status: 'flying', fuel: 1, maxFuel: 2, locationIcao: 'EDDV', locationName: 'H', destIcao: 'EHAM', destName: 'A', departureSimTime: 0, lat: 52.4, lon: 9.6, health: 100, repairUntilSimTime: null, queue: [], ownerId: 'local', ownerName: 'kamilkrzywda' },
         ],
       }),
       AIRPORTS,
@@ -273,7 +274,7 @@ describe('queuedRoutesGeoJson (ISS-043 v0.26.0 — dotted queue line: dest → q
     const fc = queuedRoutesGeoJson(
       [
         // Pre-built route while grounded: the line starts at the plane's current airport, not at any dest.
-        { id: 'p1', model: 'atr72', status: 'available', fuel: 1, maxFuel: 2, locationIcao: 'EDDF', locationName: 'F', destIcao: null, destName: null, departureSimTime: null, lat: 50.03, lon: 8.56, health: 100, repairUntilSimTime: null, queue: ['EHAM'] },
+        { id: 'p1', model: 'atr72', status: 'available', fuel: 1, maxFuel: 2, locationIcao: 'EDDF', locationName: 'F', destIcao: null, destName: null, departureSimTime: null, lat: 50.03, lon: 8.56, health: 100, repairUntilSimTime: null, queue: ['EHAM'], ownerId: 'local', ownerName: 'kamilkrzywda' },
       ],
       AIRPORTS,
     );
@@ -288,7 +289,7 @@ describe('queuedRoutesGeoJson (ISS-043 v0.26.0 — dotted queue line: dest → q
   it('skips a grounded plane whose locationIcao is missing from the airport index', () => {
     const fc = queuedRoutesGeoJson(
       [
-        { id: 'p1', model: 'atr72', status: 'available', fuel: 1, maxFuel: 2, locationIcao: 'ZZZZ', locationName: '?', destIcao: null, destName: null, departureSimTime: null, lat: 0, lon: 0, health: 100, repairUntilSimTime: null, queue: ['EHAM'] },
+        { id: 'p1', model: 'atr72', status: 'available', fuel: 1, maxFuel: 2, locationIcao: 'ZZZZ', locationName: '?', destIcao: null, destName: null, departureSimTime: null, lat: 0, lon: 0, health: 100, repairUntilSimTime: null, queue: ['EHAM'], ownerId: 'local', ownerName: 'kamilkrzywda' },
       ],
       AIRPORTS,
     );
@@ -298,7 +299,7 @@ describe('queuedRoutesGeoJson (ISS-043 v0.26.0 — dotted queue line: dest → q
   it('draws nothing for a repairing plane, even with a non-empty queue', () => {
     const fc = queuedRoutesGeoJson(
       [
-        { id: 'p1', model: 'atr72', status: 'repairing', fuel: 1, maxFuel: 2, locationIcao: 'EDDF', locationName: 'F', destIcao: null, destName: null, departureSimTime: null, lat: 50.03, lon: 8.56, health: 0, repairUntilSimTime: 1000, queue: ['EHAM'] },
+        { id: 'p1', model: 'atr72', status: 'repairing', fuel: 1, maxFuel: 2, locationIcao: 'EDDF', locationName: 'F', destIcao: null, destName: null, departureSimTime: null, lat: 50.03, lon: 8.56, health: 0, repairUntilSimTime: 1000, queue: ['EHAM'], ownerId: 'local', ownerName: 'kamilkrzywda' },
       ],
       AIRPORTS,
     );
@@ -308,7 +309,7 @@ describe('queuedRoutesGeoJson (ISS-043 v0.26.0 — dotted queue line: dest → q
   it('draws nothing for a flying plane with an empty queue', () => {
     const fc = queuedRoutesGeoJson(
       [
-        { id: 'p1', model: 'atr72', status: 'flying', fuel: 1, maxFuel: 2, locationIcao: 'EDDF', locationName: 'F', destIcao: 'EHAM', destName: 'A', departureSimTime: 0, lat: 51, lon: 9, health: 100, repairUntilSimTime: null, queue: [] },
+        { id: 'p1', model: 'atr72', status: 'flying', fuel: 1, maxFuel: 2, locationIcao: 'EDDF', locationName: 'F', destIcao: 'EHAM', destName: 'A', departureSimTime: 0, lat: 51, lon: 9, health: 100, repairUntilSimTime: null, queue: [], ownerId: 'local', ownerName: 'kamilkrzywda' },
       ],
       AIRPORTS,
     );
@@ -319,7 +320,7 @@ describe('queuedRoutesGeoJson (ISS-043 v0.26.0 — dotted queue line: dest → q
     const fc = queuedRoutesGeoJson(
       [
         // Active leg EDDF→EHAM stays in routesGeoJson; the queue line is ONLY EHAM → EDDV → LEMD.
-        { id: 'p1', model: 'atr72', status: 'flying', fuel: 1, maxFuel: 2, locationIcao: 'EDDF', locationName: 'F', destIcao: 'EHAM', destName: 'A', departureSimTime: 0, lat: 51, lon: 9, health: 100, repairUntilSimTime: null, queue: ['EDDV', 'LEMD'] },
+        { id: 'p1', model: 'atr72', status: 'flying', fuel: 1, maxFuel: 2, locationIcao: 'EDDF', locationName: 'F', destIcao: 'EHAM', destName: 'A', departureSimTime: 0, lat: 51, lon: 9, health: 100, repairUntilSimTime: null, queue: ['EDDV', 'LEMD'], ownerId: 'local', ownerName: 'kamilkrzywda' },
       ],
       AIRPORTS,
     );
@@ -336,8 +337,8 @@ describe('queuedRoutesGeoJson (ISS-043 v0.26.0 — dotted queue line: dest → q
   it('skips a plane whose dest or a queued ICAO is missing from the airport index', () => {
     const fc = queuedRoutesGeoJson(
       [
-        { id: 'p1', model: 'atr72', status: 'flying', fuel: 1, maxFuel: 2, locationIcao: 'EDDF', locationName: 'F', destIcao: 'ZZZZ', destName: '?', departureSimTime: 0, lat: 51, lon: 9, health: 100, repairUntilSimTime: null, queue: ['EHAM'] },
+        { id: 'p1', model: 'atr72', status: 'flying', fuel: 1, maxFuel: 2, locationIcao: 'EDDF', locationName: 'F', destIcao: 'ZZZZ', destName: '?', departureSimTime: 0, lat: 51, lon: 9, health: 100, repairUntilSimTime: null, queue: ['EHAM'], ownerId: 'local', ownerName: 'kamilkrzywda' },
-        { id: 'p2', model: 'atr72', status: 'flying', fuel: 1, maxFuel: 2, locationIcao: 'EDDF', locationName: 'F', destIcao: 'EHAM', destName: 'A', departureSimTime: 0, lat: 51, lon: 9, health: 100, repairUntilSimTime: null, queue: ['ZZZZ'] },
+        { id: 'p2', model: 'atr72', status: 'flying', fuel: 1, maxFuel: 2, locationIcao: 'EDDF', locationName: 'F', destIcao: 'EHAM', destName: 'A', departureSimTime: 0, lat: 51, lon: 9, health: 100, repairUntilSimTime: null, queue: ['ZZZZ'], ownerId: 'local', ownerName: 'kamilkrzywda' },
       ],
       AIRPORTS,
     );
@@ -347,9 +348,9 @@ describe('queuedRoutesGeoJson (ISS-043 v0.26.0 — dotted queue line: dest → q
   it('one feature per qualifying plane — flying and grounded queues draw; empty-queue planes do not', () => {
     const fc = queuedRoutesGeoJson(
       [
-        { id: 'p1', model: 'atr72', status: 'flying', fuel: 1, maxFuel: 2, locationIcao: 'EDDF', locationName: 'F', destIcao: 'EHAM', destName: 'A', departureSimTime: 0, lat: 51, lon: 9, health: 100, repairUntilSimTime: null, queue: ['LEMD'] },
+        { id: 'p1', model: 'atr72', status: 'flying', fuel: 1, maxFuel: 2, locationIcao: 'EDDF', locationName: 'F', destIcao: 'EHAM', destName: 'A', departureSimTime: 0, lat: 51, lon: 9, health: 100, repairUntilSimTime: null, queue: ['LEMD'], ownerId: 'local', ownerName: 'kamilkrzywda' },
-        { id: 'p2', model: 'atr72', status: 'flying', fuel: 1, maxFuel: 2, locationIcao: 'EHAM', locationName: 'A', destIcao: 'EDDV', destName: 'H', departureSimTime: 0, lat: 52.3, lon: 4.7, health: 100, repairUntilSimTime: null, queue: [] },
+        { id: 'p2', model: 'atr72', status: 'flying', fuel: 1, maxFuel: 2, locationIcao: 'EHAM', locationName: 'A', destIcao: 'EDDV', destName: 'H', departureSimTime: 0, lat: 52.3, lon: 4.7, health: 100, repairUntilSimTime: null, queue: [], ownerId: 'local', ownerName: 'kamilkrzywda' },
-        { id: 'p3', model: 'atr72', status: 'available', fuel: 1, maxFuel: 2, locationIcao: 'EDDV', locationName: 'H', destIcao: null, destName: null, departureSimTime: null, lat: 52.46, lon: 9.68, health: 100, repairUntilSimTime: null, queue: ['LEMD'] },
+        { id: 'p3', model: 'atr72', status: 'available', fuel: 1, maxFuel: 2, locationIcao: 'EDDV', locationName: 'H', destIcao: null, destName: null, departureSimTime: null, lat: 52.46, lon: 9.68, health: 100, repairUntilSimTime: null, queue: ['LEMD'], ownerId: 'local', ownerName: 'kamilkrzywda' },
       ],
       AIRPORTS,
     );
@@ -491,7 +492,7 @@ describe('greatCircleArc — antimeridian crossing (ISS-120 v0.53.0)', () => {
     // 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'] },
+        { 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'], ownerId: 'local', ownerName: 'kamilkrzywda' },
       ],
       AIRPORTS,
     );
@@ -529,7 +530,7 @@ describe('NZAA→NFTF crossing leg — full pipeline on stored dataset coords (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: [] },
+          { 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: [], ownerId: 'local', ownerName: 'kamilkrzywda' },
         ],
       });
       lons.push(planesGeoJson(snap, index).features[0]!.geometry.coordinates[0]!);

lib/openapi.test.ts

@@ -3,7 +3,7 @@ import { describe, expect, it } from 'vitest';
 import { openApiSpec } from './openapi';
 
 describe('OpenAPI spec', () => {
-  it('documents exactly the seventeen public endpoints (6 read + 8 player actions + 2 auth + 1 admin CRUD)', () => {
+  it('documents exactly the eighteen public endpoints (4 read + 8 player actions + 4 auth + 2 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
@@ -20,6 +20,7 @@ describe('OpenAPI spec', () => {
       '/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/register', // v1.1.0 (ISS-107) — self-service account creation
       '/api/state',
       '/api/version',
     ]);
@@ -76,6 +77,7 @@ describe('OpenAPI spec', () => {
       'fuelPricePerL',
       'packages',
       'planes',
+      'players', // v1.6.0 (ISS-115) — leaderboard rows ride on every snapshot
       'sellFraction',
       'simState',
     ]);
@@ -85,12 +87,14 @@ describe('OpenAPI spec', () => {
       'fuelPricePerL',
       'packages',
       'planes',
+      'players', // v1.6.0 (ISS-115) — leaderboard rows ride on every snapshot
       'sellFraction',
       'simState',
     ]);
     expect(snap.account.$ref).toBe('#/components/schemas/AccountState');
     expect(snap.simState.$ref).toBe('#/components/schemas/SimState');
     expect(snap.planes.items.$ref).toBe('#/components/schemas/PlaneState');
+    expect(snap.players.items.$ref).toBe('#/components/schemas/PlayerSummary'); // v1.6.0 (ISS-115)
     expect(snap.packages.items.$ref).toBe('#/components/schemas/PackageState');
     expect(snap.catalog.items.$ref).toBe('#/components/schemas/CatalogEntry');
     expect(snap.fuelPricePerL.type).toBe('number');
@@ -127,6 +131,8 @@ describe('OpenAPI spec', () => {
       'lon',
       'maxFuel',
       'model',
+      'ownerId', // v1.4.0 (ISS-112) — owner's players.id
+      'ownerName', // v1.4.0 (ISS-112) — owner's username
       'queue', // v0.25.0 (ISS-043) — upcoming legs not yet started
       'repairUntilSimTime', // v0.39.0 (ISS-069) — active repair gate; null when not repairing
       'status',
@@ -136,6 +142,7 @@ describe('OpenAPI spec', () => {
     expect(Object.keys(pkg).sort()).toEqual([
       'cargoCount',
       'cargoType',
+      'carrierName', // v1.4.0 (ISS-112) — carrier's username via planeId → owner; null when unassigned
       'createdSimTime',
       'deadlineSimTime',
       'destIcao',
@@ -184,16 +191,17 @@ describe('OpenAPI spec', () => {
       expect(ok.content['application/json'].schema.$ref).toBe('#/components/schemas/StateSnapshot');
     }
 
-    // Error shapes per endpoint.
+    // Error shapes per endpoint. v1.2.0 (ISS-109): every plane-targeted action also documents 403
+    // (the session player does not own the plane); buy-plane has no plane target, so it gains none.
     const errorCodes = (p: string) => Object.keys(post(p).responses).filter((k) => k !== '200').sort();
-    expect(errorCodes('/api/packages/{id}/load')).toEqual(['400', '404', '409']);
+    expect(errorCodes('/api/packages/{id}/load')).toEqual(['400', '403', '404', '409']);
-    expect(errorCodes('/api/packages/{id}/abandon')).toEqual(['404', '409']);
+    expect(errorCodes('/api/packages/{id}/abandon')).toEqual(['403', '404', '409']);
-    expect(errorCodes('/api/planes/{planeId}/fly')).toEqual(['400', '404', '409']);
+    expect(errorCodes('/api/planes/{planeId}/fly')).toEqual(['400', '403', '404', '409']);
-    expect(errorCodes('/api/planes/{planeId}/queue')).toEqual(['400', '404', '409']); // v0.34.0 (ISS-065) — 409 on duplicate leg / active-leg re-queue
+    expect(errorCodes('/api/planes/{planeId}/queue')).toEqual(['400', '403', '404', '409']); // v0.34.0 (ISS-065) — 409 on duplicate leg / active-leg re-queue
-    expect(errorCodes('/api/planes/{planeId}/queue/cancel')).toEqual(['400', '404']); // v0.25.0
+    expect(errorCodes('/api/planes/{planeId}/queue/cancel')).toEqual(['400', '403', '404']); // v0.25.0
     expect(errorCodes('/api/market/buy-plane')).toEqual(['400', '409']);
-    expect(errorCodes('/api/market/sell-plane')).toEqual(['400', '404', '409']);
+    expect(errorCodes('/api/market/sell-plane')).toEqual(['400', '403', '404', '409']);
-    expect(errorCodes('/api/planes/{planeId}/repair')).toEqual(['404', '409']); // v0.39.0 (ISS-069) — no body, so no 400
+    expect(errorCodes('/api/planes/{planeId}/repair')).toEqual(['403', '404', '409']); // v0.39.0 (ISS-069) — no body, so no 400
 
     // Request bodies: load/fly/buy/sell take their dedicated schemas; abandon and repair take none.
     expect(post('/api/packages/{id}/load').requestBody?.content['application/json'].schema.$ref).toBe(

lib/openapi.ts

@@ -110,6 +110,10 @@ export const openApiSpec = {
             description: 'Invalid body (not an object, unknown field, or missing/non-string planeId)',
             content: { 'application/json': { schema: { $ref: '#/components/schemas/Error' } } },
           },
+          403: {
+            description: 'The session player does not own this plane (v1.2.0, ISS-109)',
+            content: { 'application/json': { schema: { $ref: '#/components/schemas/Error' } } },
+          },
           404: {
             description: 'Unknown package id or plane id',
             content: { 'application/json': { schema: { $ref: '#/components/schemas/Error' } } },
@@ -136,6 +140,10 @@ export const openApiSpec = {
             description: 'Abandoned — full state snapshot (package "abandoned", cash reduced by the penalty)',
             content: { 'application/json': { schema: { $ref: '#/components/schemas/StateSnapshot' } } },
           },
+          403: {
+            description: 'The session player does not own the bound plane (v1.2.0, ISS-109)',
+            content: { 'application/json': { schema: { $ref: '#/components/schemas/Error' } } },
+          },
           404: {
             description: 'Unknown package id',
             content: { 'application/json': { schema: { $ref: '#/components/schemas/Error' } } },
@@ -174,6 +182,10 @@ export const openApiSpec = {
               'Invalid body (not an object, unknown field, or missing/non-string destIcao) or the ICAO is not in the airport dataset',
             content: { 'application/json': { schema: { $ref: '#/components/schemas/Error' } } },
           },
+          403: {
+            description: 'The session player does not own this plane (v1.2.0, ISS-109)',
+            content: { 'application/json': { schema: { $ref: '#/components/schemas/Error' } } },
+          },
           404: {
             description: 'Unknown plane id',
             content: { 'application/json': { schema: { $ref: '#/components/schemas/Error' } } },
@@ -213,6 +225,10 @@ export const openApiSpec = {
               'Invalid body (not an object, unknown field, or missing/non-string destIcao) or the ICAO is not in the airport dataset',
             content: { 'application/json': { schema: { $ref: '#/components/schemas/Error' } } },
           },
+          403: {
+            description: 'The session player does not own this plane (v1.2.0, ISS-109)',
+            content: { 'application/json': { schema: { $ref: '#/components/schemas/Error' } } },
+          },
           404: {
             description: 'Unknown plane id',
             content: { 'application/json': { schema: { $ref: '#/components/schemas/Error' } } },
@@ -252,6 +268,10 @@ export const openApiSpec = {
               'Invalid body (not an object, unknown field, or non-integer index) or the index is outside [0, queue.length)',
             content: { 'application/json': { schema: { $ref: '#/components/schemas/Error' } } },
           },
+          403: {
+            description: 'The session player does not own this plane (v1.2.0, ISS-109)',
+            content: { 'application/json': { schema: { $ref: '#/components/schemas/Error' } } },
+          },
           404: {
             description: 'Unknown plane id',
             content: { 'application/json': { schema: { $ref: '#/components/schemas/Error' } } },
@@ -312,6 +332,10 @@ export const openApiSpec = {
             description: 'Invalid body (not an object, unknown field, or missing/non-string planeId)',
             content: { 'application/json': { schema: { $ref: '#/components/schemas/Error' } } },
           },
+          403: {
+            description: 'The session player does not own this plane (v1.2.0, ISS-109)',
+            content: { 'application/json': { schema: { $ref: '#/components/schemas/Error' } } },
+          },
           404: {
             description: 'Unknown plane id',
             content: { 'application/json': { schema: { $ref: '#/components/schemas/Error' } } },
@@ -337,6 +361,10 @@ export const openApiSpec = {
             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' } } },
           },
+          403: {
+            description: 'The session player does not own this plane (v1.2.0, ISS-109)',
+            content: { 'application/json': { schema: { $ref: '#/components/schemas/Error' } } },
+          },
           404: {
             description: 'Unknown plane id',
             content: { 'application/json': { schema: { $ref: '#/components/schemas/Error' } } },
@@ -348,6 +376,37 @@ export const openApiSpec = {
         },
       },
     },
+    // v1.1.0 — multiplayer step 3 (ISS-107): self-service account creation.
+    '/api/register': {
+      post: {
+        summary: 'Create an account',
+        description:
+          'Register a new local account (v1.1.0, ISS-107): username 3–20 chars of [a-z0-9_-] (case-insensitive input, stored lowercase), password at least 8 chars — else 400; 409 when the username is taken. Creates the users row (scrypt) AND a players row with the starter economy (the exact values a fresh world seeds: €20,000 cash, reputation 10). Mints a session immediately and returns it, so no second round-trip is needed.',
+        operationId: 'register',
+        requestBody: {
+          required: true,
+          content: {
+            'application/json': {
+              schema: { $ref: '#/components/schemas/RegisterRequest' },
+            },
+          },
+        },
+        responses: {
+          200: {
+            description: 'Registered — new session id + the user (same shape as login)',
+            content: { 'application/json': { schema: { $ref: '#/components/schemas/LoginResponse' } } },
+          },
+          400: {
+            description: 'Invalid body (not an object, unknown field, bad username charset/length, or password shorter than 8 chars)',
+            content: { 'application/json': { schema: { $ref: '#/components/schemas/Error' } } },
+          },
+          409: {
+            description: 'Username is already taken',
+            content: { 'application/json': { schema: { $ref: '#/components/schemas/Error' } } },
+          },
+        },
+      },
+    },
     // v0.71.0 — admin panel: session auth + generic whole-database CRUD behind the admin flag.
     '/api/login': {
       post: {
@@ -445,7 +504,7 @@ export const openApiSpec = {
       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.',
+          'Column headers + up to `limit` rows of the named table (default 500, cap 1000). rowid is exposed as __rowid so the PK-less tables (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' } },
@@ -648,6 +707,11 @@ export const openApiSpec = {
             type: 'array',
             items: { $ref: '#/components/schemas/PlaneState' },
           },
+          players: {
+            type: 'array',
+            description: 'Leaderboard rows (v1.6.0, ISS-115) — one per player in the world.',
+            items: { $ref: '#/components/schemas/PlayerSummary' },
+          },
           packages: {
             type: 'array',
             items: { $ref: '#/components/schemas/PackageState' },
@@ -660,7 +724,7 @@ export const openApiSpec = {
           fuelPricePerL: { type: 'number', description: 'Jet-A1 price in €/liter; the automatic dispatch top-up costs liters × this, reduced by a reputation-scaled discount at refuel time (v0.38.0) — ISS-082 (v0.42.0): it now applies to the auto-refuel on /fly and the engine\'s chained-leg top-ups.' },
           sellFraction: { type: 'number', description: 'Fraction of the catalog price paid out when selling a plane.' },
         },
-        required: ['account', 'simState', 'planes', 'packages', 'catalog', 'fuelPricePerL', 'sellFraction'],
+        required: ['account', 'simState', 'planes', 'players', 'packages', 'catalog', 'fuelPricePerL', 'sellFraction'],
       },
       CatalogEntry: {
         type: 'object',
@@ -691,6 +755,18 @@ export const openApiSpec = {
         },
         required: ['clockMs'],
       },
+      PlayerSummary: {
+        type: 'object',
+        description: 'One leaderboard row (v1.6.0, ISS-115) — a player\'s economy plus how many planes they own.',
+        properties: {
+          id: { type: 'string' },
+          username: { type: 'string' },
+          cash: { type: 'number' },
+          reputation: { type: 'number' },
+          planeCount: { type: 'integer', description: 'Number of planes in the world owned by this player.' },
+        },
+        required: ['id', 'username', 'cash', 'reputation', 'planeCount'],
+      },
       LoadPackageRequest: {
         type: 'object',
         properties: {
@@ -733,6 +809,15 @@ export const openApiSpec = {
         },
         required: ['planeId'],
       },
+      // v1.1.0 — multiplayer step 3 (ISS-107).
+      RegisterRequest: {
+        type: 'object',
+        properties: {
+          username: { type: 'string', description: '3–20 chars of [a-z0-9_-]; input is lowercased before validation.' },
+          password: { type: 'string', description: 'Plaintext, at least 8 chars — stored as a scrypt digest server-side.' },
+        },
+        required: ['username', 'password'],
+      },
       // v0.71.0 — admin panel auth + DB tooling schemas.
       LoginRequest: {
         type: 'object',
@@ -866,6 +951,8 @@ export const openApiSpec = {
             description:
               'Sim-clock epoch ms when an active repair finishes (v0.39.0) — set with status "repairing", cleared by the engine\'s flip-back; null when not in repair.',
           },
+          ownerId: { type: 'string', description: 'Owner\'s players.id (v1.4.0, ISS-112) — the snapshot carries ALL planes in the shared world.' },
+          ownerName: { type: 'string', description: 'Owner\'s username (v1.4.0, ISS-112).' },
         },
         required: [
           'id',
@@ -883,6 +970,8 @@ export const openApiSpec = {
           'queue',
           'health', // v0.39.0 (ISS-069) — structural health in [0, 100]
           'repairUntilSimTime', // v0.39.0 (ISS-069) — active repair gate; null when not repairing
+          'ownerId', // v1.4.0 (ISS-112) — owner's players.id
+          'ownerName', // v1.4.0 (ISS-112) — owner's username
         ],
       },
       PackageState: {
@@ -906,6 +995,7 @@ export const openApiSpec = {
           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.' },
+          carrierName: { type: ['string', 'null'], description: 'Carrier name (v1.4.0, ISS-112) — players.username of the carrying plane\'s owner via planeId → planes.owner_id; null when unassigned.' },
         },
         required: [
           'id',
@@ -923,6 +1013,7 @@ export const openApiSpec = {
           'planeId',
           'createdSimTime',
           'expiresRealMs', // v0.65.0 — wall-clock expiry of open jobs; null otherwise
+          'carrierName', // v1.4.0 (ISS-112) — carrier's username via planeId → owner; null when unassigned
         ],
       },
     },

lib/sim/engine.test.ts

@@ -5,12 +5,13 @@ import { eq } from 'drizzle-orm';
 import { afterAll, beforeAll, describe, expect, it, vi } from 'vitest';
 import { openGameDb } from '@/lib/db/client';
 import * as schema from '@/lib/db/schema';
+import { LOCAL_PLAYER, getPlayer, getLocalPlayer, updateLocalPlayerEconomy } from '@/lib/db/localPlayer';
 import { loadAirportsGeoJson } from '@/lib/airports';
 import { haversineKm, initialBearingDeg } from '@/lib/geo';
 import { weatherFor } from '@/lib/weather';
 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 { 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 { JOB_BONUS_PER_REP, JOB_LIFETIME_MS, MAX_JOB_BONUS, POOL_BANDS, POOL_TARGET_PER_AIRPORT, REFILL_DELAY_MS, SMALL_REFILL_DELAY_MS, STARTING_CLOCK_MS, STARTING_REPUTATION, mulberry32, poolBandOf, rewardFor } from '@/lib/game/seed';
 import { arrivalTimeFor, fuelAtWeighted, requiredFuelFor, windBurnFactor } from './movement';
 import {
   deliverPackages,
@@ -228,20 +229,20 @@ describe('deliverPackages (v0.12.0 arrival delivery)', () => {
 
   it('does nothing before the arrival time', async () => {
     const { inst, km, type } = await setupFlight('deliver-early.db');
-    const accountBefore = (await inst.db.select().from(schema.account))[0]!;
+    const playerBefore = (await getLocalPlayer(inst));
 
     const clock = T0 + travelMs(km, type.speedKmh) - 1; // one ms before arrival
     expect(await deliverPackages(inst, clock)).toBe(0);
 
     const plane = (await inst.db.select().from(schema.planes))[0];
-    const account = (await inst.db.select().from(schema.account))[0]!;
+    const player = (await getLocalPlayer(inst));
     expect(plane.status).toBe('flying');
-    expect(account.cash).toBe(accountBefore.cash); // no award before landing
+    expect(player.cash).toBe(playerBefore.cash); // no award before landing
   });
 
   it('delivers in-deadline cargo, unbinds expired cargo for free, keeps other-dest cargo bound', async () => {
     const { inst, from, to, km, type } = await setupFlight('deliver-mixed.db');
-    const accountBefore = (await inst.db.select().from(schema.account))[0]!;
+    const playerBefore = (await getLocalPlayer(inst));
 
     // Three packages on the plane: one in-deadline for TO, one expired for TO,
     // one loaded for a DIFFERENT airport (stays bound for a later leg).
@@ -274,23 +275,23 @@ describe('deliverPackages (v0.12.0 arrival delivery)', () => {
     expect(byId.get('p-elsewhere')!.status).toBe('loaded'); // not this airport's cargo…
     expect(byId.get('p-elsewhere')!.planeId).toBe('plane-starter'); // …stays bound for the next leg
 
-    const account = (await inst.db.select().from(schema.account))[0]!;
+    const player = (await getLocalPlayer(inst));
-    expect(account.cash).toBeCloseTo(accountBefore.cash + 5_000, 9); // ONLY p-pay paid out
+    expect(player.cash).toBeCloseTo(playerBefore.cash + 5_000, 9); // ONLY p-pay paid out
-    expect(account.reputation).toBeCloseTo(
+    expect(player.reputation).toBeCloseTo(
-      Math.round((accountBefore.reputation + reputationGainFor(km)) * 100) / 100,
+      Math.round((playerBefore.reputation + reputationGainFor(km)) * 100) / 100,
       9,
     );
 
     // A later tick must not award again — the plane is no longer 'flying'.
     expect(await deliverPackages(inst, clock + 3_600_000)).toBe(0);
-    const accountAfter = (await inst.db.select().from(schema.account))[0]!;
+    const playerAfter = (await getLocalPlayer(inst));
-    expect(accountAfter.cash).toBe(account.cash);
+    expect(playerAfter.cash).toBe(player.cash);
-    expect(accountAfter.reputation).toBe(account.reputation);
+    expect(playerAfter.reputation).toBe(player.reputation);
   });
 
   it('delivers every in-deadline package for the arrival airport with per-package rewards', async () => {
     const { inst, km } = await setupFlight('deliver-multi.db');
-    const accountBefore = (await inst.db.select().from(schema.account))[0]!;
+    const playerBefore = (await getLocalPlayer(inst));
 
     await inst.db.insert(schema.packages).values([
       { id: 'p-a', originIcao: FROM, destIcao: TO, reward: 1_000, cargoType: 'Mail', cargoCount: 1, deadlineSimTime: T0 + 24 * 3_600_000, status: 'loaded', planeId: 'plane-starter', createdSimTime: T0 },
@@ -300,17 +301,17 @@ describe('deliverPackages (v0.12.0 arrival delivery)', () => {
     const clock = T0 + travelMs(km, PLANE_TYPES.atr72.speedKmh);
     expect(await deliverPackages(inst, clock)).toBe(1);
 
-    const account = (await inst.db.select().from(schema.account))[0]!;
+    const player = (await getLocalPlayer(inst));
-    expect(account.cash).toBeCloseTo(accountBefore.cash + 3_500, 9); // both rewards
+    expect(player.cash).toBeCloseTo(playerBefore.cash + 3_500, 9); // both rewards
-    expect(account.reputation).toBeCloseTo(
+    expect(player.reputation).toBeCloseTo(
-      Math.round((accountBefore.reputation + reputationGainFor(km) * 2) * 100) / 100,
+      Math.round((playerBefore.reputation + reputationGainFor(km) * 2) * 100) / 100,
       9,
     ); // rep per delivered package
   });
 
   it('adds the registry rep bonus for a special package at delivery (v0.37.0)', async () => {
     const { inst, km } = await setupFlight('deliver-special.db');
-    const accountBefore = (await inst.db.select().from(schema.account))[0]!;
+    const playerBefore = (await getLocalPlayer(inst));
 
     await inst.db.insert(schema.packages).values([
       { id: 'p-prio', originIcao: FROM, destIcao: TO, reward: 5_000, cargoType: 'Mail', cargoCount: 10, special: 'priority', deadlineSimTime: T0 + 24 * 3_600_000, status: 'loaded', planeId: 'plane-starter', createdSimTime: T0 },
@@ -319,11 +320,11 @@ describe('deliverPackages (v0.12.0 arrival delivery)', () => {
     const clock = T0 + travelMs(km, PLANE_TYPES.atr72.speedKmh); // exactly at arrival
     expect(await deliverPackages(inst, clock)).toBe(1);
 
-    const account = (await inst.db.select().from(schema.account))[0]!;
+    const player = (await getLocalPlayer(inst));
-    expect(account.cash).toBeCloseTo(accountBefore.cash + 5_000, 9);
+    expect(player.cash).toBeCloseTo(playerBefore.cash + 5_000, 9);
     // Distance-based gain + the registry rep bonus — double-rounded like every other award.
-    expect(account.reputation).toBeCloseTo(
+    expect(player.reputation).toBeCloseTo(
-      Math.round((accountBefore.reputation + reputationGainFor(km) + SPECIALS.priority.repBonus) * 100) / 100,
+      Math.round((playerBefore.reputation + reputationGainFor(km) + SPECIALS.priority.repBonus) * 100) / 100,
       9,
     );
   });
@@ -381,7 +382,7 @@ describe('deliverPackages (v0.12.0 arrival delivery)', () => {
       .set({ fuel: depFuel, queue: JSON.stringify(['EHAM']) })
       .where(eq(schema.planes.id, 'plane-starter'));
 
-    const accountBefore = (await inst.db.select().from(schema.account))[0]!; // seeded €20k — the top-up is affordable
+    const playerBefore = (await getLocalPlayer(inst)); // seeded €20k — the top-up is affordable
     const clock = T0 + travelMs(km, type.speedKmh); // exactly at arrival
     expect(await deliverPackages(inst, clock)).toBe(1);
 
@@ -402,7 +403,7 @@ describe('deliverPackages (v0.12.0 arrival delivery)', () => {
     const target = Math.min(type.maxFuel, Math.max(landedFuel, nextRequiredL * 1.5));
     const liters = Math.max(0, target - landedFuel);
     expect(liters).toBeGreaterThan(0); // the hop genuinely needs more than what's left
-    const rate = repRate(accountBefore.reputation, FUEL_DISCOUNT_PER_REP, MAX_FUEL_DISCOUNT);
+    const rate = repRate(playerBefore.reputation, FUEL_DISCOUNT_PER_REP, MAX_FUEL_DISCOUNT);
     const expectedCost = Math.round(liters * FUEL_PRICE_PER_L * (1 - rate) * 100) / 100;
 
     const plane = (await inst.db.select().from(schema.planes))[0];
@@ -412,21 +413,21 @@ describe('deliverPackages (v0.12.0 arrival delivery)', () => {
     expect(JSON.parse(plane.queue)).toEqual([]); // …leg consumed, rest kept in order
     expect(plane.fuel).toBeCloseTo(target, 6); // …departing with the post-top-up level
 
-    const account = (await inst.db.select().from(schema.account))[0]!;
+    const player = (await getLocalPlayer(inst));
-    expect(account.cash).toBeCloseTo(accountBefore.cash - expectedCost, 9); // exactly the rep-discounted cost
+    expect(player.cash).toBeCloseTo(playerBefore.cash - expectedCost, 9); // exactly the rep-discounted cost
   });
 
   it('grounds with the queue intact when cash cannot cover the auto top-up (ISS-082)', async () => {
     const { inst, from, to, km, type } = await setupFlight('chain-nofuel-poor.db');
 
-    // Same empty-tank landing as above, but the account is broke — the top-up is unaffordable.
+    // Same empty-tank landing as above, but the player is broke — the top-up is unaffordable.
     const w = weatherFor(FROM);
     const f = windBurnFactor(w.windKt, w.windDirDeg, initialBearingDeg(from.lat, from.lon, to.lat, to.lon));
     const depFuel = requiredFuelFor(type.burnPerKm * f, type.emptyWeightKg, type.maxFuel, km);
     await inst.db.update(schema.planes)
       .set({ fuel: depFuel, queue: JSON.stringify(['EHAM']) })
       .where(eq(schema.planes.id, 'plane-starter'));
-    await inst.db.update(schema.account).set({ cash: 0 });
+    await updateLocalPlayerEconomy(inst, { cash: 0 });
 
     const clock = T0 + travelMs(km, type.speedKmh); // exactly at arrival
     expect(await deliverPackages(inst, clock)).toBe(1);
@@ -438,7 +439,7 @@ describe('deliverPackages (v0.12.0 arrival delivery)', () => {
     expect(JSON.parse(plane.queue)).toEqual(['EHAM']); // …queue kept for a later dispatch
     const landedFuel = fuelAtWeighted(depFuel, type.burnPerKm * f, type.emptyWeightKg, type.maxFuel, km, 1);
     expect(plane.fuel).toBeCloseTo(landedFuel, 6); // no top-up happened — the tank is untouched
-    expect((await inst.db.select().from(schema.account))[0]!.cash).toBe(0);
+    expect((await getLocalPlayer(inst)).cash).toBe(0);
   });
 
   it('grounds as before when the queue is empty', async () => {
@@ -496,6 +497,78 @@ describe('deliverPackages (v0.12.0 arrival delivery)', () => {
     expect(plane.destIcao).toBeNull();
     expect(JSON.parse(plane.queue)).toEqual(['EHAM']); // …the rest of the queue kept for a later dispatch
   });
+
+  // --- Per-owner economy (v1.3.0, ISS-110) ---
+
+  it('pays cash + reputation to the plane OWNER, not the local player', async () => {
+    const { inst, km } = await setupFlight('deliver-owner.db');
+    // A second player owns the starter — distinct economy so any leak into 'local' is visible.
+    await inst.db.insert(schema.players).values({ id: 'player-b', provider: 'test', username: 'b', cash: 1_000, reputation: 5 });
+    await inst.db.update(schema.planes)
+      .set({ ownerId: 'player-b' })
+      .where(eq(schema.planes.id, 'plane-starter'));
+
+    const localBefore = (await getPlayer(inst, LOCAL_PLAYER.id));
+    const bBefore = (await getPlayer(inst, 'player-b'));
+    await inst.db.insert(schema.packages).values([
+      { id: 'p-owner', originIcao: FROM, destIcao: TO, reward: 5_000, cargoType: 'Mail', cargoCount: 1, deadlineSimTime: T0 + 24 * 3_600_000, status: 'loaded', planeId: 'plane-starter', createdSimTime: T0 },
+    ]);
+
+    const clock = T0 + travelMs(km, PLANE_TYPES.atr72.speedKmh); // exactly at arrival
+    expect(await deliverPackages(inst, clock)).toBe(1);
+
+    const bAfter = (await getPlayer(inst, 'player-b'));
+    expect(bAfter.cash).toBeCloseTo(bBefore.cash + 5_000, 9); // the owner was paid…
+    expect(bAfter.reputation).toBeCloseTo(Math.round((bBefore.reputation + reputationGainFor(km)) * 100) / 100, 9); // …with the distance-based rep gain
+    const localAfter = (await getPlayer(inst, LOCAL_PLAYER.id));
+    expect(localAfter.cash).toBe(localBefore.cash); // the local player is untouched…
+    expect(localAfter.reputation).toBe(localBefore.reputation); // …in both directions
+  });
+
+  it('debits the auto top-up from the plane OWNER, not the local player (ISS-082 × ISS-110)', async () => {
+    const { inst, from, to, km, type } = await setupFlight('chain-owner.db');
+    // Owner B funds the chain: distinct cash + rep so both the debit and the discount are attributable.
+    await inst.db.insert(schema.players).values({ id: 'player-b', provider: 'test', username: 'b', cash: 50_000, reputation: 10 });
+
+    // Depart with exactly the wind-adjusted fuel for EDDF→LEMD → lands empty; LEMD→EHAM needs a top-up.
+    const w = weatherFor(FROM);
+    const f = windBurnFactor(w.windKt, w.windDirDeg, initialBearingDeg(from.lat, from.lon, to.lat, to.lon));
+    const depFuel = requiredFuelFor(type.burnPerKm * f, type.emptyWeightKg, type.maxFuel, km);
+    await inst.db.update(schema.planes)
+      .set({ fuel: depFuel, queue: JSON.stringify(['EHAM']), ownerId: 'player-b' })
+      .where(eq(schema.planes.id, 'plane-starter'));
+
+    const localBefore = (await getPlayer(inst, LOCAL_PLAYER.id));
+    const bBefore = (await getPlayer(inst, 'player-b'));
+    const clock = T0 + travelMs(km, type.speedKmh); // exactly at arrival
+    expect(await deliverPackages(inst, clock)).toBe(1);
+
+    // Expected cost from the SAME helpers the engine uses — computed with B's rep discount.
+    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 wTo = weatherFor(TO);
+    const fNext = windBurnFactor(wTo.windKt, wTo.windDirDeg, initialBearingDeg(to.lat, to.lon, nextP.lat, nextP.lon));
+    const nextRequiredL = requiredFuelFor(
+      type.burnPerKm * fNext,
+      type.emptyWeightKg,
+      type.maxFuel,
+      haversineKm(to.lat, to.lon, nextP.lat, nextP.lon),
+    );
+    const target = Math.min(type.maxFuel, Math.max(landedFuel, nextRequiredL * 1.5));
+    const liters = Math.max(0, target - landedFuel);
+    expect(liters).toBeGreaterThan(0); // the hop genuinely needs more than what's left
+    const rate = repRate(bBefore.reputation, FUEL_DISCOUNT_PER_REP, MAX_FUEL_DISCOUNT);
+    const expectedCost = Math.round(liters * FUEL_PRICE_PER_L * (1 - rate) * 100) / 100;
+
+    const plane = (await inst.db.select().from(schema.planes))[0];
+    expect(plane.status).toBe('flying'); // B's cash funded the chain…
+    expect(plane.destIcao).toBe('EHAM');
+    const bAfter = (await getPlayer(inst, 'player-b'));
+    expect(bAfter.cash).toBeCloseTo(bBefore.cash - expectedCost, 9); // …debited from B…
+    expect((await getPlayer(inst, LOCAL_PLAYER.id)).cash).toBe(localBefore.cash); // …not local
+  });
 });
 
 describe('wear on landed legs (v0.39.0, ISS-069)', () => {
@@ -669,6 +742,32 @@ describe('grounded fleet freezes the world clock (#135)', () => {
     expect(sim.clockMs).toBeGreaterThan(STARTING_CLOCK_MS); // the repair gate is what keeps time moving
   });
 
+  it('N-player fleet: one owner airborne keeps the clock running; all owners grounded freezes it (ISS-113)', async () => {
+    const inst = await freshDb('nplayer-clock.db');
+    // A second player with their own GROUNDED plane — the world now has two owners.
+    await inst.db.insert(schema.players).values({ id: 'player-b', provider: 'test', username: 'b', cash: 1_000, reputation: STARTING_REPUTATION });
+    await inst.db.insert(schema.planes).values({
+      id: 'plane-b', ownerId: 'player-b', model: 'atr72', status: 'available', fuel: 100, maxFuel: PLANE_TYPES.atr72.maxFuel,
+      locationIcao: 'EDDF', destIcao: null, lat: 50.03, lon: 8.57, departureSimTime: null,
+    });
+
+    // A (local) takes off while B stays grounded → the world advances — one owner flying is enough…
+    await makeWorldActive(inst);
+    vi.setSystemTime(T0 + 1_000);
+    const sim = await tickOnce(inst);
+    expect(sim.clockMs).toBe(STARTING_CLOCK_MS + 1_000 * WORLD_TIME_SCALE); // …at the fixed world rate
+
+    // …and grounding A's plane (B was already grounded) freezes the whole world.
+    await inst.db.update(schema.planes)
+      .set({ status: 'available', destIcao: null, departureSimTime: null })
+      .where(eq(schema.planes.id, 'plane-starter'));
+    vi.setSystemTime(T0 + 2_000); // a full second of real idleness with every owner grounded
+    const frozen = await tickOnce(inst);
+
+    expect(frozen.clockMs).toBe(STARTING_CLOCK_MS + 1_000 * WORLD_TIME_SCALE); // frozen — no advance…
+    expect(frozen.lastRealTickMs).toBe(T0 + 2_000); // …but the real-time anchor keeps tracking
+  });
+
   it('a frozen tick still refills the pool so a grounded fleet never starves (#135 follow-up)', async () => {
     const inst = await freshDb('frozen-topup.db'); // seeded starter is on the ground → frozen
     // Drain the open market the way wall-clock expiry would (removal paths run while frozen).
@@ -782,7 +881,7 @@ describe('spawnPoolPackages (v0.65.0 per-airport pools)', () => {
       .set({ status: 'flying', destIcao: 'LEMD', departureSimTime: T0, queue: JSON.stringify(['EHAM']) })
       .where(eq(schema.planes.id, 'plane-starter'));
     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-2', ownerId: 'local', model: 'atr72', status: 'available', fuel: 100, maxFuel: 6300, locationIcao: 'LEMD', destIcao: null, lat: 40.4, lon: -3.6, departureSimTime: null,
     });
 
     const n = await spawnPoolPackages(inst, T0 + 5_000, mulberry32(7), T0);
@@ -827,7 +926,7 @@ describe('spawnPoolPackages (v0.65.0 per-airport pools)', () => {
     // 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,
+      id: 'p-air', ownerId: 'local', 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
@@ -838,6 +937,73 @@ describe('spawnPoolPackages (v0.65.0 per-airport pools)', () => {
     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);
   });
+
+  // v1.5.0 (ISS-111): shared-world spawn quality — MAX reputation across players. Independent
+  // recomputation of a spawned package's reward at a given reputation, from the stored row with the
+  // same formula generatePackage uses (rewardFor × rep bonus × special multiplier) — checks the rule
+  // against the math, not against itself.
+  async function expectedRewardAt(p: schema.PackageRow, reputation: number): Promise<number> {
+    const fc = await loadAirportsGeoJson();
+    const o = fc.features.find((f) => f.properties.icao === p.originIcao)!;
+    const d = fc.features.find((f) => f.properties.icao === p.destIcao)!;
+    const km = haversineKm(o.properties.lat, o.properties.lon, d.properties.lat, d.properties.lon);
+    return Math.round(
+      rewardFor(km, p.weightKg) * (1 + repRate(reputation, JOB_BONUS_PER_REP, MAX_JOB_BONUS)) * (p.special ? SPECIALS[p.special]?.rewardMultiplier ?? 1 : 1),
+    );
+  }
+
+  it('scales job quality by the MAX reputation across players, not the local row (v1.5.0, ISS-111)', async () => {
+    const inst = await freshDb('pool-shared-rep.db');
+    // Local sits at the starting rep (×1 bonus); player-b is far ahead — the shared-world rule must pick b's.
+    await inst.db.insert(schema.players).values({ id: 'player-b', provider: 'test', username: 'b', cash: 1_000, reputation: 60 });
+    for (const p of await inst.db.select().from(schema.packages)) {
+      await inst.db.delete(schema.packages).where(eq(schema.packages.id, p.id));
+    }
+
+    expect(await spawnPoolPackages(inst, T0 + 5_000, mulberry32(7), T0)).toBe(POOL_TARGET_PER_AIRPORT);
+
+    const openRows = (await inst.db.select().from(schema.packages)).filter((p) => p.status === 'open');
+    expect(openRows.length).toBe(POOL_TARGET_PER_AIRPORT);
+    for (const p of openRows) {
+      expect(p.reward).toBe(await expectedRewardAt(p, 60)); // every job scaled to the MAX…
+      expect(p.reward).not.toBe(await expectedRewardAt(p, STARTING_REPUTATION)); // …not to local's starting rep
+    }
+  });
+
+  it('MAX picks the local row when local leads — symmetric to the player-b case (v1.5.0)', async () => {
+    const inst = await freshDb('pool-shared-rep-local.db');
+    // Local is far ahead of b's starting rep — a "prefer non-local" implementation would pick b and fail here.
+    await updateLocalPlayerEconomy(inst, { reputation: 60 });
+    await inst.db.insert(schema.players).values({ id: 'player-b', provider: 'test', username: 'b', cash: 1_000, reputation: STARTING_REPUTATION });
+    for (const p of await inst.db.select().from(schema.packages)) {
+      await inst.db.delete(schema.packages).where(eq(schema.packages.id, p.id));
+    }
+
+    expect(await spawnPoolPackages(inst, T0 + 5_000, mulberry32(7), T0)).toBe(POOL_TARGET_PER_AIRPORT);
+
+    const openRows = (await inst.db.select().from(schema.packages)).filter((p) => p.status === 'open');
+    for (const p of openRows) {
+      expect(p.reward).toBe(await expectedRewardAt(p, 60)); // every job scaled to the MAX…
+      expect(p.reward).not.toBe(await expectedRewardAt(p, STARTING_REPUTATION)); // …not to b's starting rep
+    }
+  });
+
+  it("single player: spawn quality is that player's own reputation (v1.5.0 regression guard)", async () => {
+    const inst = await freshDb('pool-single-rep.db');
+    // Raise the only player's rep so the bonus is non-trivial, then respawn from zero with a fixed RNG —
+    // with one row, MAX equals that row: identical to the pre-v1.5.0 singleton read.
+    await updateLocalPlayerEconomy(inst, { reputation: 60 });
+    for (const p of await inst.db.select().from(schema.packages)) {
+      await inst.db.delete(schema.packages).where(eq(schema.packages.id, p.id));
+    }
+
+    expect(await spawnPoolPackages(inst, T0 + 5_000, mulberry32(7), T0)).toBe(POOL_TARGET_PER_AIRPORT);
+
+    const openRows = (await inst.db.select().from(schema.packages)).filter((p) => p.status === 'open');
+    for (const p of openRows) {
+      expect(p.reward).toBe(await expectedRewardAt(p, 60));
+    }
+  });
 });
 
 // Local helper mirroring lib/sim/movement.ts (kept private there on purpose — the

lib/sim/engine.ts

@@ -1,6 +1,7 @@
 import { randomInt, randomUUID } from 'node:crypto';
 import { eq, sql } from 'drizzle-orm';
 import { getGameDb, persist, type GameDb } from '@/lib/db/client';
+import { getSharedWorldReputation, getPlayer, updatePlayerEconomy } from '@/lib/db/localPlayer';
 import * as schema from '@/lib/db/schema';
 import { loadAirportsGeoJson } from '@/lib/airports';
 import { haversineKm, initialBearingDeg } from '@/lib/geo';
@@ -8,7 +9,7 @@ import { weatherFor } from '@/lib/weather';
 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 { getStateSnapshot, parseIcaoQueue, poolAirports, sseFrame } from '@/lib/game/state';
-import { broadcast } from '@/lib/sse';
+import { broadcast, subscribedPlayerIds } from '@/lib/sse';
 
 import {
   JOB_LIFETIME_MS,
@@ -250,13 +251,13 @@ export async function deliverPackages(inst: GameDb, clockMs: number): Promise<nu
     for (const pk of onBoard) {
       if (pk.status === 'loaded' && clockMs <= pk.deadlineSimTime) {
         await inst.db.update(schema.packages).set({ status: 'delivered' }).where(eq(schema.packages.id, pk.id));
-        // Fresh account read per award so multiple deliveries in one tick all count.
+        // v1.3.0 (ISS-110): the award goes to the DELIVERED PLANE'S OWNER — fresh read per award so
-        const fresh = (await inst.db.select().from(schema.account))[0];
+        // multiple deliveries in one tick all count.
-        if (!fresh) throw new Error('account row missing');
+        const fresh = await getPlayer(inst, p.ownerId);
         // v0.37.0 (ISS-073): special packages add the registry's flat rep bonus on top of the
         // distance-based gain — same double-rounding convention as before (gain rounded to cents, total re-rounded).
         const repBonus = pk.special ? SPECIALS[pk.special]?.repBonus ?? 0 : 0;
-        await inst.db.update(schema.account).set({
+        await updatePlayerEconomy(inst, p.ownerId, {
           cash: fresh.cash + pk.reward,
           reputation: Math.round((fresh.reputation + reputationGainFor(distanceKm) + repBonus) * 100) / 100,
         });
@@ -306,15 +307,15 @@ export async function deliverPackages(inst: GameDb, clockMs: number): Promise<nu
             // ISS-082: auto top-up — same target/price terms as flyPlane's dispatch refuel.
             const target = Math.min(type.maxFuel, Math.max(landedFuel, nextRequiredL * 1.5));
             const liters = Math.max(0, target - landedFuel);
-            // Fresh account read (same pattern as the delivery awards above) so a top-up in this tick sees current cash.
+            // v1.3.0 (ISS-110): the PLANE OWNER's economy pays — fresh read (same pattern as the
-            const fresh = (await inst.db.select().from(schema.account))[0];
+            // delivery awards above) so a top-up in this tick sees current cash.
-            if (!fresh) throw new Error('account row missing');
+            const fresh = await getPlayer(inst, p.ownerId);
             const cost = Math.round(liters * FUEL_PRICE_PER_L * (1 - repRate(fresh.reputation, FUEL_DISCOUNT_PER_REP, MAX_FUEL_DISCOUNT)) * 100) / 100;
             if (cost === 0 || fresh.cash >= cost) {
               queue.shift();
               chainedTo = nextDest;
               topUpFuel = target;
-              if (cost > 0) await inst.db.update(schema.account).set({ cash: Math.round((fresh.cash - cost) * 100) / 100 });
+              if (cost > 0) await updatePlayerEconomy(inst, p.ownerId, { cash: Math.round((fresh.cash - cost) * 100) / 100 });
             }
           }
         }
@@ -383,9 +384,11 @@ export async function spawnPoolPackages(
     lon: f.properties.lon,
   }));
   const rand = rng ?? mulberry32(randomInt(0, 2 ** 31));
-  // v0.38.0 (ISS-072): spawned jobs carry the account's CURRENT reputation quality — read once per spawn batch.
+  // v0.38.0 (ISS-072): spawned jobs carry a reputation-based job quality — read once per spawn batch.
-  const account = (await inst.db.select().from(schema.account))[0];
+  // v1.5.0 (ISS-111), the #101 decision point: pools are SHARED world state, so quality follows the
-  if (!account) throw new Error('account row missing');
+  // agreed shared-world rule — MAX reputation across all players — and scales to the best-progressed
+  // player instead of the seeded local row.
+  const reputation = await getSharedWorldReputation(inst);
 
   let n = 0;
   for (const originIcao of pool) {
@@ -415,7 +418,7 @@ export async function spawnPoolPackages(
             clockMs,
             id: randomUUID(),
             createdRealMs: real,
-            reputation: account.reputation,
+            reputation,
           }),
         );
         openByBand[bandIdx]++;
@@ -433,12 +436,21 @@ export async function spawnPoolPackages(
 // 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.
+// v1.4.0 (ISS-112): per-player frames — the tick projects ONE snapshot per connected session's
+// player id (subscribedPlayerIds; N is tiny) and fans each frame out to that player's group only,
+// so every client sees its own account row in every push. Same shared projection as GET /api/state
+// (getStateSnapshot + sseFrame), so pushed frames can never drift from polled ones. A session whose
+// players row vanished mid-stream is skipped per-tick with a log — the others keep flowing.
 async function broadcastState(): Promise<void> {
+  const frames = new Map<string, string>();
+  for (const playerId of subscribedPlayerIds()) {
     try {
-    broadcast(JSON.stringify(sseFrame(await getStateSnapshot())));
+      frames.set(playerId, JSON.stringify(sseFrame(await getStateSnapshot(playerId))));
     } catch (err) {
       console.error('flight: state broadcast failed', err);
     }
+  }
+  if (frames.size > 0) broadcast(frames);
 }
 
 export function tickNow(): Promise<schema.SimStateRow> {

lib/sse.test.ts

@@ -1,45 +1,65 @@
 import { describe, expect, it } from 'vitest';
-import { broadcast, subscribe } from './sse';
+import { broadcast, subscribedPlayerIds, subscribe } from './sse';
 
-// ISS-129 (v0.57.0): the fan-out registry behind /api/events — plain Set semantics, so no DB or
+// ISS-129 (v0.57.0): the fan-out registry behind /api/events — no DB or server needed. Subscribers
-// server needed. Subscribers leak across tests in this file (module-level state), which is fine:
+// leak across tests in this file (module-level state), which is fine: each test asserts on its own
-// each test only asserts on its own arrays.
+// arrays and uses distinct player ids where isolation matters. v1.4.0 (ISS-112): keyed by PLAYER ID
+// — a frame for one player must never reach another player's streams.
 
 describe('lib/sse', () => {
-  it('delivers broadcasts to subscribers and stops after unsubscribe', () => {
+  it('delivers broadcasts to subscribers of the SAME player only, and stops after unsubscribe', () => {
     const a: string[] = [];
-    const b: string[] = [];
+    const b: string[] = []; // same player as a — both get its frames
-    const unsubA = subscribe((t) => a.push(t));
+    const c: string[] = []; // different player — never sees their frames
-    const unsubB = subscribe((t) => b.push(t));
+    const unsubA = subscribe('p-a', (t) => a.push(t));
+    const unsubB = subscribe('p-a', (t) => b.push(t));
+    const unsubC = subscribe('p-c', (t) => c.push(t));
 
-    broadcast('x');
+    broadcast(new Map([['p-a', 'x']]));
     expect(a).toEqual(['x']);
-    expect(b).toEqual(['x']);
+    expect(b).toEqual(['x']); // same group
+    expect(c).toEqual([]); // other player's frame never crosses over
 
     unsubA();
-    broadcast('y');
+    broadcast(new Map([['p-a', 'y'], ['p-c', 'z']]));
     expect(a).toEqual(['x']); // unsubscribed — no more events
     expect(b).toEqual(['x', 'y']);
+    expect(c).toEqual(['z']);
     unsubB();
+    unsubC();
   });
 
-  it('a throwing subscriber does not break the others', () => {
+  it('subscribedPlayerIds lists exactly the players with live streams, dropping empty groups', () => {
     const got: string[] = [];
-    subscribe(() => {
+    const unsub1 = subscribe('p-ids-1', (t) => got.push(t));
+    const unsub2 = subscribe('p-ids-1', (t) => got.push(t)); // second member of the same group
+    const unsub3 = subscribe('p-ids-2', (t) => got.push(t));
+    expect(subscribedPlayerIds().sort()).toEqual(['p-ids-1', 'p-ids-2']);
+
+    unsub1(); // p-ids-1 still has one member — id stays listed
+    expect(subscribedPlayerIds().sort()).toEqual(['p-ids-1', 'p-ids-2']);
+    unsub3(); // p-ids-2's last stream goes → its projections stop
+    expect(subscribedPlayerIds()).toEqual(['p-ids-1']);
+    unsub2();
+  });
+
+  it('a throwing subscriber does not break the others in its group', () => {
+    const got: string[] = [];
+    subscribe('p-boom', () => {
       throw new Error('boom');
     });
-    const unsub = subscribe((t) => got.push(t));
+    const unsub = subscribe('p-boom', (t) => got.push(t));
-    broadcast('z');
+    broadcast(new Map([['p-boom', 'z']]));
     expect(got).toEqual(['z']);
     unsub();
   });
 
-  it('unsubscribe is idempotent', () => {
+  it('unsubscribe is idempotent and broadcasting to an unknown player is a no-op', () => {
     const got: string[] = [];
-    const unsub = subscribe((t) => got.push(t));
+    const unsub = subscribe('p-idem', (t) => got.push(t));
     unsub();
     unsub(); // second call must not throw
-    broadcast('w');
+    broadcast(new Map([['nobody-subscribed-here', 'w']])); // no group → dropped, no throw
     expect(got).toEqual([]);
   });
 });

lib/sse.ts

@@ -1,29 +1,50 @@
 // 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
+// sim state alive) — no new dependencies, no WS upgrade needed. The Map 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.
+// give each its own empty map and no push would ever be delivered. v1.4.0 (ISS-112): subscribers are
+// keyed by PLAYER ID — the engine projects one snapshot per connected player and pushes each frame
+// only to that player's group, so every client sees its own account row in every pushed frame.
 
 type Push = (text: string) => void;
 
-const g = globalThis as unknown as { __flightSseSubscribers?: Set<Push> };
+const g = globalThis as unknown as { __flightSseSubscribersByPlayer?: Map<string, Set<Push>> };
-const subscribers: Set<Push> = (g.__flightSseSubscribers ??= new Set());
+const subscribers: Map<string, Set<Push>> = (g.__flightSseSubscribersByPlayer ??= new Map());
 
-export function subscribe(fn: Push): () => void {
+export function subscribe(playerId: string, fn: Push): () => void {
-  subscribers.add(fn);
+  let group = subscribers.get(playerId);
+  if (!group) {
+    group = new Set();
+    subscribers.set(playerId, group);
+  }
+  group.add(fn);
   return () => {
-    subscribers.delete(fn);
+    const s = subscribers.get(playerId);
+    if (!s) return; // already unsubscribed — idempotent
+    s.delete(fn);
+    if (s.size === 0) subscribers.delete(playerId); // drop the empty group so projections stop for it
   };
 }
 
-// Call each subscriber safely — one dead stream must not take the others down.
+// v1.4.0 (ISS-112): which player ids currently have at least one connected stream — the engine
-export function broadcast(text: string): void {
+// projects exactly these per tick (N is tiny; a projection is skipped when nobody listens).
-  for (const fn of [...subscribers]) {
+export function subscribedPlayerIds(): string[] {
+  return [...subscribers.keys()];
+}
+
+// Call each subscriber safely — one dead stream must not take the others down. `frames` maps
+// player id → pre-serialized frame text (the engine projects per player, this only fans out).
+export function broadcast(frames: Map<string, string>): void {
+  for (const [playerId, text] of frames) {
+    const group = subscribers.get(playerId);
+    if (!group) continue; // unsubscribed between projection and push — fine
+    for (const fn of [...group]) {
       try {
         fn(text);
       } catch {
         // subscriber's stream is gone; its own cleanup unsubscribes it
       }
     }
+  }
 }

lib/useGameAction.ts

@@ -2,6 +2,7 @@
 
 import { useCallback, useEffect, useState } from 'react';
 import type { StateSnapshot } from '@/lib/game/state';
+import { sessionHeaders } from './authClient';
 
 // ISS-021 (v0.20.0) — shared action runner for the side panes (extracted verbatim from
 // RightPane.runAction when the On board section moved to LeftPane). POSTs an action endpoint;
@@ -30,7 +31,8 @@ export function useGameAction(
       try {
         const res = await fetch(path, {
           method: 'POST',
-          headers: { 'Content-Type': 'application/json' },
+          // v1.1.0 (ISS-107): action endpoints are session-guarded — echo the stored id.
+          headers: { 'Content-Type': 'application/json', ...sessionHeaders() },
           body: body === undefined ? undefined : JSON.stringify(body),
           cache: 'no-store',
         });

lib/useGameState.test.ts

@@ -22,7 +22,19 @@ describe('fetchState', () => {
 
     await expect(fetchState()).resolves.toEqual(SNAPSHOT);
     expect(fetchMock).toHaveBeenCalledTimes(1);
-    expect(fetchMock).toHaveBeenCalledWith('/api/state', { cache: 'no-store' });
+    // No stored session in node → empty headers object (v1.1.0, ISS-107).
+    expect(fetchMock).toHaveBeenCalledWith('/api/state', { cache: 'no-store', headers: {} });
+  });
+
+  it('sends the stored session as X-Flight-Session when one exists (v1.1.0)', async () => {
+    vi.stubGlobal('window', {
+      localStorage: { getItem: (k: string) => (k === 'flight.session' ? 'sid-123' : null), removeItem: () => {} },
+    });
+    const fetchMock = vi.fn(async () => ({ ok: true, status: 200, json: async () => SNAPSHOT }));
+    vi.stubGlobal('fetch', fetchMock);
+
+    await fetchState();
+    expect(fetchMock).toHaveBeenCalledWith('/api/state', { cache: 'no-store', headers: { 'X-Flight-Session': 'sid-123' } });
   });
 
   it('throws with the HTTP status on a non-2xx response', async () => {

lib/useGameState.ts

@@ -2,6 +2,7 @@
 
 import { useCallback, useEffect, useRef, useState } from 'react';
 import type { StateSnapshot } from './game/state';
+import { sessionHeaders, storedSession } from './authClient';
 
 export interface GameStateResult {
   state: StateSnapshot | null;
@@ -19,7 +20,8 @@ export interface GameStateResult {
 
 // Single fetch of the full game-state snapshot. Exported separately from the hook so it can be unit-tested with a mocked fetch.
 export async function fetchState(): Promise<StateSnapshot> {
-  const res = await fetch('/api/state', { cache: 'no-store' });
+  // v1.1.0 (ISS-107): /api/state is session-guarded — the stored id rides along as X-Flight-Session.
+  const res = await fetch('/api/state', { cache: 'no-store', headers: sessionHeaders() });
   if (!res.ok) throw new Error(`GET /api/state → HTTP ${res.status}`);
   const snapshot = (await res.json()) as StateSnapshot;
   // Dev/e2e hook (v0.15.0): the last successfully polled snapshot, so tests can compare what
@@ -93,7 +95,10 @@ export function useGameState(intervalMs = 1000): GameStateResult {
 
     let source: EventSource | null = null;
     try {
-      source = new EventSource(SSE_URL);
+      // v1.1.0 (ISS-107): EventSource cannot set custom headers, so the session id rides along as a
+      // query param — /api/events accepts ?session= exactly for this (requireAuthSse).
+      const sid = storedSession();
+      source = new EventSource(sid ? `${SSE_URL}?session=${encodeURIComponent(sid)}` : SSE_URL);
     } catch {
       source = null; // no EventSource support — pure polling below
     }

package.json

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