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/frontend/tests/e2e/fixtures/report-fbs.ts

@@ -0,0 +1,129 @@
+// Phase 11 helpers for forging FlatBuffers report payloads in e2e
+// tests. Mirrors the engine's `report.Report` shape so the mocked
+// gateway can return realistic data without standing up the real
+// engine container.
+//
+// Phase 11 only renders planets, so the helpers keep the report shape
+// minimal (turn / dimensions / planet vectors). Later phases extend
+// the helper as ships, fleets, sciences, etc. land.
+
+import { Builder } from "flatbuffers";
+
+import {
+	LocalPlanet,
+	OtherPlanet,
+	Report,
+	UnidentifiedPlanet,
+	UninhabitedPlanet,
+} from "../../../src/proto/galaxy/fbs/report";
+
+export interface PlanetFixture {
+	number: number;
+	name: string;
+	x: number;
+	y: number;
+}
+
+export interface OtherPlanetFixture extends PlanetFixture {
+	owner: string;
+}
+
+export interface ReportFixture {
+	turn: number;
+	mapWidth?: number;
+	mapHeight?: number;
+	localPlanets?: PlanetFixture[];
+	otherPlanets?: OtherPlanetFixture[];
+	uninhabitedPlanets?: PlanetFixture[];
+	unidentifiedPlanets?: { number: number; x: number; y: number }[];
+}
+
+export function buildReportPayload(fixture: ReportFixture): Uint8Array {
+	const builder = new Builder(512);
+
+	const localOffsets = (fixture.localPlanets ?? []).map((planet) => {
+		const name = builder.createString(planet.name);
+		LocalPlanet.startLocalPlanet(builder);
+		LocalPlanet.addNumber(builder, BigInt(planet.number));
+		LocalPlanet.addX(builder, planet.x);
+		LocalPlanet.addY(builder, planet.y);
+		LocalPlanet.addName(builder, name);
+		LocalPlanet.addSize(builder, 10);
+		LocalPlanet.addResources(builder, 0.5);
+		LocalPlanet.addPopulation(builder, 0);
+		LocalPlanet.addIndustry(builder, 0);
+		return LocalPlanet.endLocalPlanet(builder);
+	});
+
+	const otherOffsets = (fixture.otherPlanets ?? []).map((planet) => {
+		const name = builder.createString(planet.name);
+		const owner = builder.createString(planet.owner);
+		OtherPlanet.startOtherPlanet(builder);
+		OtherPlanet.addNumber(builder, BigInt(planet.number));
+		OtherPlanet.addX(builder, planet.x);
+		OtherPlanet.addY(builder, planet.y);
+		OtherPlanet.addName(builder, name);
+		OtherPlanet.addOwner(builder, owner);
+		OtherPlanet.addSize(builder, 9);
+		return OtherPlanet.endOtherPlanet(builder);
+	});
+
+	const uninhabitedOffsets = (fixture.uninhabitedPlanets ?? []).map(
+		(planet) => {
+			const name = builder.createString(planet.name);
+			UninhabitedPlanet.startUninhabitedPlanet(builder);
+			UninhabitedPlanet.addNumber(builder, BigInt(planet.number));
+			UninhabitedPlanet.addX(builder, planet.x);
+			UninhabitedPlanet.addY(builder, planet.y);
+			UninhabitedPlanet.addName(builder, name);
+			UninhabitedPlanet.addSize(builder, 6);
+			return UninhabitedPlanet.endUninhabitedPlanet(builder);
+		},
+	);
+
+	const unidentifiedOffsets = (fixture.unidentifiedPlanets ?? []).map(
+		(planet) => {
+			UnidentifiedPlanet.startUnidentifiedPlanet(builder);
+			UnidentifiedPlanet.addNumber(builder, BigInt(planet.number));
+			UnidentifiedPlanet.addX(builder, planet.x);
+			UnidentifiedPlanet.addY(builder, planet.y);
+			return UnidentifiedPlanet.endUnidentifiedPlanet(builder);
+		},
+	);
+
+	const localVec =
+		localOffsets.length === 0
+			? null
+			: Report.createLocalPlanetVector(builder, localOffsets);
+	const otherVec =
+		otherOffsets.length === 0
+			? null
+			: Report.createOtherPlanetVector(builder, otherOffsets);
+	const uninhabitedVec =
+		uninhabitedOffsets.length === 0
+			? null
+			: Report.createUninhabitedPlanetVector(builder, uninhabitedOffsets);
+	const unidentifiedVec =
+		unidentifiedOffsets.length === 0
+			? null
+			: Report.createUnidentifiedPlanetVector(builder, unidentifiedOffsets);
+
+	const totalPlanets =
+		(fixture.localPlanets ?? []).length +
+		(fixture.otherPlanets ?? []).length +
+		(fixture.uninhabitedPlanets ?? []).length +
+		(fixture.unidentifiedPlanets ?? []).length;
+
+	Report.startReport(builder);
+	Report.addTurn(builder, BigInt(fixture.turn));
+	Report.addWidth(builder, fixture.mapWidth ?? 4000);
+	Report.addHeight(builder, fixture.mapHeight ?? 4000);
+	Report.addPlanetCount(builder, totalPlanets);
+	if (localVec !== null) Report.addLocalPlanet(builder, localVec);
+	if (otherVec !== null) Report.addOtherPlanet(builder, otherVec);
+	if (uninhabitedVec !== null) Report.addUninhabitedPlanet(builder, uninhabitedVec);
+	if (unidentifiedVec !== null) Report.addUnidentifiedPlanet(builder, unidentifiedVec);
+	const reportOff = Report.endReport(builder);
+	builder.finish(reportOff);
+	return builder.asUint8Array();
+}