diff --git a/src/client/HostLobbyModal.ts b/src/client/HostLobbyModal.ts
index 322cc68add..01dbdc6858 100644
--- a/src/client/HostLobbyModal.ts
+++ b/src/client/HostLobbyModal.ts
@@ -179,6 +179,7 @@ export class HostLobbyModal extends BaseModal {
     });
   }
 
+  /** Render the host lobby body: game config settings and the player list. */
   protected renderBody() {
     const inputCards = [
       html`<toggle-input-card
@@ -323,6 +324,9 @@ export class HostLobbyModal extends BaseModal {
                   defaultValue: this.defaultNationCount,
                   labelKey: "host_modal.nations",
                   disabledKey: "host_modal.nations_disabled",
+                  // Random lobby: show "Map default" without the count, which
+                  // would otherwise reveal the (hidden) map.
+                  hideDefaultValue: this.useRandomMap,
                 },
                 toggles: [
                   {
@@ -409,6 +413,7 @@ export class HostLobbyModal extends BaseModal {
             .currentClientID=${this.lobbyCreatorClientID}
             .teamCount=${this.teamCount}
             .nationCount=${this.nations}
+            .randomMap=${this.useRandomMap}
             .onKickPlayer=${(clientID: string) => this.kickPlayer(clientID)}
           ></lobby-player-view>
         </div>
@@ -934,6 +939,7 @@ export class HostLobbyModal extends BaseModal {
     this.putGameConfig();
   }
 
+  /** Push the host's current lobby settings to the server as a config update. */
   private async putGameConfig() {
     const spawnImmunityTicks = this.spawnImmunityDurationMinutes
       ? this.spawnImmunityDurationMinutes * 60 * 10
@@ -945,6 +951,7 @@ export class HostLobbyModal extends BaseModal {
         detail: {
           config: {
             gameMap: this.selectedMap,
+            randomMap: this.useRandomMap,
             gameMapSize: this.compactMap
               ? GameMapSize.Compact
               : GameMapSize.Normal,
diff --git a/src/client/JoinLobbyModal.ts b/src/client/JoinLobbyModal.ts
index 115bff0fa4..d2ab1bfced 100644
--- a/src/client/JoinLobbyModal.ts
+++ b/src/client/JoinLobbyModal.ts
@@ -96,6 +96,7 @@ export class JoinLobbyModal extends BaseModal {
     });
   }
 
+  /** Render the join lobby body: game config preview and the player list. */
   protected renderBody() {
     // Pre-join state: show lobby ID input form
     if (!this.currentLobbyId) {
@@ -156,6 +157,7 @@ export class JoinLobbyModal extends BaseModal {
                           this.gameConfig?.nations ?? "default",
                           this.nationCount,
                         )}
+                        .randomMap=${this.gameConfig?.randomMap === true}
                       ></lobby-player-view>
                     `
                   : ""}
@@ -406,15 +408,20 @@ export class JoinLobbyModal extends BaseModal {
 
   // --- Game config rendering ---
 
+  /** Render the lobby's map, mode, and option cards (map hidden when random). */
   private renderGameConfig(): TemplateResult {
     if (!this.gameConfig) return html``;
 
     const c = this.gameConfig;
-    const mapName = getMapName(c.gameMap);
+    // A "Random" lobby keeps the concrete map hidden until the game starts.
+    const isRandomMap = c.randomMap === true;
+    const mapName = isRandomMap
+      ? translateText("map.random")
+      : getMapName(c.gameMap);
     const normalizedMap = normaliseMapKey(c.gameMap);
-    const thumbnailUrl = assetUrl(
-      `maps/${encodeURIComponent(normalizedMap)}/thumbnail.webp`,
-    );
+    const thumbnailUrl = isRandomMap
+      ? assetUrl("images/RandomMap.webp")
+      : assetUrl(`maps/${encodeURIComponent(normalizedMap)}/thumbnail.webp`);
     const isTeam = c.gameMode === GameMode.Team;
 
     let modeSubtitle: string;
diff --git a/src/client/SinglePlayerModal.ts b/src/client/SinglePlayerModal.ts
index 994996ddd6..68454678e6 100644
--- a/src/client/SinglePlayerModal.ts
+++ b/src/client/SinglePlayerModal.ts
@@ -198,6 +198,7 @@ export class SinglePlayerModal extends BaseModal {
     });
   }
 
+  /** Render the single-player setup body: game config settings. */
   protected renderBody() {
     const inputCards = [
       html`<toggle-input-card
@@ -290,6 +291,9 @@ export class SinglePlayerModal extends BaseModal {
                   defaultValue: this.defaultNationCount,
                   labelKey: "single_modal.nations",
                   disabledKey: "single_modal.nations_disabled",
+                  // Random map: show "Map default" without the count, which
+                  // would otherwise reveal the hidden map.
+                  hideDefaultValue: this.useRandomMap,
                 },
                 toggles: [
                   {
diff --git a/src/client/components/FluentSlider.ts b/src/client/components/FluentSlider.ts
index 1a026135ed..4e3ec42f6d 100644
--- a/src/client/components/FluentSlider.ts
+++ b/src/client/components/FluentSlider.ts
@@ -16,6 +16,12 @@ export class FluentSlider extends LitElement {
   @property({ type: String }) disabledKey = "";
   @property({ type: Number }) defaultValue: number | undefined = undefined;
   @property({ type: String }) defaultLabelKey = "";
+  /**
+   * When true, render only the default label (not the numeric value) while the
+   * slider sits at its default position. Used to hide the map's nation count
+   * for "Random" lobbies, where the number would reveal the map.
+   */
+  @property({ type: Boolean }) hideDefaultValue = false;
 
   @state() private isEditing = false;
 
@@ -31,6 +37,14 @@ export class FluentSlider extends LitElement {
     );
   }
 
+  /** Restore the slider to its default value and notify listeners. */
+  private resetToDefault() {
+    if (this.defaultValue === undefined) return;
+    this.value = this.defaultValue;
+    this.isEditing = false;
+    this.dispatchValueChange();
+  }
+
   private handleSliderInput(e: Event) {
     const target = e.target as HTMLInputElement;
     this.value = target.valueAsNumber;
@@ -71,11 +85,23 @@ export class FluentSlider extends LitElement {
     this.updateComplete.then(() => this.numberInput?.focus());
   }
 
+  /** Render the range input, its value label, and the optional reset button. */
   render() {
+    // For a hidden default (a "Random" lobby), the real value would reveal the
+    // map's nation count via the thumb's *position*, not just the number. While
+    // untouched at the default, park the thumb at the track's center so it
+    // gives nothing away. Dragging/typing still reports the real input value.
+    const atHiddenDefault =
+      this.hideDefaultValue &&
+      this.defaultValue !== undefined &&
+      this.value === this.defaultValue;
+    const displayValue = atHiddenDefault
+      ? Math.round((this.min + this.max) / 2)
+      : this.value;
     const percentage =
       this.max === this.min
         ? 0
-        : ((this.value - this.min) / (this.max - this.min)) * 100;
+        : ((displayValue - this.min) / (this.max - this.min)) * 100;
     return html`
       <div
         class="flex flex-col items-center justify-center gap-1 w-full text-center"
@@ -85,7 +111,7 @@ export class FluentSlider extends LitElement {
           .min=${this.min}
           .max=${this.max}
           .step=${this.step}
-          .valueAsNumber=${this.value}
+          .valueAsNumber=${displayValue}
           style="background: linear-gradient(to right, var(--color-malibu-blue) 0%, var(--color-malibu-blue) ${percentage}%, rgba(255, 255, 255, 0.15) ${percentage}%, rgba(255, 255, 255, 0.15) 100%); background-size: 100% 6px; background-repeat: no-repeat; background-position: center; border-radius: 9999px;"
           class="w-full h-6 p-0 m-0 bg-transparent appearance-none cursor-pointer focus:outline-none 
                  [&::-webkit-slider-runnable-track]:w-full [&::-webkit-slider-runnable-track]:h-[6px] [&::-webkit-slider-runnable-track]:cursor-pointer [&::-webkit-slider-runnable-track]:bg-transparent [&::-webkit-slider-runnable-track]:rounded-full [&::-webkit-slider-runnable-track]:transition-colors
@@ -107,7 +133,7 @@ export class FluentSlider extends LitElement {
                 type="number"
                 .min=${this.min}
                 .max=${this.max}
-                .valueAsNumber=${this.value}
+                .valueAsNumber=${displayValue}
                 class="w-[60px] bg-black/60 text-white border border-white/20 text-center rounded text-sm p-1 leading-none font-bold font-inherit mt-1 focus:outline-none focus:border-blue-500"
                 @input=${this.handleNumberInput}
                 @blur=${() => {
@@ -136,12 +162,28 @@ export class FluentSlider extends LitElement {
                   : this.defaultValue !== undefined &&
                       this.value === this.defaultValue &&
                       this.defaultLabelKey
-                    ? html`${this.value}
-                        <span class="text-white/40 uppercase"
-                          >(${translateText(this.defaultLabelKey)})</span
+                    ? this.hideDefaultValue
+                      ? html`<span class="text-white/40 uppercase"
+                          >${translateText(this.defaultLabelKey)}</span
                         >`
+                      : html`${this.value}
+                          <span class="text-white/40 uppercase"
+                            >(${translateText(this.defaultLabelKey)})</span
+                          >`
                     : this.value}
               </span>`}
+          ${this.hideDefaultValue &&
+          this.defaultValue !== undefined &&
+          this.value !== this.defaultValue &&
+          this.defaultLabelKey
+            ? html`<button
+                type="button"
+                class="text-xs lowercase text-white/40 hover:text-white underline underline-offset-2 mt-1 cursor-pointer bg-transparent border-none"
+                @click=${this.resetToDefault}
+              >
+                ↺ ${translateText(this.defaultLabelKey)}
+              </button>`
+            : ""}
         </div>
       </div>
     `;
diff --git a/src/client/components/GameConfigSettings.ts b/src/client/components/GameConfigSettings.ts
index 39184d267d..23f415ac54 100644
--- a/src/client/components/GameConfigSettings.ts
+++ b/src/client/components/GameConfigSettings.ts
@@ -198,6 +198,7 @@ export interface GameConfigSettingsData {
       labelKey: string;
       disabledKey: string;
       hidden?: boolean;
+      hideDefaultValue?: boolean;
     };
     toggles: ToggleOptionConfig[];
     inputCards: TemplateResult[];
@@ -309,6 +310,7 @@ export class GameConfigSettings extends LitElement {
     });
   }
 
+  /** Render the map picker, difficulty, sliders, and option toggles. */
   render() {
     if (!this.settings) return nothing;
     const settings = this.settings;
@@ -468,6 +470,8 @@ export class GameConfigSettings extends LitElement {
                       .value=${settings.options.nations.value}
                       .defaultValue=${settings.options.nations.defaultValue}
                       defaultLabelKey="common.map_default"
+                      .hideDefaultValue=${settings.options.nations
+                        .hideDefaultValue ?? false}
                       labelKey=${settings.options.nations.labelKey}
                       disabledKey=${settings.options.nations.disabledKey}
                       @value-changed=${this.handleNationsChanged}
diff --git a/src/client/components/LobbyPlayerView.ts b/src/client/components/LobbyPlayerView.ts
index d4f4510e11..4a0910d0a8 100644
--- a/src/client/components/LobbyPlayerView.ts
+++ b/src/client/components/LobbyPlayerView.ts
@@ -37,6 +37,8 @@ export class LobbyTeamView extends LitElement {
   @property({ type: Function }) onKickPlayer?: (clientID: string) => void;
   @property({ type: Number }) nationCount: number = 0;
   @property({ type: Boolean }) isPublicGame: boolean = false;
+  /** When true (a "Random" lobby), hide the nation count so it can't reveal the map. */
+  @property({ type: Boolean }) randomMap: boolean = false;
 
   private get theme(): Theme {
     return themeProvider.current();
@@ -50,12 +52,20 @@ export class LobbyTeamView extends LitElement {
    * controls the nation count via the slider.
    */
   private get effectiveNationCount(): number {
+    // A "Random" lobby must not reveal the map's nation count — not in the
+    // header, and not via anything derived from it (team-card totals, team
+    // sizing, player totals). Treat it as 0 everywhere; the header shows
+    // "Map default" via its own randomMap branch instead.
+    if (this.randomMap) {
+      return 0;
+    }
     if (this.isPublicGame && this.teamCount === HumansVsNations) {
       return this.clients.length;
     }
     return this.nationCount;
   }
 
+  /** Recompute the team preview when an input affecting team layout changes. */
   willUpdate(changedProperties: Map<string, any>) {
     // Recompute team preview when relevant properties change
     // clients is updated from WebSocket lobby_info events
@@ -64,7 +74,8 @@ export class LobbyTeamView extends LitElement {
       changedProperties.has("clients") ||
       changedProperties.has("teamCount") ||
       changedProperties.has("nationCount") ||
-      changedProperties.has("isPublicGame")
+      changedProperties.has("isPublicGame") ||
+      changedProperties.has("randomMap")
     ) {
       const teamsList = this.getTeamList();
       this.computeTeamPreview(teamsList);
@@ -72,6 +83,7 @@ export class LobbyTeamView extends LitElement {
     }
   }
 
+  /** Render the player/nation summary header and the team or FFA roster. */
   render() {
     return html`
       <div class="border-t border-white/10 pt-6">
@@ -84,10 +96,13 @@ export class LobbyTeamView extends LitElement {
               ? translateText("host_modal.player")
               : translateText("host_modal.players")}
             <span style="margin: 0 8px;">•</span>
-            ${this.effectiveNationCount}
-            ${this.effectiveNationCount === 1
-              ? translateText("host_modal.nation_player")
-              : translateText("host_modal.nation_players")}
+            ${this.randomMap
+              ? html`${translateText("common.map_default")}
+                ${translateText("host_modal.nation_players")}`
+              : html`${this.effectiveNationCount}
+                ${this.effectiveNationCount === 1
+                  ? translateText("host_modal.nation_player")
+                  : translateText("host_modal.nation_players")}`}
           </div>
         </div>
         <div
diff --git a/src/core/Schemas.ts b/src/core/Schemas.ts
index f23516f389..77a0b11860 100644
--- a/src/core/Schemas.ts
+++ b/src/core/Schemas.ts
@@ -241,6 +241,11 @@ export type TeamCountConfig = z.infer<typeof TeamCountConfigSchema>;
 
 export const GameConfigSchema = z.object({
   gameMap: z.enum(GameMapType),
+  // When true, the host chose "Random": the concrete gameMap above is still
+  // resolved client-side (so nation count etc. work), but it must be hidden
+  // from all pre-start visuals (embed, lobby map name, nation count). The
+  // server clears this flag at prestart, which reveals the map.
+  randomMap: z.boolean().optional(),
   difficulty: z.enum(Difficulty),
   donateGold: z.boolean(), // Configures donations to humans only
   donateTroops: z.boolean(), // Configures donations to humans only
diff --git a/src/server/GamePreviewBuilder.ts b/src/server/GamePreviewBuilder.ts
index 592fafc491..1ca84da11e 100644
--- a/src/server/GamePreviewBuilder.ts
+++ b/src/server/GamePreviewBuilder.ts
@@ -134,6 +134,11 @@ export function escapeHtml(value: string): string {
     .replace(/'/g, "&#39;");
 }
 
+/**
+ * Build the OpenGraph/social preview (title, description, image, join URL) for
+ * a game link from its live lobby and/or archived public info. A pre-start
+ * "Random" lobby is shown with a generic placeholder so the map isn't spoiled.
+ */
 export async function buildPreview(
   gameID: string,
   origin: string,
@@ -162,6 +167,10 @@ export async function buildPreview(
       countActivePlayers(players) || (lobby?.clients?.length ?? 0);
   }
   const map = lobby?.gameConfig?.gameMap ?? config.gameMap;
+  // While a "Random" lobby hasn't started, hide the concrete map so the embed
+  // doesn't spoil it. The server clears randomMap at prestart, so an
+  // in-progress/finished game reveals its real map normally.
+  const isRandomMap = lobby?.gameConfig?.randomMap === true && !isFinished;
   let mode = lobby?.gameConfig?.gameMode ?? config.gameMode ?? GameMode.FFA;
   const playerTeams = lobby?.gameConfig?.playerTeams ?? config.playerTeams;
   const numericTeamCount =
@@ -192,23 +201,28 @@ export async function buildPreview(
   const duration = publicInfo?.info?.duration;
 
   // Normalize map name to match filesystem (lowercase, no spaces or special chars)
-  const normalizedMap = map ? map.toLowerCase().replace(/[\s.()]+/g, "") : null;
+  const normalizedMap =
+    map && !isRandomMap ? map.toLowerCase().replace(/[\s.()]+/g, "") : null;
 
   const mapThumbnail = normalizedMap
     ? buildAbsoluteAssetUrl(
         `maps/${encodeURIComponent(normalizedMap)}/thumbnail.webp`,
       )
     : null;
-  const image =
-    mapThumbnail ?? buildAbsoluteAssetUrl("images/GameplayScreenshot.png");
+  const image = isRandomMap
+    ? buildAbsoluteAssetUrl("images/RandomMap.webp")
+    : (mapThumbnail ?? buildAbsoluteAssetUrl("images/GameplayScreenshot.png"));
+
+  // The name shown in the title: "Random Map" until the lobby starts.
+  const displayMap = isRandomMap ? "Random Map" : map;
 
   const gameType = lobby?.gameConfig?.gameType ?? config.gameType;
   const gameTypeLabel = gameType ? ` (${gameType})` : "";
 
   const title = isFinished
     ? `${mode ?? "Game"} on ${map ?? "Unknown Map"}${gameTypeLabel}`
-    : mode && map
-      ? `${mode} on ${map}${gameTypeLabel}`
+    : mode && displayMap
+      ? `${mode} on ${displayMap}${gameTypeLabel}`
       : "OpenFront Game";
 
   let description: string;
diff --git a/src/server/GameServer.ts b/src/server/GameServer.ts
index 21279f856d..cd2c98aec2 100644
--- a/src/server/GameServer.ts
+++ b/src/server/GameServer.ts
@@ -118,10 +118,14 @@ export class GameServer {
       : undefined;
   }
 
+  /** Merge an allowed subset of config fields from a lobby host's update. */
   public updateGameConfig(gameConfig: Partial<GameConfig>): void {
     if (gameConfig.gameMap !== undefined) {
       this.gameConfig.gameMap = gameConfig.gameMap;
     }
+    if (gameConfig.randomMap !== undefined) {
+      this.gameConfig.randomMap = gameConfig.randomMap;
+    }
     if (gameConfig.gameMapSize !== undefined) {
       this.gameConfig.gameMapSize = gameConfig.gameMapSize;
     }
@@ -648,12 +652,19 @@ export class GameServer {
     return this.outOfSyncClients.size;
   }
 
+  /** Begin the start sequence: reveal the map and broadcast prestart to clients. */
   public prestart() {
     if (this.hasStarted()) {
       return;
     }
     this._hasPrestarted = true;
 
+    // The game is starting: reveal the map. Clearing the flag means every
+    // downstream consumer (embed, started-game info) sees a normal concrete
+    // map with no special-casing. The concrete gameMap was already resolved
+    // client-side at lobby creation, so nothing else needs to change here.
+    this.gameConfig.randomMap = false;
+
     const prestartMsg = ServerPrestartMessageSchema.safeParse({
       type: "prestart",
       gameMap: this.gameConfig.gameMap,
diff --git a/tests/RandomMapConfig.test.ts b/tests/RandomMapConfig.test.ts
new file mode 100644
index 0000000000..b156d4a1d1
--- /dev/null
+++ b/tests/RandomMapConfig.test.ts
@@ -0,0 +1,20 @@
+import { describe, expect, test } from "vitest";
+import {
+  GameConfigSchema,
+  UpdateGameConfigIntentSchema,
+} from "../src/core/Schemas";
+
+describe("randomMap in GameConfig", () => {
+  test("is carried by the update_game_config intent", () => {
+    const parsed = UpdateGameConfigIntentSchema.parse({
+      type: "update_game_config",
+      config: { randomMap: true },
+    });
+    expect(parsed.config.randomMap).toBe(true);
+  });
+
+  test("is optional", () => {
+    const parsed = GameConfigSchema.partial().parse({});
+    expect(parsed.randomMap).toBeUndefined();
+  });
+});
diff --git a/tests/client/components/FluentSlider.test.ts b/tests/client/components/FluentSlider.test.ts
index 8b633df09e..4b5f965772 100644
--- a/tests/client/components/FluentSlider.test.ts
+++ b/tests/client/components/FluentSlider.test.ts
@@ -278,6 +278,103 @@ describe("FluentSlider", () => {
     });
   });
 
+  describe("Hidden default (Random lobby)", () => {
+    it("parks the thumb at the track center when at a hidden default", async () => {
+      slider.min = 0;
+      slider.max = 400;
+      slider.defaultValue = 247;
+      slider.value = 247;
+      slider.hideDefaultValue = true;
+      await slider.updateComplete;
+
+      const rangeInput = slider.querySelector(
+        'input[type="range"]',
+      ) as HTMLInputElement;
+
+      // Thumb shows the center (200), NOT the real count (247) that would
+      // otherwise reveal the hidden map.
+      expect(rangeInput.valueAsNumber).toBe(200);
+      // The underlying value is untouched.
+      expect(slider.value).toBe(247);
+    });
+
+    it("tracks the real position once moved off the default", async () => {
+      slider.min = 0;
+      slider.max = 400;
+      slider.defaultValue = 247;
+      slider.value = 300;
+      slider.hideDefaultValue = true;
+      await slider.updateComplete;
+
+      const rangeInput = slider.querySelector(
+        'input[type="range"]',
+      ) as HTMLInputElement;
+      expect(rangeInput.valueAsNumber).toBe(300);
+    });
+
+    it("still reports the dragged value from the parked position", async () => {
+      slider.min = 0;
+      slider.max = 400;
+      slider.defaultValue = 247;
+      slider.value = 247;
+      slider.hideDefaultValue = true;
+      await slider.updateComplete;
+
+      const rangeInput = slider.querySelector(
+        'input[type="range"]',
+      ) as HTMLInputElement;
+      rangeInput.valueAsNumber = 180;
+      rangeInput.dispatchEvent(new Event("change", { bubbles: true }));
+      await slider.updateComplete;
+
+      expect(slider.value).toBe(180);
+    });
+
+    it("offers a reset button only once moved off the hidden default", async () => {
+      slider.min = 0;
+      slider.max = 400;
+      slider.defaultValue = 247;
+      slider.hideDefaultValue = true;
+      slider.defaultLabelKey = "common.map_default";
+
+      // At default: no reset button.
+      slider.value = 247;
+      await slider.updateComplete;
+      expect(slider.querySelector("button")).toBeNull();
+
+      // Moved off default: reset button appears.
+      slider.value = 180;
+      await slider.updateComplete;
+      expect(slider.querySelector("button")).toBeTruthy();
+    });
+
+    it("resets to the default value (and re-parks) when reset is clicked", async () => {
+      const eventSpy = vi.fn();
+      slider.addEventListener("value-changed", eventSpy);
+
+      slider.min = 0;
+      slider.max = 400;
+      slider.defaultValue = 247;
+      slider.value = 180;
+      slider.hideDefaultValue = true;
+      slider.defaultLabelKey = "common.map_default";
+      await slider.updateComplete;
+
+      const resetButton = slider.querySelector("button") as HTMLButtonElement;
+      expect(resetButton).toBeTruthy();
+      resetButton.click();
+      await slider.updateComplete;
+
+      // Back to the (hidden) default, re-parked at center, change dispatched.
+      expect(slider.value).toBe(247);
+      expect(eventSpy).toHaveBeenCalledTimes(1);
+      const rangeInput = slider.querySelector(
+        'input[type="range"]',
+      ) as HTMLInputElement;
+      expect(rangeInput.valueAsNumber).toBe(200);
+    });
+  });
+
   describe("Edge Cases", () => {
     it("should handle min equal to max without NaN in style", async () => {
       slider.min = 100;
diff --git a/tests/server/GameLifecycle.test.ts b/tests/server/GameLifecycle.test.ts
index 19661a7648..0c4f714310 100644
--- a/tests/server/GameLifecycle.test.ts
+++ b/tests/server/GameLifecycle.test.ts
@@ -85,4 +85,30 @@ describe("GameLifecycle", () => {
     await expect(game.end()).resolves.toBeUndefined();
     expect((game as any)._hasEnded).toBe(true);
   });
+
+  it("clears the randomMap flag at prestart (reveals the map at start)", () => {
+    const game = new GameServer("test-game", mockLogger, Date.now(), {
+      gameType: GameType.Private,
+      gameMap: "plains",
+      gameMapSize: 100,
+      randomMap: true,
+    } as any);
+
+    expect((game as any).gameConfig.randomMap).toBe(true);
+    game.prestart();
+    // The concrete map is untouched; only the "hide it" flag is cleared.
+    expect((game as any).gameConfig.randomMap).toBe(false);
+    expect((game as any).gameConfig.gameMap).toBe("plains");
+  });
+
+  it("persists the randomMap flag through updateGameConfig", () => {
+    const game = new GameServer("test-game", mockLogger, Date.now(), {
+      gameType: GameType.Private,
+      gameMap: "plains",
+      randomMap: false,
+    } as any);
+
+    game.updateGameConfig({ randomMap: true } as any);
+    expect((game as any).gameConfig.randomMap).toBe(true);
+  });
 });
diff --git a/tests/server/GamePreviewRandomMap.test.ts b/tests/server/GamePreviewRandomMap.test.ts
new file mode 100644
index 0000000000..65fee6aa02
--- /dev/null
+++ b/tests/server/GamePreviewRandomMap.test.ts
@@ -0,0 +1,77 @@
+import { describe, expect, test, vi } from "vitest";
+
+// buildPreview reads the runtime asset manifest and CDN base; stub both so the
+// pure title/image logic can be tested without filesystem/env.
+vi.mock("../../src/server/RuntimeAssetManifest", () => ({
+  getRuntimeAssetManifest: vi.fn().mockResolvedValue({}),
+}));
+vi.mock("../../src/server/ServerEnv", () => ({
+  ServerEnv: {
+    /** Empty CDN base so asset URLs resolve to same-origin paths in tests. */
+    cdnBase: () => "",
+  },
+}));
+
+import { buildPreview } from "../../src/server/GamePreviewBuilder";
+
+const origin = "https://example.com";
+
+/** Build a minimal live-lobby GameInfo stub around a gameConfig for buildPreview. */
+function lobby(gameConfig: any) {
+  return { gameConfig, clients: [{ username: "host" }] } as any;
+}
+
+describe("GamePreview — random map", () => {
+  test("hides the concrete map for an unstarted random lobby", async () => {
+    const meta = await buildPreview(
+      "game1",
+      origin,
+      "w0",
+      lobby({
+        gameMap: "Europe",
+        randomMap: true,
+        gameType: "Private",
+        gameMode: "FFA",
+      }),
+      null,
+    );
+
+    expect(meta.image).toContain("RandomMap.webp");
+    expect(meta.image.toLowerCase()).not.toContain("europe");
+    expect(meta.title).toContain("Random Map");
+    expect(meta.title).not.toContain("Europe");
+  });
+
+  test("shows the concrete map for a normal lobby", async () => {
+    const meta = await buildPreview(
+      "game2",
+      origin,
+      "w0",
+      lobby({
+        gameMap: "Europe",
+        randomMap: false,
+        gameType: "Private",
+        gameMode: "FFA",
+      }),
+      null,
+    );
+
+    expect(meta.image.toLowerCase()).toContain("europe");
+    expect(meta.title).toContain("Europe");
+  });
+
+  test("shows the concrete map when randomMap is omitted (the common case)", async () => {
+    // randomMap is optional, so most normal lobbies never set it at all.
+    const meta = await buildPreview(
+      "game3",
+      origin,
+      "w0",
+      lobby({ gameMap: "Europe", gameType: "Private", gameMode: "FFA" }),
+      null,
+    );
+
+    expect(meta.image.toLowerCase()).toContain("europe");
+    expect(meta.image).not.toContain("RandomMap.webp");
+    expect(meta.title).toContain("Europe");
+  });
+});