Merge pull request 'v1.3.0: per-player money & reputation in engine + actions (ISS-110)' (#154) from feat/multiplayer-per-player-economy into master

CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## 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.

app/api/events/route.test.ts

@@ -2,9 +2,12 @@ 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 } from '@/lib/auth';
+import { getGameDb } from '@/lib/db/client';
 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 +15,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 +25,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');

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,19 @@ 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).
 
 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,8 +30,10 @@ 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.3.0 (ISS-110): the connect
-      getStateSnapshot()
+      // frame carries THIS session's account row; later pushes come from the shared broadcast
+      // (local player) until per-player frames land (#112).
+      getStateSnapshot(auth.player.id)
         .then((snapshot) => {
           unsubscribe = subscribe((text) => {
             try {

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

@@ -4,16 +4,20 @@ import path from 'node:path';
 import { afterAll, beforeAll, describe, expect, it } from 'vitest';
 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 () => {

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

@@ -6,16 +6,20 @@ 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 () => {
@@ -23,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 () => {
@@ -49,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'));

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

@@ -6,15 +6,19 @@ 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 () => {
@@ -22,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

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 () => {

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 () => {

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

@@ -5,9 +5,13 @@ import { afterAll, beforeAll, describe, expect, it } from 'vitest';
 import { loadAirportsGeoJson } from '@/lib/airports';
 import { haversineKm } from '@/lib/geo';
 import { FUEL_PRICE_PER_L, PLANE_TYPES, SELL_FRACTION } from '@/lib/game/catalog';
+import { 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 +19,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 +34,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');
 
@@ -75,13 +85,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 +114,23 @@ 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
+  });
 });

app/api/state/route.ts

@@ -1,12 +1,18 @@
+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. The snapshot shape is
+// unchanged; per-player snapshots are a later step (#112).
+// v1.3.0 (ISS-110): `account` carries the SESSION player's economy row.
+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 { getLocalPlayer, updateLocalPlayerEconomy } from '@/lib/db/localPlayer';
+import { LOCAL_PLAYER, getLocalPlayer, updateLocalPlayerEconomy } from '@/lib/db/localPlayer';
 import { getStateSnapshot } from '@/lib/game/state';
 import { tickNow } from '@/lib/sim/engine';
 
@@ -46,10 +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)
+    // v1.3.0 (ISS-110): admin-style hook — no session, grants to the SEEDED local account (the
+    // player the e2e suite plays via mint-player-session's default).
     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/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 { getLocalPlayer, updateLocalPlayerEconomy } from '@/lib/db/localPlayer';
+import { LOCAL_PLAYER, getLocalPlayer, updateLocalPlayerEconomy } from '@/lib/db/localPlayer';
 import { getStateSnapshot } from '@/lib/game/state';
 import { tickNow } from '@/lib/sim/engine';
 
@@ -42,10 +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)
+    // v1.3.0 (ISS-110): admin-style hook — no session, stages the SEEDED local account (the player
+    // the e2e suite plays via mint-player-session's default).
     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

@@ -727,3 +727,74 @@ body {
 .admin-row-actions {
   white-space: nowrap;
 }
+
+/* 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,50 @@ 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);
+
+  useEffect(() => {
+    const sid = storedSession();
+    if (!sid) {
+      setAuthed(false);
+      return;
+    }
+    let cancelled = false;
+    fetch('/api/me', { headers: sessionHeaders(sid), cache: 'no-store' })
+      .then((res) => {
+        if (cancelled) return;
+        if (!res.ok) clearStoredSession(); // stale/expired id — drop it and show sign-in
+        setAuthed(res.ok);
+      })
+      .catch(() => {
+        if (!cancelled) setAuthed(false); // network error → let the user try to sign in
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, []);
+
+  if (authed === null) {
+    return (
+      <div className="app-shell">
+        <p data-testid="auth-checking" className="sign-in-loading">
+          Loading…
+        </p>
+      </div>
+    );
+  }
+  if (!authed) {
+    return <SignInScreen onAuthed={() => setAuthed(true)} />;
+  }
+
+  // The admin panel's Log out cleared the session — drop back to sign-in (ISS-107).
+  return <AppShell onLogout={() => setAuthed(false)} />;
+}
+
+function AppShell({ onLogout }: { onLogout: () => void }) {
   // 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 +95,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} />
       <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/Map.tsx

@@ -13,6 +13,7 @@ import { weatherFor } from '../lib/weather';
 import { approxLocalTime } from '../lib/localTime';
 import Modal from './Modal';
 import AdminPanel from './AdminPanel';
+import { 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 +70,14 @@ 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;
 }
 
 // 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 }: 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
@@ -295,7 +299,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',
               });
@@ -591,7 +596,7 @@ export default function FlightMap({ state, hovered, applySnapshot }: MapProps) {
       </header>
       <div ref={containerRef} data-testid="map" className="map-container" />
       <Modal open={adminOpen} onClose={() => setAdminOpen(false)} title="Admin">
-        <AdminPanel />
+        <AdminPanel onLogout={onLogout} />
       </Modal>
     </div>
   );

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>
+  );
+}

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

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,31 @@
+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
+
+export async function mintPlayerSession(page: Page): Promise<string> {
+  const res = await page.request.post('/api/test/mint-player-session');
+  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

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

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.

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

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)

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

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,6 +2,7 @@ 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_CASH, STARTING_CLOCK_MS, STARTING_REPUTATION } from '@/lib/game/seed';
@@ -88,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 () => {
@@ -350,4 +385,32 @@ describe('openGameDb', () => {
     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

@@ -23,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,
@@ -159,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
@@ -267,7 +276,8 @@ 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);
   // 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 });

lib/db/localPlayer.ts

@@ -2,10 +2,10 @@ import { eq } from 'drizzle-orm';
 import type { GameDb } from './client';
 import * as schema from './schema';
 
-// v1.0.0 (ISS-105): TEMPORARY single-player economy access — resolves the local player row so all
+// v1.0.0 (ISS-105): single-player economy access — resolves the seeded local player row. As of
-// pre-multiplayer code keeps working while `account` is replaced by `players`. A later step
+// v1.3.0 (ISS-110) every per-player read/write goes through getPlayer/updatePlayerEconomy below;
-// parameterizes these by playerId for real multiplayer; until then every read/write of the
+// these 'local' helpers remain ONLY for world-level reads with no acting session (the engine's
-// singleton economy goes through this file and nowhere else.
+// shared-pool spawn quality, the SSE broadcast account) and env-gated /api/test/* admin hooks.
 
 export const LOCAL_PLAYER = { id: 'local', provider: 'local', username: 'kamilkrzywda' } as const;
 
@@ -21,3 +21,20 @@ export async function updateLocalPlayerEconomy(
 ): 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));
+}

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'.

lib/game/actions.test.ts

@@ -5,7 +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 { getLocalPlayer, updateLocalPlayerEconomy } from '@/lib/db/localPlayer';
+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';
@@ -22,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,
@@ -94,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');
@@ -107,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 () => {
@@ -129,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 () => {
@@ -137,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 () => {
@@ -149,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 () => {
@@ -160,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);
   });
 });
 
@@ -168,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');
@@ -188,17 +188,17 @@ 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 () => {
@@ -207,7 +207,7 @@ describe('flyPlane', () => {
     await inst.db.update(schema.planes).set({ health: 0 }).where(eq(schema.planes.id, 'plane-starter'));
     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…
@@ -219,7 +219,7 @@ describe('flyPlane', () => {
     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');
@@ -253,7 +253,7 @@ describe('flyPlane', () => {
     await updateLocalPlayerEconomy(inst, { reputation: 30 });
     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
@@ -274,7 +274,7 @@ describe('flyPlane', () => {
     expect(required * 1.5).toBeLessThan(PLANE_TYPES.atr72.maxFuel); // sanity: the target stays below a full tank
     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');
@@ -289,7 +289,7 @@ describe('flyPlane', () => {
     await inst.db.update(schema.planes).set({ fuel: startFuel }).where(eq(schema.planes.id, 'plane-starter'));
     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…
@@ -301,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');
@@ -321,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');
@@ -337,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
   });
@@ -352,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…
@@ -362,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
@@ -386,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
@@ -394,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']);
@@ -405,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']);
@@ -417,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);
   });
 });
 
@@ -442,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'));
@@ -454,7 +454,7 @@ describe('abandonPackage', () => {
     const inst = await setupLoaded('ab-start.db');
     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];
@@ -468,7 +468,7 @@ describe('abandonPackage', () => {
     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);
   });
@@ -481,7 +481,7 @@ 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);
     }
   });
@@ -490,7 +490,7 @@ describe('abandonPackage', () => {
     const inst = await setupLoaded('ab-expired.db', 'expired');
     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 getLocalPlayer(inst)).cash).toBe(cashBefore);
@@ -502,7 +502,7 @@ describe('abandonPackage', () => {
     const inst = await setupLoaded('ab-floor.db');
     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 getLocalPlayer(inst)).cash).toBe(0);
@@ -514,19 +514,19 @@ 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);
   });
 });
 
@@ -536,7 +536,7 @@ describe('buyPlane', () => {
     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 player = await getLocalPlayer(inst);
     expect(player.cash).toBe(500_000 - PLANE_TYPES.atr72.price);
@@ -557,12 +557,12 @@ 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 () => {
@@ -571,7 +571,7 @@ describe('buyPlane', () => {
     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
@@ -587,14 +587,14 @@ describe('buyPlane', () => {
     // rep 30 → discounted cost 160k: 170k is enough now, though it was not before v0.38.0.
     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 player = await getLocalPlayer(inst);
     expect(player.cash).toBeCloseTo(170_000 - 160_000, 6);
 
     const inst2 = await freshDb('buy-boundary-poor.db'); // just below the discounted cost
     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);
   });
 });
 
@@ -603,12 +603,12 @@ 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 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 player = await getLocalPlayer(inst);
@@ -621,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
   });
@@ -644,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);
   });
 });
 
@@ -671,7 +671,7 @@ describe('repairPlane (v0.39.0, ISS-069; gradual since v0.45.0, ISS-089)', () =>
     await inst.db.update(schema.planes).set({ health: 42 }).where(eq(schema.planes.id, 'plane-starter'));
     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];
@@ -686,7 +686,7 @@ describe('repairPlane (v0.39.0, ISS-069; gradual since v0.45.0, ISS-089)', () =>
     const inst = await freshDb('repair-full.db'); // seeded starter at 100
     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];
@@ -702,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 () => {
@@ -711,23 +711,23 @@ 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 () => {
@@ -735,11 +735,92 @@ describe('repairPlane (v0.39.0, ISS-069; gradual since v0.45.0, ISS-089)', () =>
     await inst.db.update(schema.planes).set({ health: 50 }).where(eq(schema.planes.id, 'plane-starter'));
     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,7 +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 { getLocalPlayer, updateLocalPlayerEconomy } from '@/lib/db/localPlayer';
+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';
@@ -34,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 {
@@ -53,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)),
@@ -71,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`);
   }
@@ -110,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`);
   }
@@ -141,7 +150,8 @@ 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 player = await getLocalPlayer(inst);
+  // v1.2.0 (ISS-109): the acting player's own economy pays for the top-up (they own the plane).
+  const player = await getPlayer(inst, playerId);
   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 && player.cash < cost) {
     throw new GameActionError(409, `insufficient funds: refueling costs ${cost}, you have ${Math.round(player.cash)}`);
@@ -173,7 +183,7 @@ export async function flyPlane(inst: GameDb, planeId: string, destIcao: string):
     })
     .where(eq(schema.planes.id, planeId));
   if (cost > 0) {
-    await updateLocalPlayerEconomy(inst, { cash: Math.round((player.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,8 +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 player = await getLocalPlayer(inst);
+  // v1.2.0 (ISS-109): the acting player's own economy pays the penalty.
-  await updateLocalPlayerEconomy(inst, { cash: Math.max(0, Math.round((player.cash - penalty) * 100) / 100) });
+  const player = await getPlayer(inst, playerId);
+  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 };
@@ -267,11 +281,12 @@ 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 player = await getLocalPlayer(inst);
+  // v1.2.0 (ISS-109): the buyer's own economy pays and becomes the owner of the delivered plane.
+  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(player.reputation, PLANE_DISCOUNT_PER_REP, MAX_PLANE_DISCOUNT)) * 100) / 100;
   if (player.cash < cost) {
@@ -285,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
@@ -296,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 updateLocalPlayerEconomy(inst, { cash: Math.round((player.cash - cost) * 100) / 100 });
+  await updatePlayerEconomy(inst, playerId, { cash: Math.round((player.cash - cost) * 100) / 100 });
   await persist(inst);
   return { planeId };
 }
@@ -305,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`);
   }
@@ -327,16 +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 player = await getLocalPlayer(inst);
+  const player = await getPlayer(inst, playerId);
-  await updateLocalPlayerEconomy(inst, { cash: Math.round((player.cash + payout) * 100) / 100 });
+  await updatePlayerEconomy(inst, playerId, { cash: Math.round((player.cash + payout) * 100) / 100 });
   await persist(inst);
   return { payout };
 }
@@ -349,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`);
   }
@@ -361,7 +381,8 @@ 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 player = await getLocalPlayer(inst);
+  // v1.2.0 (ISS-109): the owner's own economy pays for the repair.
+  const player = await getPlayer(inst, playerId);
   if (player.cash < REPAIR_COST) {
     throw new GameActionError(409, `insufficient funds: repair costs ${REPAIR_COST}, you have ${Math.round(player.cash)}`);
   }
@@ -370,7 +391,7 @@ export async function repairPlane(inst: GameDb, planeId: string): Promise<{ cost
   await inst.db.update(schema.planes)
     .set({ status: 'repairing', repairUntilSimTime: sim.clockMs + REPAIR_DURATION_MS })
     .where(eq(schema.planes.id, planeId));
-  await updateLocalPlayerEconomy(inst, { cash: Math.round((player.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 };
 }
@@ -381,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.ts

@@ -2,7 +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 { getLocalPlayer } from '@/lib/db/localPlayer';
+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';
@@ -114,16 +114,17 @@ 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
+// shape as before ({cash, reputation}), sourced per-player. Callers without a session context
+// (the shared SSE broadcast) pass LOCAL_PLAYER.id until per-player frames land (#112).
+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).
-  // v1.0.0 (ISS-105): the snapshot's `account` field is now the local player row — same shape,
-  // resolved through the temporary single-player helper until multiplayer lands.
   const [player, simRows, planeRows, packageRows] = await Promise.all([
-    getLocalPlayer(inst),
+    getPlayer(inst, playerId),
     db.select().from(schema.simState),
     db.select().from(schema.planes),
     db.select().from(schema.packages),

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',
     ]);
@@ -184,16 +185,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: {
@@ -733,6 +792,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',

lib/sim/engine.test.ts

@@ -5,7 +5,7 @@ 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 { getLocalPlayer, updateLocalPlayerEconomy } from '@/lib/db/localPlayer';
+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';
@@ -497,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)', () => {
@@ -783,7 +855,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);
@@ -828,7 +900,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

lib/sim/engine.ts

@@ -1,7 +1,7 @@
 import { randomInt, randomUUID } from 'node:crypto';
 import { eq, sql } from 'drizzle-orm';
 import { getGameDb, persist, type GameDb } from '@/lib/db/client';
-import { getLocalPlayer, updateLocalPlayerEconomy } from '@/lib/db/localPlayer';
+import { LOCAL_PLAYER, getLocalPlayer, getPlayer, updatePlayerEconomy } from '@/lib/db/localPlayer';
 import * as schema from '@/lib/db/schema';
 import { loadAirportsGeoJson } from '@/lib/airports';
 import { haversineKm, initialBearingDeg } from '@/lib/geo';
@@ -251,12 +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 player 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 getLocalPlayer(inst);
+        // multiple deliveries in one tick all count.
+        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 updateLocalPlayerEconomy(inst, {
+        await updatePlayerEconomy(inst, p.ownerId, {
           cash: fresh.cash + pk.reward,
           reputation: Math.round((fresh.reputation + reputationGainFor(distanceKm) + repBonus) * 100) / 100,
         });
@@ -306,14 +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 player 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 getLocalPlayer(inst);
+            // delivery awards above) so a top-up in this tick sees current cash.
+            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 updateLocalPlayerEconomy(inst, { cash: Math.round((fresh.cash - cost) * 100) / 100 });
+              if (cost > 0) await updatePlayerEconomy(inst, p.ownerId, { cash: Math.round((fresh.cash - cost) * 100) / 100 });
             }
           }
         }
@@ -382,7 +384,10 @@ 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 local player'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.
+  // ponytail: stays on the seeded 'local' row in v1.3.0 (ISS-110) — pools are SHARED world state
+  // (packages have no owner), so there is no single owning player whose rep should set job quality;
+  // per-player job quality / pools is a later multiplayer step (#112).
   const player = await getLocalPlayer(inst);
 
   let n = 0;
@@ -431,9 +436,12 @@ 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.3.0 (ISS-110): the shared broadcast channel has no acting session — it carries the seeded
+// local player's account until per-player SSE frames land (#112). Session-scoped reads (/api/state,
+// /api/events connect frame, action responses) all source their own row.
 async function broadcastState(): Promise<void> {
   try {
-    broadcast(JSON.stringify(sseFrame(await getStateSnapshot())));
+    broadcast(JSON.stringify(sseFrame(await getStateSnapshot(LOCAL_PLAYER.id))));
   } catch (err) {
     console.error('flight: state broadcast failed', err);
   }

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": "1.0.0",
+  "version": "1.3.0",
   "private": true,
   "scripts": {
     "dev": "next dev -p 3000",