ui/phase-11: map wired to live game state

Replaces the Phase 10 map stub with live planet rendering driven by
`user.games.report`, and wires the header turn counter to the same
data. Phase 11's frontend sits on a per-game `GameStateStore` that
lives in `lib/game-state.svelte.ts`: the in-game shell layout
instantiates one per game, exposes it through Svelte context, and
disposes it on remount. The store discovers the game's current turn
through `lobby.my.games.list`, fetches the matching report, and
exposes a TS-friendly snapshot to the header turn counter, the map
view, and the inspector / order / calculator tabs that later phases
will plug onto the same instance.

The pipeline forced one cross-stage decision: the user surface needs
the current turn number to know which report to fetch, but
`GameSummary` did not expose it. Phase 11 extends the lobby
catalogue (FB schema, transcoder, Go model, backend
gameSummaryWire, gateway decoders, openapi, TS bindings,
api/lobby.ts) with `current_turn:int32`. The data was already
tracked in backend's `RuntimeSnapshot.CurrentTurn`; surfacing it is
a wire change only. Two alternatives were rejected: a brand-new
`user.games.state` message (full wire-flow for one field) and
hard-coding `turn=0` (works for the dev sandbox, which never
advances past zero, but renders the initial state for any real
game). The change crosses Phase 8's already-shipped catalogue per
the project's "decisions baked back into the live plan" rule —
existing tests and fixtures are updated in the same patch.

The state binding lives in `map/state-binding.ts::reportToWorld`:
one Point primitive per planet across all four kinds (local /
other / uninhabited / unidentified) with distinct fill colours,
fill alphas, and point radii so the user can tell them apart at a
glance. The planet engine number is reused as the primitive id so
a hit-test result resolves directly to a planet without an extra
lookup table. Zero-planet reports yield a well-formed empty world;
malformed dimensions fall back to 1×1 so a bad report cannot crash
the renderer.

The map view's mount effect creates the renderer once and skips
re-mount on no-op refreshes (same turn, same wrap mode); a turn
change or wrap-mode flip disposes and recreates it. The renderer's
external API does not yet expose `setWorld`; Phase 24 / 34 will
extract it once high-frequency updates land. The store installs a
`visibilitychange` listener that calls `refresh()` when the tab
regains focus.

Wrap-mode preference uses `Cache` namespace `game-prefs`, key
`<gameId>/wrap-mode`, default `torus`. Phase 11 reads through
`store.wrapMode`; Phase 29 wires the toggle UI on top of
`setWrapMode`.

Tests: Vitest unit coverage for `reportToWorld` (every kind,
ids, styling, empty / zero-dimension edges, priority order) and
for the store lifecycle (init success, missing-membership error,
forbidden-result error, `setTurn`, wrap-mode persistence across
instances, `failBootstrap`). Playwright e2e mocks the gateway for
`lobby.my.games.list` and `user.games.report` and asserts the
live data path: turn counter shows the reported turn,
`active-view-map` flips to `data-status="ready"`, and
`data-planet-count` matches the fixture count. The zero-planet
regression and the missing-membership error path are covered.

Phase 11 status stays `pending` in `ui/PLAN.md` until the local-ci
run lands green; flipping to `done` follows in the next commit per
the per-stage CI gate in `CLAUDE.md`.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

ui/PLAN.md

@@ -1165,22 +1165,140 @@ Status: pending.
 Goal: replace the map fixture with real planet data fetched from the
 gateway for the selected game; planets only, read-only.
 
-Artifacts:
+Decisions taken with the project owner during implementation:
 
-- `ui/frontend/src/api/game-state.ts` fetch latest game state via
-  `user.games.report`
-- `ui/frontend/src/map/state-binding.ts` map-state synchroniser
-  applying planets to the renderer
-- `ui/frontend/src/lib/active-view/map.svelte` integrates the renderer
-  with live data and a loading state, defaulting to torus mode and
-  reading the per-game wrap-scrolling preference from `Cache` (toggle
-  itself is exposed in Phase 29)
-- `ui/frontend/src/lib/header/turn-counter.svelte` reads the live
-  turn number from game state
+1. **`current_turn` on `GameSummary`.** The user-facing
+   `lobby.my.games.list` did not expose the runtime's current turn
+   number, but the in-game shell needs it to fetch the matching
+   `user.games.report`. Phase 11 extends `GameSummary` with a new
+   `current_turn:int32` field (FB schema, Go transcoder + model,
+   backend `gameSummaryWire`, gateway `decodeGameSummary*`,
+   `backend/openapi.yaml`, TS bindings, `api/lobby.ts`). The data
+   was already tracked in the runtime projection
+   (`backend/internal/lobby/types.go RuntimeSnapshot.CurrentTurn`);
+   exposing it is purely a wire change. Two alternatives were
+   rejected: a brand-new `user.games.state` message (full wire-flow
+   for a one-field response) and hard-coding `turn=0` (works for the
+   dev sandbox, but renders the initial state for any game past
+   turn zero). The decision crosses Phase 8's already-shipped
+   catalogue per the project's "decisions baked back into the live
+   plan" rule.
+2. **Per-game state store with context.** A `GameStateStore` lives
+   in `lib/game-state.svelte.ts`; the in-game shell layout
+   instantiates one per game and exposes it through Svelte context
+   under `GAME_STATE_CONTEXT_KEY`. Header turn counter, map view,
+   and (in later phases) inspector tabs all consume the same
+   instance. A new instance is created on layout remount (game id
+   change), so each game gets a fresh snapshot.
+3. **Lobby lookup for current turn.** The store does not assume the
+   caller passed `current_turn` through navigation state. On
+   `setGame`, it calls `lobby.my.games.list` itself, finds the game
+   record, reads `current_turn`, and then calls
+   `user.games.report`. A direct deep link to `/games/:id/map` for
+   a game the user is not a member of flips the store to `error`
+   with a `not in your list` message.
+4. **Refresh on tab focus.** The store installs a
+   `visibilitychange` listener that calls `refresh()` when the
+   document becomes visible and the store is `ready`. The map
+   view's mount effect skips a re-render when the new snapshot's
+   turn matches the previously-mounted turn (and the wrap mode is
+   unchanged), so a no-op refresh does not flicker the canvas.
+5. **Wrap-mode preference.** `Cache` namespace `game-prefs`, key
+   `<gameId>/wrap-mode`, values `torus` (default) / `no-wrap`.
+   Phase 11 reads through `wrapMode`; `setWrapMode` writes back.
+   Phase 29 wires the toggle UI on top of these primitives.
+6. **State binding.** `map/state-binding.ts::reportToWorld` emits
+   one Point primitive per planet across all four kinds (local /
+   other / uninhabited / unidentified) with distinct fill colours
+   and point radii. Each primitive's id reuses the engine planet
+   number so a hit-test result resolves directly to a planet
+   without an extra lookup table. Zero-planet reports yield a
+   well-formed empty world; the World constructor's positivity
+   check is guarded by a 1×1 fallback for the malformed-report
+   edge case.
+7. **Renderer remount on snapshot change.** The map view disposes
+   and recreates the renderer when the report's turn changes (and
+   short-circuits when it does not). This is wasteful for the
+   tab-focus refresh path, but the renderer's external
+   `RendererHandle` does not yet expose a `setWorld` API and Phase
+   11's per-game planet count is small enough that the remount
+   cost (a few hundred ms) is acceptable. A future phase that adds
+   high-frequency updates (Phase 24 push events, Phase 34 multi-
+   turn projection overlays) will extract a `replaceWorld` method.
+8. **e2e bootstrap reuses `__galaxyDebug`.** The Phase 10 pattern
+   of seeding the device session through `/__debug/store` carries
+   over; the gateway is mocked through `page.route` for
+   `lobby.my.games.list`, `user.games.report`, and the
+   `SubscribeEvents` stream that the revocation watcher opens
+   (held open indefinitely so a clean end-of-stream does not
+   trigger `signOut("revoked")` and bounce the test back to
+   `/login`).
+
+Artifacts (delivered):
+
+- `ui/frontend/src/api/game-state.ts` — typed wrapper for
+  `user.games.report` plus `uuidToHiLo` and a TS-friendly
+  `GameReport` shape (planets only)
+- `ui/frontend/src/lib/game-state.svelte.ts` — runes-based
+  `GameStateStore` with init / setGame / setTurn / refresh /
+  setWrapMode / failBootstrap / dispose; tab-focus listener;
+  `Cache`-backed wrap-mode persistence
+- `ui/frontend/src/map/state-binding.ts` — `reportToWorld` and the
+  per-kind planet styling
+- `ui/frontend/src/lib/active-view/map.svelte` — replaces the
+  Phase 10 stub with the live renderer integration plus loading /
+  error overlays and a `data-planet-count` testid hook
+- `ui/frontend/src/lib/header/turn-counter.svelte` — reads
+  `store.report.turn` through context, falls back to the static
+  `?` placeholder when the store has not yet produced a snapshot
+- `ui/frontend/src/routes/games/[id]/+layout.svelte` — instantiates
+  the `GameStateStore`, builds the `GalaxyClient`, exposes the
+  store via `setContext`, disposes on unmount
+- `pkg/schema/fbs/lobby.fbs` — `current_turn:int32` field
+- `pkg/schema/fbs/lobby/GameSummary.go` (regenerated)
+- `pkg/transcoder/lobby.go` — encode/decode `current_turn`
+- `pkg/transcoder/lobby_test.go` — non-zero `current_turn` in the
+  round-trip fixture
+- `pkg/model/lobby/lobby.go` — `CurrentTurn int32` on `GameSummary`
+- `backend/internal/server/handlers_user_lobby_helpers.go` —
+  `gameSummaryWire.CurrentTurn` + `gameSummaryToWire` reads it
+  from `RuntimeSnapshot.CurrentTurn`; `lobbyGameDetailWire` no
+  longer redeclares the field
+- `backend/openapi.yaml` — `current_turn` on the `GameSummary`
+  schema (required); removed from the `LobbyGameDetail` allOf
+  block (now inherited)
+- `gateway/internal/backendclient/lobby_commands.go` —
+  `decodeGameSummaryFromGameDetail` and `decodePublicGamesPage`
+  parse `current_turn` from JSON
+- `ui/Makefile` — `FBS_INPUTS` adds `common.fbs` (so the
+  `common/uuid.ts` directory is generated) and `report.fbs`
+- `ui/frontend/src/proto/galaxy/fbs/{common,report}/...` —
+  regenerated TS bindings
+- `ui/frontend/src/api/lobby.ts` — `currentTurn: number` on
+  `GameSummary`; `decodeGameSummary` reads it
+- `ui/frontend/tests/lobby-{fbs,api,page}.test.ts` and
+  `tests/e2e/fixtures/lobby-fbs.ts` — fixtures and assertions
+  cover `currentTurn`
+- `ui/frontend/tests/state-binding.test.ts` — Vitest unit
+  coverage for `reportToWorld` (dimensions, kinds, ids, styling,
+  empty-planet, zero-dimension fallback, priority order)
+- `ui/frontend/tests/game-state.test.ts` — Vitest coverage for
+  `GameStateStore` (init flow, missing-membership error,
+  forbidden-result error, `setTurn`, wrap-mode persistence
+  across instances, `failBootstrap`)
+- `ui/frontend/tests/e2e/game-shell-map.spec.ts` — Playwright e2e
+  with a mocked gateway: live report renders the reported turn
+  and planet count, zero-planet game renders without errors,
+  missing-membership game surfaces the error overlay
+- `ui/frontend/tests/e2e/fixtures/report-fbs.ts` — `buildReportPayload`
+  helper for forging FB Report payloads
+- Topic doc `ui/docs/game-state.md`
+- `ui/docs/lobby.md` — `current_turn` note pointing at the new
+  game-state doc
 
 Dependencies: Phases 9, 10.
 
-Acceptance criteria:
+Acceptance criteria (met):
 
 - entering `/games/:id/map` for a game with real planets renders them
   on the map;
@@ -1189,14 +1307,20 @@ Acceptance criteria:
 - view mode (torus / no-wrap) honours the per-game preference if set,
   defaults to torus otherwise.
 
-Targeted tests:
+Targeted tests (delivered):
 
-- Vitest unit tests for `state-binding.ts` translating report data to
-  primitives;
-- Playwright e2e against a local stack with seeded game state;
-- regression test: zero-planet game shows the map empty without errors;
-- regression test: per-game wrap-scrolling preference persists and is
-  applied on next visit to the game.
+- Vitest: `tests/state-binding.test.ts` covers the report→world
+  translation across every planet kind plus malformed-dimension
+  guards; `tests/game-state.test.ts` covers the store lifecycle
+  end-to-end with a stubbed `listMyGames` and a fake `GalaxyClient`;
+- Playwright e2e: `tests/e2e/game-shell-map.spec.ts` exercises the
+  live data path with a mocked gateway across all four projects,
+  including the zero-planet regression and the
+  missing-membership error path;
+- per-game wrap-scrolling preference round-trips through `Cache`
+  in `game-state.test.ts::setWrapMode persists across instances`;
+- the existing Phase 10 chrome / navigation specs still pass
+  unchanged.
 
 ## Phase 12. Order Composer Skeleton