commit 32398c13e8ae4801323d7f2db95daae632c7c7ba
Author: 33333-33333 <arinco114arinco114@gmail.com>
Date:   Wed May 20 13:50:56 2026 +0900

    first commit

diff --git a/README.md b/README.md
new file mode 100644
index 0000000..86da000
--- /dev/null
+++ b/README.md
@@ -0,0 +1,46 @@
+# Prefecture Map Generator v16 - Causal Terrain Cleanup Edition
+
+This version is designed to run directly in VSCode with **Live Server**. No npm setup is required.
+
+## Run
+
+1. Open this folder in VSCode.
+2. Right-click `index.html`.
+3. Choose **Open with Live Server**.
+
+## Main changes in v16
+
+- River action is much stronger. `erosionField` and `depositionField` now produce clearer valleys, terraces, and alluvial lowlands.
+- Neighboring prefecture regions are generated as background territory with `prefectureRegionId` and `regionalPrefectureBorders`, so the current prefecture is no longer visually isolated.
+- River color now uses the same blue family as the sea; hierarchy is expressed by width and opacity.
+- CBD/DID cells are sparser and restricted to dense, connected urban fabric.
+- Railways, roads, and expressways are pruned for long-distance purpose; compact local tangles are rejected except for environmental ring segments.
+- Expressway rings are rare. ICs are sampled at shorter intervals along expressway corridors.
+- Bridge and tunnel icon rendering was removed. The legacy arrays remain empty for compatibility.
+- Municipal regions are less likely to split small urban areas, while large cities claim larger municipality-like areas.
+
+## Existing systems retained
+
+- River hierarchy: main rivers, tributaries, and small streams.
+- Port classes: major, regional, fishing, lake.
+- Major rail corridors first, then purposeful branches.
+- Expressways avoid city centers; city access is represented through IC access roads.
+- Castles are restricted to terrain/historical candidate sites.
+- Default generated names and manual overrides are both managed in `names.js`.
+- Continuous terrain rendering is always on.
+
+## Editing place names
+
+Edit `names.js`.
+
+```js
+export const CUSTOM_NAMES = {
+  "city-0": "Aohara",
+  "port-0": "Shirahama",
+  "castle-0": "Kurono"
+};
+```
+
+## Tests
+
+Open `test.html` with Live Server to run the browser-side smoke tests, or run `node --check *.js` on the source files.
diff --git a/app.js b/app.js
new file mode 100644
index 0000000..d4c4d06
--- /dev/null
+++ b/app.js
@@ -0,0 +1,249 @@
+import { generateMap } from "./mapGenerator.js";
+import { drawMap } from "./renderer.js";
+
+const modes = [
+  ["all", "All"],
+  ["terrain", "Terrain"],
+  ["suitability", "Suitability"],
+  ["history", "Premodern"],
+  ["modern", "Modern"],
+  ["roads", "Roads"],
+  ["development", "Development"],
+  ["landuse", "Land Use"],
+  ["admin", "Municipal Borders"],
+];
+
+const state = {
+  seedText: "114514",
+  mode: "all",
+  showFeatures: true,
+  showLabels: true,
+  map: null,
+};
+
+const canvas = document.getElementById("mapCanvas");
+const seedInput = document.getElementById("seed");
+const randomSeedButton = document.getElementById("randomSeed");
+const showFeaturesInput = document.getElementById("showFeatures");
+const showLabelsInput = document.getElementById("showLabels");
+const modeGrid = document.getElementById("modeGrid");
+const statsEl = document.getElementById("stats");
+const idsEl = document.getElementById("nameIds");
+const tooltipEl = document.getElementById("mapTooltip");
+
+function parseSeed(seedText) {
+  const numeric = Number.parseInt(seedText, 10);
+  if (Number.isFinite(numeric)) return numeric >>> 0;
+
+  let hash = 2166136261;
+  for (const ch of seedText) hash = Math.imul(hash ^ ch.charCodeAt(0), 16777619);
+  return hash >>> 0;
+}
+
+function insideCount(items) {
+  return items.filter((item) => item.insidePrefecture).length;
+}
+
+function outsideCount(items) {
+  return items.length - insideCount(items);
+}
+
+function countText(items) {
+  return `${insideCount(items)} / outside ${outsideCount(items)}`;
+}
+
+function getStats(map) {
+  return [
+    ["Villages", countText(map.villages)],
+    ["Market Towns", countText(map.markets)],
+    ["Castles", countText(map.castles)],
+    ["Premodern Roads", map.premodernRoads.length],
+    ["Minor Roads", map.minorRoads.length],
+    ["Prefectural Capital", map.prefecturalCapital?.name || "-"],
+    ["Modern Cities", countText(map.modernCities)],
+    ["Ports", `${map.ports.filter((p) => p.portClass === "major").length} major / ${map.ports.filter((p) => p.portClass === "regional").length} regional / ${map.ports.filter((p) => p.portClass === "fishing").length} fishing / ${map.ports.filter((p) => p.portClass === "lake").length} lake`],
+    ["Satellite Cities", countText(map.satelliteCities || [])],
+    ["Population", (map.totalPopulation || 0).toLocaleString()],
+    ["Rivers", `${map.mainRivers.length} main / ${(map.tributaryRivers || []).length} tributary / ${(map.smallStreams || []).length} hidden streams`],
+    ["Neighbor Prefecture Borders", (map.regionalPrefectureBorders || []).length],
+    ["Harbor Works", (map.harborWorks || []).length],
+    ["Rail Lines", map.railways.length + map.branchRailways.length + (map.ringRailways || []).length + map.externalRailways.length],
+    ["Industrial Zones", countText(map.industrialZones)],
+    ["National Roads", map.nationalRoads.length + (map.ringRoads || []).length],
+    ["Expressways", map.expressways.length + (map.ringExpressways || []).length + map.externalExpressways.length],
+    ["External Gateways", map.externalGateways.length],
+    ["Interchanges", countText(map.interchanges)],
+    ["Logistics Parks", countText(map.logisticsParks)],
+    ["New Towns", countText(map.newTowns)],
+    ["Municipalities", map.adminCenters.length],
+  ];
+}
+
+function renderStats(map) {
+  statsEl.innerHTML = "";
+  for (const [labelText, valueText] of getStats(map)) {
+    const row = document.createElement("div");
+    row.className = "stat-row";
+
+    const label = document.createElement("span");
+    label.textContent = labelText;
+
+    const value = document.createElement("strong");
+    value.textContent = String(valueText);
+
+    row.append(label, value);
+    statsEl.append(row);
+  }
+}
+
+function renderNameIds(map) {
+  idsEl.innerHTML = "";
+  for (const entity of map.entitiesForNames.slice(0, 120)) {
+    const row = document.createElement("div");
+    row.className = "id-row";
+
+    const code = document.createElement("code");
+    code.textContent = entity.id;
+
+    const name = document.createElement("span");
+    const population = entity.population ? ` / ${entity.population.toLocaleString()} people` : "";
+    name.textContent = `${entity.name} / ${entity.kind}${population}`;
+
+    row.append(code, name);
+    idsEl.append(row);
+  }
+}
+
+
+function nearestEntity(map, x, y, maxDistance = 5) {
+  const groups = [
+    ...(map.modernCities || []),
+    ...(map.ports || []),
+    ...(map.stations || []),
+    ...(map.interchanges || []),
+    ...(map.industrialZones || []),
+    ...(map.logisticsParks || []),
+    ...(map.newTowns || []),
+    ...(map.castles || []),
+    ...(map.markets || []),
+    ...(map.villages || []),
+    ...(map.adminCenters || []),
+  ];
+  let best = null;
+  let bestD = maxDistance;
+  for (const item of groups) {
+    const d = Math.hypot(item.x - x, item.y - y);
+    if (d < bestD) { best = item; bestD = d; }
+  }
+  return best;
+}
+
+function landuseName(value) {
+  return {
+    0: "Agriculture",
+    1: "Plain",
+    2: "Old urban area",
+    3: "CBD / DID core",
+    4: "Suburban urban area",
+    5: "Industrial zone",
+    6: "Logistics area",
+    7: "New town",
+    8: "Roadside development",
+    9: "Forest / rural land",
+  }[value] || "Land";
+}
+
+function adminName(map, adminId) {
+  const center = (map.adminCenters || [])[adminId];
+  return center?.name || (adminId >= 0 ? `Municipality ${adminId + 1}` : "-");
+}
+
+function updateTooltip(event) {
+  if (!state.map || !tooltipEl) return;
+  const rect = canvas.getBoundingClientRect();
+  const x = Math.floor((event.clientX - rect.left) / rect.width * state.map.width);
+  const y = Math.floor((event.clientY - rect.top) / rect.height * state.map.height);
+  if (x < 0 || y < 0 || x >= state.map.width || y >= state.map.height) {
+    tooltipEl.classList.remove("visible");
+    return;
+  }
+  const i = y * state.map.width + x;
+  const entity = nearestEntity(state.map, x, y);
+  const elevation = state.map.elevation?.[i] ?? 0;
+  const density = state.map.populationDensity?.[i] ?? 0;
+  const lines = [
+    `<strong>${entity ? `${entity.name} / ${entity.kind}` : `${x}, ${y}`}</strong>`,
+    `Admin: ${adminName(state.map, state.map.adminId?.[i] ?? -1)}`,
+    `Land: ${state.map.sea?.[i] ? "Sea" : landuseName(state.map.landuse?.[i])}`,
+    `Elevation: ${elevation.toFixed(3)} / Slope: ${(state.map.slope?.[i] ?? 0).toFixed(3)}`,
+    `River: ${(state.map.river?.[i] ?? 0).toFixed(2)} / Density: ${density.toFixed(2)}`,
+  ];
+  if (entity?.population) lines.splice(1, 0, `Population: ${entity.population.toLocaleString()}`);
+  tooltipEl.innerHTML = lines.join("<br>");
+  tooltipEl.style.left = `${event.clientX - rect.left + 14}px`;
+  tooltipEl.style.top = `${event.clientY - rect.top + 14}px`;
+  tooltipEl.classList.add("visible");
+}
+
+function renderModeButtons() {  modeGrid.innerHTML = "";
+  for (const [key, label] of modes) {
+    const button = document.createElement("button");
+    button.type = "button";
+    button.textContent = label;
+    button.className = key === state.mode ? "mode-button active" : "mode-button";
+    button.addEventListener("click", () => {
+      state.mode = key;
+      renderModeButtons();
+      redraw();
+    });
+    modeGrid.append(button);
+  }
+}
+
+function regenerate() {
+  state.seedText = seedInput.value;
+  state.map = generateMap(parseSeed(state.seedText));
+  renderStats(state.map);
+  renderNameIds(state.map);
+  redraw();
+}
+
+function redraw() {
+  if (!state.map) return;
+  drawMap(canvas, state.map, {
+    mode: state.mode,
+    showFeatures: state.showFeatures,
+    showLabels: state.showLabels,
+  });
+}
+
+function init() {
+  renderModeButtons();
+
+  seedInput.addEventListener("change", regenerate);
+  seedInput.addEventListener("keydown", (event) => {
+    if (event.key === "Enter") regenerate();
+  });
+
+  randomSeedButton.addEventListener("click", () => {
+    seedInput.value = String(Math.floor(Math.random() * 9999999));
+    regenerate();
+  });
+
+  showFeaturesInput.addEventListener("change", () => {
+    state.showFeatures = showFeaturesInput.checked;
+    redraw();
+  });
+
+  showLabelsInput.addEventListener("change", () => {
+    state.showLabels = showLabelsInput.checked;
+    redraw();
+  });
+
+  canvas.addEventListener("mousemove", updateTooltip);
+  canvas.addEventListener("mouseleave", () => tooltipEl?.classList.remove("visible"));
+
+  regenerate();
+}
+
+init();
diff --git a/index.html b/index.html
new file mode 100644
index 0000000..2260ac3
--- /dev/null
+++ b/index.html
@@ -0,0 +1,98 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Prefecture Map Generator v16</title>
+    <link rel="stylesheet" href="./styles.css" />
+  </head>
+  <body>
+    <div class="app">
+      <main class="layout">
+        <section class="main-panel">
+          <header class="header">
+            <div>
+              <h1>Prefecture Map Generator v16</h1>
+              <p>
+                Terrain-highlighted prefecture generation with terrain-snapped municipalities, a clear prefectural capital,
+                hidden small streams, city-seeking national roads, and hover tooltips.
+              </p>
+            </div>
+          </header>
+
+          <div class="canvas-shell">
+            <canvas id="mapCanvas" class="map-canvas"></canvas>
+            <div id="mapTooltip" class="map-tooltip" role="status" aria-live="polite"></div>
+          </div>
+        </section>
+
+        <aside class="sidebar">
+          <section class="card">
+            <label class="label" for="seed">Seed</label>
+            <input id="seed" class="input" value="114514" />
+            <button id="randomSeed" type="button" class="primary-button">Generate Random Seed</button>
+          </section>
+
+          <section class="card">
+            <div class="card-title">Display Layers</div>
+            <div id="modeGrid" class="mode-grid"></div>
+
+            <label class="checkbox-row">
+              <input id="showFeatures" type="checkbox" checked />
+              Show features
+            </label>
+
+            <label class="checkbox-row">
+              <input id="showLabels" type="checkbox" checked />
+              Show labels
+            </label>
+          </section>
+
+          <section class="card">
+            <div class="card-title">Generated Features</div>
+            <div id="stats" class="stats"></div>
+          </section>
+
+          <section class="card legend">
+            <div class="card-title">Name Override IDs</div>
+            <p>Add entries to <code>names.js</code> in <code>CUSTOM_NAMES</code>.</p>
+            <pre class="example">export const CUSTOM_NAMES = {
+  "city-0": "Aohara",
+  "port-0": "Shirahama",
+  "castle-0": "Kurono"
+};</pre>
+            <div id="nameIds" class="id-list"></div>
+          </section>
+
+          <section class="card legend">
+            <div class="card-title">Legend</div>
+            <div class="legend-grid" aria-label="Map legend">
+              <div class="legend-row"><span class="legend-swatch border-swatch"></span><span>Prefecture region / municipal border</span></div>
+              <div class="legend-row"><span class="legend-line river-major"></span><span>Main river / tributary</span></div>
+              <div class="legend-row"><span class="legend-line rail-line"></span><span>Railway / solid ring railway</span></div>
+              <div class="legend-row"><span class="legend-line road-line"></span><span>National road / trunk ring road</span></div>
+              <div class="legend-row"><span class="legend-line express-line"></span><span>Expressway / environmental ring segment</span></div>
+              <div class="legend-row"><span class="legend-line old-road-line"></span><span>Premodern / minor road</span></div>
+              <div class="legend-row"><span class="legend-icon city-icon"></span><span>Prefectural capital / city</span></div>
+              <div class="legend-row"><span class="legend-icon port-icon"></span><span>Major / regional / fishing / lake port</span></div>
+              <div class="legend-row"><span class="legend-icon castle-icon"></span><span>Castle / ruins</span></div>
+              <div class="legend-row"><span class="legend-swatch cbd-swatch"></span><span>CBD / central city cells</span></div>
+              <div class="legend-row"><span class="legend-icon satellite-icon"></span><span>Satellite city</span></div>
+              <div class="legend-row"><span class="legend-icon station-icon"></span><span>Station</span></div>
+              <div class="legend-row"><span class="legend-icon industry-icon"></span><span>Industry / logistics</span></div>
+              <div class="legend-row"><span class="legend-line harbor-line"></span><span>Harbor works</span></div>
+              <div class="legend-row"><span class="legend-icon newtown-icon"></span><span>New town</span></div>
+            </div>
+          </section>
+
+          <section class="card legend">
+            <div class="card-title">Notes</div>
+            <p>Open <code>index.html</code> with Live Server. Open <code>test.html</code> to run browser tests.</p>
+          </section>
+        </aside>
+      </main>
+    </div>
+
+    <script type="module" src="./app.js"></script>
+  </body>
+</html>
diff --git a/mapGenerator.js b/mapGenerator.js
new file mode 100644
index 0000000..caaf54e
--- /dev/null
+++ b/mapGenerator.js
@@ -0,0 +1,3024 @@
+import { CUSTOM_NAMES, KIND_SUFFIXES, NAME_PARTS } from "./names.js";
+
+export const MAP_W = 172;
+export const MAP_H = 122;
+export const CELL_SIZE = 6;
+
+const SIZE = MAP_W * MAP_H;
+const INF = 1e9;
+
+export function indexOf(x, y) {
+  return y * MAP_W + x;
+}
+
+function xyOf(i) {
+  return [i % MAP_W, Math.floor(i / MAP_W)];
+}
+
+function inside(x, y) {
+  return x >= 0 && y >= 0 && x < MAP_W && y < MAP_H;
+}
+
+function clamp(v, a = 0, b = 1) {
+  return Math.max(a, Math.min(b, v));
+}
+
+function nearMapEdge(x, y, margin = 1) {
+  return x < margin || y < margin || x >= MAP_W - margin || y >= MAP_H - margin;
+}
+
+function hash2(x, y, seed) {
+  let h = Math.imul((x | 0) ^ (seed | 0), 374761393) + Math.imul((y | 0) ^ ((seed >>> 1) | 0), 668265263);
+  h = (h ^ (h >>> 13)) >>> 0;
+  h = Math.imul(h, 1274126177) >>> 0;
+  return ((h ^ (h >>> 16)) >>> 0) / 4294967295;
+}
+
+function rand(seed, n) {
+  return hash2(n * 7919 + 17, n * 104729 + 31, seed);
+}
+
+function smoothstep(t) {
+  t = clamp(t);
+  return t * t * (3 - 2 * t);
+}
+
+function lerp(a, b, t) {
+  return a + (b - a) * t;
+}
+
+function valueNoise(x, y, seed, scale) {
+  const sx = x / scale;
+  const sy = y / scale;
+  const x0 = Math.floor(sx);
+  const y0 = Math.floor(sy);
+  const tx = smoothstep(sx - x0);
+  const ty = smoothstep(sy - y0);
+
+  const a = hash2(x0, y0, seed);
+  const b = hash2(x0 + 1, y0, seed);
+  const c = hash2(x0, y0 + 1, seed);
+  const d = hash2(x0 + 1, y0 + 1, seed);
+
+  return lerp(lerp(a, b, tx), lerp(c, d, tx), ty);
+}
+
+function fbm(x, y, seed) {
+  let amp = 1;
+  let scale = 54;
+  let sum = 0;
+  let norm = 0;
+  for (let i = 0; i < 5; i++) {
+    sum += valueNoise(x, y, seed + i * 101, scale) * amp;
+    norm += amp;
+    amp *= 0.5;
+    scale *= 0.5;
+  }
+  return sum / norm;
+}
+
+function neighbors8(x, y) {
+  const out = [];
+  for (let dy = -1; dy <= 1; dy++) {
+    for (let dx = -1; dx <= 1; dx++) {
+      if (dx === 0 && dy === 0) continue;
+      const nx = x + dx;
+      const ny = y + dy;
+      if (inside(nx, ny)) out.push([nx, ny, Math.hypot(dx, dy)]);
+    }
+  }
+  return out;
+}
+
+function distanceToNearest(points, x, y, fallback = 999) {
+  let best = fallback;
+  for (const p of points) best = Math.min(best, Math.hypot(p.x - x, p.y - y));
+  return best;
+}
+
+function pickEntities(candidates, { max = 99, minDistance = 5, threshold = 0, seed = 0, jitter = 0.04 } = {}) {
+  const sorted = candidates
+    .filter((p) => Number.isFinite(p.score) && p.score >= threshold)
+    .map((p) => ({ ...p, score: p.score + hash2(p.x, p.y, seed + 54321) * jitter }))
+    .sort((a, b) => b.score - a.score);
+
+  const out = [];
+  for (const candidate of sorted) {
+    if (out.every((p) => Math.hypot(p.x - candidate.x, p.y - candidate.y) >= minDistance)) {
+      out.push(candidate);
+      if (out.length >= max) break;
+    }
+  }
+  return out;
+}
+
+class MinHeap {
+  constructor() { this.items = []; }
+  push(item) {
+    this.items.push(item);
+    let i = this.items.length - 1;
+    while (i > 0) {
+      const parent = (i - 1) >> 1;
+      if (this.items[parent].f <= item.f) break;
+      this.items[i] = this.items[parent];
+      i = parent;
+    }
+    this.items[i] = item;
+  }
+  pop() {
+    if (this.items.length === 0) return null;
+    const root = this.items[0];
+    const last = this.items.pop();
+    if (this.items.length > 0) {
+      let i = 0;
+      while (true) {
+        const left = i * 2 + 1;
+        const right = left + 1;
+        if (left >= this.items.length) break;
+        const child = right < this.items.length && this.items[right].f < this.items[left].f ? right : left;
+        if (this.items[child].f >= last.f) break;
+        this.items[i] = this.items[child];
+        i = child;
+      }
+      this.items[i] = last;
+    }
+    return root;
+  }
+  get length() { return this.items.length; }
+}
+
+function aStar(start, goal, costAt) {
+  const startIndex = indexOf(start.x, start.y);
+  const goalIndex = indexOf(goal.x, goal.y);
+  if (startIndex === goalIndex) return [[start.x, start.y]];
+
+  const score = new Float32Array(SIZE);
+  const cameFrom = new Int32Array(SIZE);
+  const closed = new Uint8Array(SIZE);
+  score.fill(INF);
+  cameFrom.fill(-1);
+
+  const heap = new MinHeap();
+  score[startIndex] = 0;
+  heap.push({ i: startIndex, f: Math.hypot(start.x - goal.x, start.y - goal.y) });
+
+  let guard = 0;
+  while (heap.length > 0 && guard++ < SIZE * 3) {
+    const current = heap.pop();
+    if (!current || closed[current.i]) continue;
+    closed[current.i] = 1;
+
+    if (current.i === goalIndex) {
+      const path = [];
+      let p = goalIndex;
+      while (p !== -1) {
+        const [x, y] = xyOf(p);
+        path.push([x, y]);
+        if (p === startIndex) break;
+        p = cameFrom[p];
+      }
+      return path.reverse();
+    }
+
+    const [cx, cy] = xyOf(current.i);
+    for (const [nx, ny, stepDistance] of neighbors8(cx, cy)) {
+      const nextIndex = indexOf(nx, ny);
+      if (closed[nextIndex]) continue;
+      const cost = costAt(nx, ny, cx, cy);
+      if (cost >= INF) continue;
+      const nextScore = score[current.i] + cost * stepDistance;
+      if (nextScore < score[nextIndex]) {
+        score[nextIndex] = nextScore;
+        cameFrom[nextIndex] = current.i;
+        heap.push({ i: nextIndex, f: nextScore + Math.hypot(nx - goal.x, ny - goal.y) * 0.78 });
+      }
+    }
+  }
+  return [];
+}
+
+function influenceFromPaths(paths, radius) {
+  const grid = new Float32Array(SIZE);
+  for (const path of paths) {
+    for (const [x, y] of path) {
+      for (let dy = -radius; dy <= radius; dy++) {
+        for (let dx = -radius; dx <= radius; dx++) {
+          const nx = x + dx;
+          const ny = y + dy;
+          if (!inside(nx, ny)) continue;
+          const d = Math.hypot(dx, dy);
+          if (d > radius) continue;
+          const i = indexOf(nx, ny);
+          grid[i] = Math.max(grid[i], 1 / (1 + d));
+        }
+      }
+    }
+  }
+  return grid;
+}
+
+function pointKey(p) {
+  return `${p.x},${p.y}`;
+}
+
+function getDegree(degreeMap, p) {
+  return degreeMap.get(pointKey(p)) || 0;
+}
+
+function incrementDegree(degreeMap, p) {
+  degreeMap.set(pointKey(p), getDegree(degreeMap, p) + 1);
+}
+
+function nearestConnectable(points, target, degreeMap, maxDegree = 3) {
+  if (!points.length) return null;
+  const sorted = points
+    .map((p) => ({ ...p, d: Math.hypot(p.x - target.x, p.y - target.y), degree: getDegree(degreeMap, p) }))
+    .sort((a, b) => (a.degree >= maxDegree ? 22 : 0) + a.d + a.degree * 7 - ((b.degree >= maxDegree ? 22 : 0) + b.d + b.degree * 7));
+  return sorted.find((p) => p.degree < maxDegree) || sorted[0];
+}
+
+function corridorPenalty(grid, x, y, hubs, endpoints, strength = 6) {
+  if (!grid) return 0;
+  const value = grid[indexOf(x, y)];
+  if (value <= 0.0001) return 0;
+
+  const nearEndpoint = distanceToNearest(endpoints, x, y) <= 3.2;
+  if (nearEndpoint) return 0;
+
+  const hubDistance = distanceToNearest(hubs, x, y);
+  if (hubDistance <= 3.5) return 0;
+  if (hubDistance <= 7.5) return value * strength * 0.28;
+  return value * strength;
+}
+
+function nodeAvoidPenalty(points, x, y, endpoints, radius = 3.0, strength = 5.0) {
+  if (!points || points.length === 0) return 0;
+  if (distanceToNearest(endpoints, x, y) <= radius + 0.4) return 0;
+  const d = distanceToNearest(points, x, y);
+  if (d >= radius) return 0;
+  return (radius - d) * strength;
+}
+
+function makeTransportCost(baseCost, existingPaths, hubs, endpoints, radius = 4, strength = 6, avoidPoints = [], avoidRadius = 3.0, avoidStrength = 5.0) {
+  const grid = existingPaths.length ? influenceFromPaths(existingPaths, radius) : null;
+  return (x, y, cx, cy) => {
+    const base = baseCost(x, y, cx, cy);
+    if (base >= INF) return base;
+    return base
+      + corridorPenalty(grid, x, y, hubs, endpoints, strength)
+      + nodeAvoidPenalty(avoidPoints, x, y, endpoints, avoidRadius, avoidStrength);
+  };
+}
+
+function pathLength(path) {
+  let total = 0;
+  for (let i = 1; i < path.length; i++) total += Math.hypot(path[i][0] - path[i - 1][0], path[i][1] - path[i - 1][1]);
+  return total;
+}
+
+function pathEndpointDistance(path) {
+  if (!path || path.length < 2) return 0;
+  const a = path[0];
+  const b = path[path.length - 1];
+  return Math.hypot(a[0] - b[0], a[1] - b[1]);
+}
+
+function pathCompactness(path) {
+  const direct = pathEndpointDistance(path);
+  if (direct <= 0.001) return INF;
+  return pathLength(path) / direct;
+}
+
+function pathOverlapRatio(path, existingPaths, radius = 2) {
+  if (!path?.length || !existingPaths?.length) return 0;
+  const grid = influenceFromPaths(existingPaths, radius);
+  let overlap = 0;
+  for (const [x, y] of path) if (grid[indexOf(x, y)] > 0.18) overlap++;
+  return overlap / Math.max(1, path.length);
+}
+
+function compactPathArray(paths, { minLength = 8, maxOverlap = 0.35, maxCount = 99 } = {}) {
+  const kept = [];
+  for (const path of paths.slice().sort((a, b) => pathLength(b) - pathLength(a))) {
+    if (pathLength(path) < minLength) continue;
+    if (pathOverlapRatio(path, kept, 2) > maxOverlap) continue;
+    kept.push(path);
+    if (kept.length >= maxCount) break;
+  }
+  paths.splice(0, paths.length, ...kept);
+}
+
+function bresenhamCells(a, b) {
+  const cells = [];
+  let x0 = a[0];
+  let y0 = a[1];
+  const x1 = b[0];
+  const y1 = b[1];
+  const dx = Math.abs(x1 - x0);
+  const dy = Math.abs(y1 - y0);
+  const sx = x0 < x1 ? 1 : -1;
+  const sy = y0 < y1 ? 1 : -1;
+  let err = dx - dy;
+  while (true) {
+    cells.push([x0, y0]);
+    if (x0 === x1 && y0 === y1) break;
+    const e2 = 2 * err;
+    if (e2 > -dy) { err -= dy; x0 += sx; }
+    if (e2 < dx) { err += dx; y0 += sy; }
+  }
+  return cells;
+}
+
+function smoothPathByLineOfSight(path, passable, maxSegment = 9) {
+  if (!path || path.length < 3) return path || [];
+  const out = [path[0]];
+  let i = 0;
+  while (i < path.length - 1) {
+    let best = i + 1;
+    const limit = Math.min(path.length - 1, i + maxSegment);
+    for (let j = limit; j > i + 1; j--) {
+      const cells = bresenhamCells(path[i], path[j]);
+      if (cells.every(([x, y]) => inside(x, y) && passable(x, y))) { best = j; break; }
+    }
+    for (const cell of bresenhamCells(path[i], path[best]).slice(1)) out.push(cell);
+    i = best;
+  }
+  return out;
+}
+
+function averagePathField(path, field) {
+  if (!path?.length) return 0;
+  let sum = 0;
+  for (const [x, y] of path) sum += field[indexOf(x, y)] || 0;
+  return sum / path.length;
+}
+
+function influenceFromPoints(points, radius, weightFn = () => 1) {
+  const grid = new Float32Array(SIZE);
+  for (const p of points) {
+    const weight = weightFn(p);
+    for (let dy = -radius; dy <= radius; dy++) {
+      for (let dx = -radius; dx <= radius; dx++) {
+        const nx = p.x + dx;
+        const ny = p.y + dy;
+        if (!inside(nx, ny)) continue;
+        const d = Math.hypot(dx, dy);
+        if (d > radius) continue;
+        const i = indexOf(nx, ny);
+        grid[i] = Math.max(grid[i], weight / (1 + d));
+      }
+    }
+  }
+  return grid;
+}
+
+function samplePath(path, step) {
+  const out = [];
+  for (let i = step; i < path.length - step; i += step) {
+    const [x, y] = path[i];
+    out.push({ x, y, score: 1 });
+  }
+  return out;
+}
+
+function smoothMask(mask, passes = 2) {
+  let current = new Uint8Array(mask);
+  for (let pass = 0; pass < passes; pass++) {
+    const next = new Uint8Array(current);
+    for (let y = 1; y < MAP_H - 1; y++) {
+      for (let x = 1; x < MAP_W - 1; x++) {
+        const i = indexOf(x, y);
+        let count = 0;
+        for (let dy = -1; dy <= 1; dy++) {
+          for (let dx = -1; dx <= 1; dx++) {
+            if (current[indexOf(x + dx, y + dy)]) count++;
+          }
+        }
+        if (count >= 5) next[i] = 1;
+        else if (count <= 3) next[i] = 0;
+      }
+    }
+    current = next;
+  }
+  return current;
+}
+
+function largestConnectedMask(mask) {
+  const seen = new Uint8Array(SIZE);
+  let best = [];
+  const queue = [];
+
+  for (let i = 0; i < SIZE; i++) {
+    if (!mask[i] || seen[i]) continue;
+    const component = [];
+    queue.length = 0;
+    queue.push(i);
+    seen[i] = 1;
+
+    for (let q = 0; q < queue.length; q++) {
+      const cur = queue[q];
+      component.push(cur);
+      const [x, y] = xyOf(cur);
+      for (const [nx, ny] of neighbors8(x, y)) {
+        const ni = indexOf(nx, ny);
+        if (!mask[ni] || seen[ni]) continue;
+        seen[ni] = 1;
+        queue.push(ni);
+      }
+    }
+
+    if (component.length > best.length) best = component;
+  }
+
+  const out = new Uint8Array(SIZE);
+  for (const i of best) out[i] = 1;
+  return out;
+}
+
+function componentCount(mask) {
+  const seen = new Uint8Array(SIZE);
+  const queue = [];
+  let count = 0;
+  for (let i = 0; i < SIZE; i++) {
+    if (!mask[i] || seen[i]) continue;
+    count++;
+    queue.length = 0;
+    queue.push(i);
+    seen[i] = 1;
+    for (let q = 0; q < queue.length; q++) {
+      const [x, y] = xyOf(queue[q]);
+      for (const [nx, ny] of neighbors8(x, y)) {
+        const ni = indexOf(nx, ny);
+        if (!mask[ni] || seen[ni]) continue;
+        seen[ni] = 1;
+        queue.push(ni);
+      }
+    }
+  }
+  return count;
+}
+
+
+function makePrefectureMask(seed, sea, elevation, slope, river) {
+  const candidates = [];
+  for (let y = 8; y < MAP_H - 8; y++) {
+    for (let x = 8; x < MAP_W - 8; x++) {
+      const i = indexOf(x, y);
+      if (sea[i]) continue;
+      const centrality = 1 - Math.hypot((x / MAP_W) - 0.5, (y / MAP_H) - 0.5) / 0.72;
+      const score = centrality * 0.28 + (1 - slope[i]) * 0.42 + (1 - Math.abs(elevation[i] - 0.42)) * 0.22 + Math.min(0.16, river[i] * 0.08);
+      candidates.push({ x, y, score });
+    }
+  }
+
+  const regionSeeds = pickEntities(candidates, {
+    max: 1,
+    minDistance: 18,
+    threshold: 0.35,
+    seed: seed + 904,
+    jitter: 0.02,
+  });
+
+  const mask = new Uint8Array(SIZE);
+  const dist = new Float32Array(SIZE);
+  dist.fill(INF);
+  const heap = new MinHeap();
+  const landCells = sea.reduce((a, v) => a + (v ? 0 : 1), 0);
+  const target = Math.floor(landCells * (0.23 + rand(seed, 906) * 0.08));
+
+  for (const s of regionSeeds) {
+    const i = indexOf(s.x, s.y);
+    dist[i] = 0;
+    heap.push({ i, f: 0 });
+  }
+
+  let claimed = 0;
+  while (heap.length > 0 && claimed < target) {
+    const current = heap.pop();
+    if (!current) continue;
+    const ci = current.i;
+    if (current.f > dist[ci] + 1e-5 || mask[ci]) continue;
+    const [cx, cy] = xyOf(ci);
+    if (sea[ci]) continue;
+
+    mask[ci] = 1;
+    claimed++;
+
+    for (const [nx, ny, step] of neighbors8(cx, cy)) {
+      const ni = indexOf(nx, ny);
+      if (sea[ni] || mask[ni]) continue;
+      const edgePenalty = nearMapEdge(nx, ny, 2) ? 4.2 : nearMapEdge(nx, ny, 5) ? 1.8 : 0;
+      const ridgePenalty = Math.max(0, elevation[ni] - 0.5) * 5.4 + Math.max(0, elevation[ni] - elevation[ci]) * 3.2;
+      const slopePenalty = slope[ni] * 4.1;
+      const riverPenalty = river[ni] > 0.65 ? 2.2 : river[ni] > 0.32 ? 0.9 : 0;
+      const cost = Math.max(0.18, 1 + edgePenalty + ridgePenalty + slopePenalty + riverPenalty + Math.abs(elevation[ni] - elevation[ci]) * 4.2) * step;
+      const nd = dist[ci] + cost;
+      if (nd < dist[ni]) {
+        dist[ni] = nd;
+        heap.push({ i: ni, f: nd });
+      }
+    }
+  }
+
+  return largestConnectedMask(smoothMask(mask, 2));
+}
+
+function generateRegionalPrefectures(seed, sea, elevation, slope, river, ridgeField, flowAccum, anchorMask) {
+  const centers = [];
+  let sx = 0;
+  let sy = 0;
+  let sc = 0;
+  for (let y = 0; y < MAP_H; y++) {
+    for (let x = 0; x < MAP_W; x++) {
+      const i = indexOf(x, y);
+      if (anchorMask[i]) { sx += x; sy += y; sc++; }
+    }
+  }
+  if (sc > 0) centers.push({ x: Math.round(sx / sc), y: Math.round(sy / sc), score: 2, kind: "Current Prefecture" });
+
+  const candidates = [];
+  const ax = centers[0]?.x ?? MAP_W / 2;
+  const ay = centers[0]?.y ?? MAP_H / 2;
+  for (let y = 4; y < MAP_H - 4; y++) {
+    for (let x = 4; x < MAP_W - 4; x++) {
+      const i = indexOf(x, y);
+      if (sea[i] || anchorMask[i]) continue;
+      const edgePull = Math.max(Math.abs(x / MAP_W - 0.5), Math.abs(y / MAP_H - 0.5));
+      const awayFromCurrent = Math.hypot(x - ax, y - ay) / Math.hypot(MAP_W, MAP_H);
+      const settleable = (1 - slope[i]) * 0.24 + Math.max(0, 0.62 - elevation[i]) * 0.28 + flowAccum[i] * 0.08;
+      const score = edgePull * 0.55 + awayFromCurrent * 0.38 + settleable + hash2(x, y, seed + 6100) * 0.06;
+      candidates.push({ x, y, score, kind: "Neighbor Prefecture" });
+    }
+  }
+  centers.push(...pickEntities(candidates, {
+    max: 9 + Math.floor(rand(seed, 6101) * 6),
+    minDistance: 22,
+    threshold: 0.38,
+    seed: seed + 6102,
+    jitter: 0.02,
+  }));
+
+  const regionId = new Int16Array(SIZE);
+  regionId.fill(-1);
+  const dist = new Float32Array(SIZE);
+  dist.fill(INF);
+  const heap = new MinHeap();
+  centers.forEach((center, id) => {
+    const i = indexOf(center.x, center.y);
+    if (sea[i]) return;
+    regionId[i] = id;
+    dist[i] = 0;
+    heap.push({ i, f: 0 });
+  });
+
+  let guard = 0;
+  while (heap.length > 0 && guard++ < SIZE * 16) {
+    const cur = heap.pop();
+    if (!cur || cur.f > dist[cur.i] + 1e-5) continue;
+    const [cx, cy] = xyOf(cur.i);
+    const curRegion = regionId[cur.i];
+    for (const [nx, ny, step] of neighbors8(cx, cy)) {
+      const ni = indexOf(nx, ny);
+      if (sea[ni]) continue;
+      const ridge = Math.max(ridgeField[ni], ridgeField[cur.i]);
+      const riverBarrier = Math.max(river[ni], river[cur.i]);
+      const divide = ridge * 7.8 + Math.max(0, elevation[ni] - 0.54) * 4.4 + slope[ni] * 3.8;
+      const watershed = Math.max(0, flowAccum[cur.i] - flowAccum[ni]) * 0.7;
+      const riverCost = riverBarrier > 0.72 ? 4.6 : riverBarrier > 0.35 ? 1.9 : 0;
+      const stepCost = Math.max(0.22, 1 + divide + riverCost + watershed + Math.abs(elevation[ni] - elevation[cur.i]) * 3.2) * step;
+      const nd = dist[cur.i] + stepCost;
+      if (nd < dist[ni]) {
+        dist[ni] = nd;
+        regionId[ni] = curRegion;
+        heap.push({ i: ni, f: nd });
+      }
+    }
+  }
+  return { regionId, centers };
+}
+
+function extractRegionBorderSegments(regionId, sea) {
+  const segments = [];
+  for (let y = 0; y < MAP_H; y++) {
+    for (let x = 0; x < MAP_W; x++) {
+      const i = indexOf(x, y);
+      if (sea[i] || regionId[i] < 0) continue;
+      const a = regionId[i];
+      if (x + 1 < MAP_W && !sea[indexOf(x + 1, y)]) {
+        const b = regionId[indexOf(x + 1, y)];
+        if (b >= 0 && a !== b) segments.push([[x + 1, y], [x + 1, y + 1]]);
+      }
+      if (y + 1 < MAP_H && !sea[indexOf(x, y + 1)]) {
+        const b = regionId[indexOf(x, y + 1)];
+        if (b >= 0 && a !== b) segments.push([[x, y + 1], [x + 1, y + 1]]);
+      }
+    }
+  }
+  return segments;
+}
+
+function extractMaskBorder(mask, sea = null) {
+  const segments = [];
+  for (let y = 0; y < MAP_H; y++) {
+    for (let x = 0; x < MAP_W; x++) {
+      const i = indexOf(x, y);
+      const a = mask[i];
+      if (x + 1 < MAP_W) {
+        const ni = indexOf(x + 1, y);
+        const b = mask[ni];
+        if (a !== b && !(sea && (sea[i] || sea[ni]))) segments.push([[x + 1, y], [x + 1, y + 1]]);
+      }
+      if (y + 1 < MAP_H) {
+        const ni = indexOf(x, y + 1);
+        const b = mask[ni];
+        if (a !== b && !(sea && (sea[i] || sea[ni]))) segments.push([[x, y + 1], [x + 1, y + 1]]);
+      }
+    }
+  }
+  return segments;
+}
+
+function extractAdminBorderSegments(adminId, prefectureMask) {
+  const segments = [];
+  for (let y = 0; y < MAP_H; y++) {
+    for (let x = 0; x < MAP_W; x++) {
+      const i = indexOf(x, y);
+      if (!prefectureMask[i]) continue;
+      const a = adminId[i];
+      if (a < 0) continue;
+      if (x + 1 < MAP_W && prefectureMask[indexOf(x + 1, y)]) {
+        const b = adminId[indexOf(x + 1, y)];
+        if (b >= 0 && a !== b) segments.push([[x + 1, y], [x + 1, y + 1]]);
+      }
+      if (y + 1 < MAP_H && prefectureMask[indexOf(x, y + 1)]) {
+        const b = adminId[indexOf(x, y + 1)];
+        if (b >= 0 && a !== b) segments.push([[x, y + 1], [x + 1, y + 1]]);
+      }
+    }
+  }
+  return segments;
+}
+
+function tagInsidePrefecture(points, prefectureMask) {
+  return points.map((p) => ({ ...p, insidePrefecture: Boolean(prefectureMask[indexOf(p.x, p.y)]) }));
+}
+
+function defaultName(seed, id, kind) {
+  const prefixKey = id.split("-")[0];
+  const n = Number(id.split("-")[1] || 0);
+  const prefixes = NAME_PARTS.prefixes || [""];
+  const infixes = NAME_PARTS.infixes || [""];
+  const suffixes = NAME_PARTS.suffixes || [""];
+  const prefix = prefixes[(seed + n * 7) % prefixes.length];
+  const useInfix = hash2(n + prefixKey.length * 17, seed + n * 31, seed + 2777) >= 0.7;
+  const infix = useInfix ? infixes[(seed * 3 + n * 11) % infixes.length] : "";
+  const suffixWord = suffixes[(seed * 5 + n * 13 + prefixKey.length) % suffixes.length];
+  const kindSuffix = KIND_SUFFIXES[prefixKey] || kind || "";
+  return `${prefix}${infix}${suffixWord}${kindSuffix}`;
+}
+
+function attachIdsAndNames(points, prefix, seed, kindOverride = null) {
+  return points.map((p, i) => {
+    const id = `${prefix}-${i}`;
+    const kind = kindOverride || p.kind;
+    return {
+      ...p,
+      id,
+      name: CUSTOM_NAMES[id] || defaultName(seed + prefix.length * 1000, id, kind),
+      insidePrefecture: Boolean(p.insidePrefecture),
+    };
+  });
+}
+
+function generateAdminRegions(centers, prefectureMask, sea, elevation, slope, river, ridgeField, valleyField, populationDensity, landuse) {
+  const adminId = new Int16Array(SIZE);
+  adminId.fill(-1);
+  const dist = new Float32Array(SIZE);
+  dist.fill(INF);
+  const heap = new MinHeap();
+
+  centers.forEach((center, regionId) => {
+    const i = indexOf(center.x, center.y);
+    dist[i] = 0;
+    adminId[i] = regionId;
+    heap.push({ i, f: 0, regionId });
+  });
+
+  let guard = 0;
+  while (heap.length > 0 && guard++ < SIZE * 12) {
+    const current = heap.pop();
+    if (!current) continue;
+    const curIndex = current.i;
+    const curRegion = adminId[curIndex];
+    if (curRegion < 0) continue;
+    if (current.f > dist[curIndex] + 1e-5) continue;
+
+    const [cx, cy] = xyOf(curIndex);
+    for (const [nx, ny, step] of neighbors8(cx, cy)) {
+      const ni = indexOf(nx, ny);
+      if (!prefectureMask[ni] || sea[ni]) continue;
+
+      const ridgeBarrier = Math.max(ridgeField[ni], ridgeField[curIndex]);
+      const riverBarrier = Math.max(river[ni], river[curIndex]);
+      const ridgePenalty = Math.max(0, elevation[ni] - 0.40) * 9.4 + Math.abs(elevation[ni] - elevation[curIndex]) * 8.8 + ridgeBarrier * 14.2;
+      const slopePenalty = slope[ni] * 7.8;
+      const riverPenalty = riverBarrier > 0.7 ? 13.0 : riverBarrier > 0.42 ? 8.2 : riverBarrier > 0.22 ? 3.8 : 0;
+      const urbanContinuityBonus = (landuse[ni] >= 2 && landuse[ni] <= 4 && populationDensity[ni] > 0.20) ? 1.95 : 0;
+      const valleyLocalityBonus = valleyField[ni] * 0.03;
+      const stepCost = Math.max(0.25, 0.72 + ridgePenalty + slopePenalty + riverPenalty - valleyLocalityBonus - urbanContinuityBonus) * step;
+      const nextDist = dist[curIndex] + stepCost;
+
+      if (nextDist < dist[ni]) {
+        dist[ni] = nextDist;
+        adminId[ni] = curRegion;
+        heap.push({ i: ni, f: nextDist, regionId: curRegion });
+      }
+    }
+  }
+
+  return adminId;
+}
+
+function terrainBoundaryStrength(i, elevation, slope, river, ridgeField, valleyField) {
+  return clamp(
+    ridgeField[i] * 2.75 +
+    river[i] * 2.05 +
+    slope[i] * 1.18 +
+    Math.max(0, elevation[i] - 0.5) * 1.05 -
+    valleyField[i] * 0.10
+  );
+}
+
+function smoothAdminRegionsTerrainAware(adminId, prefectureMask, sea, elevation, slope, river, ridgeField, valleyField, populationDensity, landuse, passes = 5) {
+  let current = new Int16Array(adminId);
+  for (let pass = 0; pass < passes; pass++) {
+    const next = new Int16Array(current);
+    for (let y = 1; y < MAP_H - 1; y++) {
+      for (let x = 1; x < MAP_W - 1; x++) {
+        const i = indexOf(x, y);
+        const own = current[i];
+        if (!prefectureMask[i] || sea[i] || own < 0) continue;
+        const urbanCell = (landuse[i] >= 2 && landuse[i] <= 4) || landuse[i] === 7 || populationDensity[i] > 0.24;
+        const barrier = terrainBoundaryStrength(i, elevation, slope, river, ridgeField, valleyField);
+        if (barrier > 0.62 || urbanCell) continue;
+
+        const counts = new Map();
+        let ownCount = 0;
+        for (const [nx, ny] of neighbors8(x, y)) {
+          const ni = indexOf(nx, ny);
+          if (!prefectureMask[ni] || sea[ni]) continue;
+          const id = current[ni];
+          if (id < 0) continue;
+          const weight = terrainBoundaryStrength(ni, elevation, slope, river, ridgeField, valleyField) > 0.72 ? 0.45 : 1;
+          counts.set(id, (counts.get(id) || 0) + weight);
+          if (id === own) ownCount += weight;
+        }
+        let bestId = own;
+        let best = ownCount;
+        for (const [id, score] of counts) {
+          if (score > best) { best = score; bestId = id; }
+        }
+        if (bestId !== own && (best >= 4.2 || ownCount <= 2.1)) next[i] = bestId;
+      }
+    }
+    current = next;
+  }
+  adminId.set(current);
+}
+
+function lockSmallUrbanComponentsToMunicipality(adminId, prefectureMask, sea, landuse, populationDensity, maxCells = 360) {
+  const seen = new Uint8Array(SIZE);
+  const queue = [];
+  for (let i = 0; i < SIZE; i++) {
+    if (seen[i] || !prefectureMask[i] || sea[i]) continue;
+    const isUrbanStart = (landuse[i] >= 2 && landuse[i] <= 4) || landuse[i] === 7 || landuse[i] === 8 || populationDensity[i] > 0.20;
+    if (!isUrbanStart) continue;
+    const component = [];
+    queue.length = 0;
+    queue.push(i);
+    seen[i] = 1;
+    for (let q = 0; q < queue.length; q++) {
+      const cur = queue[q];
+      component.push(cur);
+      const [x, y] = xyOf(cur);
+      for (const [nx, ny] of neighbors8(x, y)) {
+        const ni = indexOf(nx, ny);
+        if (seen[ni] || !prefectureMask[ni] || sea[ni]) continue;
+        const isUrban = (landuse[ni] >= 2 && landuse[ni] <= 4) || landuse[ni] === 7 || landuse[ni] === 8 || populationDensity[ni] > 0.20;
+        if (!isUrban) continue;
+        seen[ni] = 1;
+        queue.push(ni);
+      }
+    }
+    if (component.length === 0 || component.length > maxCells) continue;
+    const counts = new Map();
+    for (const ci of component) {
+      const id = adminId[ci];
+      if (id >= 0) counts.set(id, (counts.get(id) || 0) + 1 + populationDensity[ci]);
+    }
+    let bestId = -1;
+    let best = -1;
+    for (const [id, score] of counts) {
+      if (score > best) { best = score; bestId = id; }
+    }
+    if (bestId >= 0) for (const ci of component) adminId[ci] = bestId;
+  }
+}
+
+
+function mergeTinyMunicipalities(adminId, prefectureMask, sea, populationDensity, modernCities = [], minArea = 320) {
+  const area = new Map();
+  const pop = new Map();
+  const adjacency = new Map();
+  const cityMunicipalities = new Set();
+  for (const city of modernCities || []) {
+    if (inside(city.x, city.y)) cityMunicipalities.add(adminId[indexOf(city.x, city.y)]);
+  }
+  for (let y = 0; y < MAP_H; y++) {
+    for (let x = 0; x < MAP_W; x++) {
+      const i = indexOf(x, y);
+      if (!prefectureMask[i] || sea[i]) continue;
+      const id = adminId[i];
+      if (id < 0) continue;
+      area.set(id, (area.get(id) || 0) + 1);
+      pop.set(id, (pop.get(id) || 0) + populationDensity[i]);
+      for (const [nx, ny] of [[x+1,y],[x,y+1]]) {
+        if (!inside(nx, ny)) continue;
+        const ni = indexOf(nx, ny);
+        if (!prefectureMask[ni] || sea[ni]) continue;
+        const other = adminId[ni];
+        if (other < 0 || other === id) continue;
+        const key = id < other ? `${id}:${other}` : `${other}:${id}`;
+        adjacency.set(key, (adjacency.get(key) || 0) + 1);
+      }
+    }
+  }
+  const mergeTarget = new Map();
+  for (const [id, cells] of area) {
+    const score = cells + (pop.get(id) || 0) * 16;
+    if (cells >= minArea || cityMunicipalities.has(id)) continue;
+    let bestNeighbor = -1;
+    let bestScore = -1;
+    for (const [key, border] of adjacency) {
+      const [a, b] = key.split(':').map(Number);
+      if (a !== id && b !== id) continue;
+      const other = a === id ? b : a;
+      const otherArea = area.get(other) || 0;
+      const otherPop = pop.get(other) || 0;
+      const candidate = border * 3 + otherArea * 0.012 + otherPop * 0.24;
+      if (candidate > bestScore) {
+        bestScore = candidate;
+        bestNeighbor = other;
+      }
+    }
+    if (bestNeighbor >= 0 && (area.get(bestNeighbor) || 0) >= score * 0.35) mergeTarget.set(id, bestNeighbor);
+  }
+  if (mergeTarget.size === 0) return;
+  for (let i = 0; i < SIZE; i++) {
+    const id = adminId[i];
+    if (mergeTarget.has(id)) adminId[i] = mergeTarget.get(id);
+  }
+}
+
+export function generateMap(seedInput = 114514) {
+  const seed = Number(seedInput) >>> 0;
+
+  let prefectureMask;
+  let prefectureBorder;
+
+  const elevation = new Float32Array(SIZE);
+  const moisture = new Float32Array(SIZE);
+  const slope = new Float32Array(SIZE);
+  const sea = new Uint8Array(SIZE);
+  const river = new Float32Array(SIZE);
+  const floodplain = new Float32Array(SIZE);
+  const plain = new Float32Array(SIZE);
+  const agriculture = new Float32Array(SIZE);
+  const ridgeField = new Float32Array(SIZE);
+  const valleyField = new Float32Array(SIZE);
+  const basinField = new Float32Array(SIZE);
+  const coastalLowland = new Float32Array(SIZE);
+  const flowAccum = new Float32Array(SIZE);
+  const erosionField = new Float32Array(SIZE);
+  const depositionField = new Float32Array(SIZE);
+  const flowTo = new Int32Array(SIZE);
+  flowTo.fill(-1);
+  const portSuitability = new Float32Array(SIZE);
+  const crossingSuitability = new Float32Array(SIZE);
+  const passSuitability = new Float32Array(SIZE);
+
+  const coastAngle = rand(seed, 11) * Math.PI * 2;
+  const coastX = Math.cos(coastAngle);
+  const coastY = Math.sin(coastAngle);
+  const coastThreshold = 0.22 + rand(seed, 12) * 0.22;
+  const coastStrength = 0.15 + rand(seed, 13) * 0.23;
+
+  const seaLevel = 0.285;
+
+  const mountainBlobs = Array.from({ length: 2 + Math.floor(rand(seed, 98) * 3) }, (_, i) => ({
+    x: rand(seed, 100 + i) * MAP_W,
+    y: rand(seed, 200 + i) * MAP_H,
+    r: 10 + rand(seed, 300 + i) * 24,
+    h: 0.08 + rand(seed, 400 + i) * 0.16,
+  }));
+
+  const ridgeBands = Array.from({ length: 5 + Math.floor(rand(seed, 97) * 4) }, (_, i) => ({
+    x: rand(seed, 1500 + i) * MAP_W,
+    y: rand(seed, 1600 + i) * MAP_H,
+    angle: rand(seed, 1700 + i) * Math.PI * 2,
+    width: 3 + rand(seed, 1800 + i) * 7,
+    length: 42 + rand(seed, 1900 + i) * 92,
+    h: 0.11 + rand(seed, 2000 + i) * 0.22,
+  }));
+
+  for (let y = 0; y < MAP_H; y++) {
+    for (let x = 0; x < MAP_W; x++) {
+      const nx = x / (MAP_W - 1) - 0.5;
+      const ny = y / (MAP_H - 1) - 0.5;
+      const i = indexOf(x, y);
+
+      const warpX = (fbm(x * 0.62 + 180, y * 0.62 - 90, seed + 3101) - 0.5) * 13;
+      const warpY = (fbm(x * 0.62 - 70, y * 0.62 + 210, seed + 3201) - 0.5) * 13;
+      const wx = x + warpX;
+      const wy = y + warpY;
+
+      let mountains = 0;
+      for (const blob of mountainBlobs) {
+        const d = Math.hypot(wx - blob.x, wy - blob.y) / blob.r;
+        mountains += Math.exp(-d * d * 2.35) * blob.h;
+      }
+
+      let ridges = 0;
+      for (const ridge of ridgeBands) {
+        const dx = wx - ridge.x;
+        const dy = wy - ridge.y;
+        const along = dx * Math.cos(ridge.angle) + dy * Math.sin(ridge.angle);
+        const perp = -dx * Math.sin(ridge.angle) + dy * Math.cos(ridge.angle);
+        const lengthFade = smoothstep(1 - Math.abs(along) / ridge.length);
+        const serration = 0.72 + valueNoise(wx + along * 0.15, wy + perp * 0.15, seed + 2220, 8) * 0.56;
+        ridges += Math.exp(-(perp * perp) / (ridge.width * ridge.width)) * lengthFade * ridge.h * serration;
+      }
+
+      const directionalCoast = nx * coastX + ny * coastY;
+      const coastWave = (fbm(wx * 0.72, wy * 0.72, seed + 2222) - 0.5) * 0.12 + (valueNoise(wx, wy, seed + 2233, 18) - 0.5) * 0.08;
+      const coastLower = smoothstep((directionalCoast + coastWave - coastThreshold) / 0.26);
+      // Four terrain-noise bands from continental structure to fine surface roughness.
+      const terrainLarge = fbm(wx * 0.36 + 40, wy * 0.36 - 60, seed + 710);
+      const terrainRegional = fbm(wx * 0.95 + 80, wy * 0.95 - 20, seed + 777);
+      const terrainLocal = fbm(wx * 2.05 + 17, wy * 2.05 - 31, seed + 1777);
+      const terrainFine = valueNoise(wx * 2.9 + 11, wy * 2.9 - 19, seed + 2444, 4.5);
+      const fineDissection = Math.abs(terrainLocal - 0.5) * 0.08 + Math.abs(terrainFine - 0.5) * 0.035;
+      const basin = 0.1 * Math.sin((nx * 3.1 + ny * 1.7 + rand(seed, 15)) * Math.PI) - 0.045 * Math.cos((nx * 5.2 - ny * 3.6 + rand(seed, 16)) * Math.PI);
+      const rawElevation =
+        0.30 * terrainLarge +
+        0.235 * terrainRegional +
+        0.105 * terrainLocal +
+        0.055 * terrainFine +
+        mountains * 0.54 +
+        ridges * 1.22 +
+        basin +
+        fineDissection -
+        coastLower * (coastStrength + 0.19) +
+        0.055;
+
+      elevation[i] = clamp(0.5 + (rawElevation - 0.5) * 1.26);
+      ridgeField[i] = clamp(ridges * 4.8 + Math.max(0, mountains - 0.10) * 0.95 + fineDissection * 2.0);
+      basinField[i] = clamp(Math.max(0, -basin) * 3.0 + (1 - coastLower) * Math.max(0, 0.42 - elevation[i]) * 0.7);
+      moisture[i] = clamp(0.44 * fbm(wx + 400, wy - 200, seed + 333) + 0.18 * valueNoise(wx, wy, seed + 343, 11) + 0.22 * (1 - Math.abs(ny * 1.7)) + 0.28 * coastLower - Math.max(0, elevation[i] - 0.62) * 0.22);
+    }
+  }
+
+  for (let y = 0; y < MAP_H; y++) {
+    for (let x = 0; x < MAP_W; x++) {
+      const i = indexOf(x, y);
+      const nx = x / (MAP_W - 1) - 0.5;
+      const ny = y / (MAP_H - 1) - 0.5;
+      const directionalCoast = nx * coastX + ny * coastY;
+      const coastNoise = (fbm(x * 0.95, y * 0.95, seed + 2222) - 0.5) * 0.14 + (valueNoise(x, y, seed + 2233, 13) - 0.5) * 0.08;
+      const oceanSide = directionalCoast + coastNoise > coastThreshold + 0.055;
+      if (elevation[i] < seaLevel || oceanSide) sea[i] = 1;
+      if (sea[i]) elevation[i] = Math.min(elevation[i], seaLevel - 0.018 + hash2(x, y, seed + 2311) * 0.012);
+    }
+  }
+
+  // Align coastal elevation with the sea mask. This prevents artificial one-cell cliffs
+  // when the directional coastline cuts through a high terrain cell.
+  for (let y = 0; y < MAP_H; y++) {
+    for (let x = 0; x < MAP_W; x++) {
+      const i = indexOf(x, y);
+      if (sea[i]) continue;
+      let nearestSea = INF;
+      for (let dy = -7; dy <= 7; dy++) {
+        for (let dx = -7; dx <= 7; dx++) {
+          const nx = x + dx;
+          const ny = y + dy;
+          if (!inside(nx, ny) || !sea[indexOf(nx, ny)]) continue;
+          nearestSea = Math.min(nearestSea, Math.hypot(dx, dy));
+        }
+      }
+      if (nearestSea <= 7) {
+        const coastalCap = seaLevel + 0.018 + nearestSea * 0.028 + Math.max(0, fbm(x * 1.4, y * 1.4, seed + 2350) - 0.5) * 0.022;
+        elevation[i] = Math.min(elevation[i], coastalCap);
+        coastalLowland[i] = clamp(1 - nearestSea / 7);
+      }
+    }
+  }
+
+  for (let y = 1; y < MAP_H - 1; y++) {
+    for (let x = 1; x < MAP_W - 1; x++) {
+      const gx = elevation[indexOf(x + 1, y)] - elevation[indexOf(x - 1, y)];
+      const gy = elevation[indexOf(x, y + 1)] - elevation[indexOf(x, y - 1)];
+      slope[indexOf(x, y)] = clamp(Math.sqrt(gx * gx + gy * gy) * 10.5);
+    }
+  }
+
+  const landOrder = [];
+  for (let y = 1; y < MAP_H - 1; y++) {
+    for (let x = 1; x < MAP_W - 1; x++) {
+      const i = indexOf(x, y);
+      if (sea[i]) continue;
+      let low = i;
+      let best = elevation[i] + 0.012 * hash2(x, y, seed + 2468);
+      let localMean = 0;
+      let localMax = elevation[i];
+      let localMin = elevation[i];
+      let nCount = 0;
+      for (const [nx, ny] of neighbors8(x, y)) {
+        const ni = indexOf(nx, ny);
+        const ev = elevation[ni];
+        localMean += ev;
+        localMax = Math.max(localMax, ev);
+        localMin = Math.min(localMin, ev);
+        nCount++;
+        const directed = ev + 0.008 * hash2(nx, ny, seed + 2469);
+        if (directed < best || sea[ni]) {
+          best = directed;
+          low = ni;
+        }
+      }
+      if (low !== i) flowTo[i] = low;
+      localMean /= Math.max(1, nCount);
+      const hollow = Math.max(0, localMean - elevation[i]);
+      const relief = localMax - localMin;
+      valleyField[i] = clamp(hollow * 8.4 + Math.max(0, 0.42 - elevation[i]) * 0.32 + moisture[i] * 0.08 - ridgeField[i] * 0.18);
+      basinField[i] = clamp(basinField[i] + hollow * 2.4 + (relief < 0.055 && elevation[i] < 0.55 ? 0.18 : 0));
+      flowAccum[i] = 0.7 + moisture[i] * 0.7 + valleyField[i] * 0.55;
+      landOrder.push(i);
+    }
+  }
+  landOrder.sort((a, b) => elevation[b] - elevation[a]);
+  for (const i of landOrder) {
+    const to = flowTo[i];
+    if (to >= 0 && to !== i) flowAccum[to] += flowAccum[i] * 0.82;
+  }
+  let maxFlowAccum = 0;
+  for (let i = 0; i < SIZE; i++) if (!sea[i]) maxFlowAccum = Math.max(maxFlowAccum, flowAccum[i]);
+  if (maxFlowAccum > 0) {
+    for (let i = 0; i < SIZE; i++) flowAccum[i] = clamp(flowAccum[i] / maxFlowAccum);
+  }
+  for (let i = 0; i < SIZE; i++) {
+    if (!sea[i]) valleyField[i] = clamp(valleyField[i] * 0.68 + Math.pow(flowAccum[i], 0.55) * 0.48);
+  }
+
+  // First-order fluvial shaping: cut valley floors on steep/high-flow cells and
+  // deposit gently in coastal lowlands and basin floors. This gives visible
+  // river valleys without destroying the macro terrain structure.
+  const shapedElevation = new Float32Array(elevation);
+  for (let y = 1; y < MAP_H - 1; y++) {
+    for (let x = 1; x < MAP_W - 1; x++) {
+      const i = indexOf(x, y);
+      if (sea[i]) continue;
+      const flow = Math.pow(flowAccum[i], 0.46);
+      const incisionNoise = 0.82 + hash2(x, y, seed + 8120) * 0.36;
+      const steepValley = clamp(flow * (0.058 + slope[i] * 0.21 + ridgeField[i] * 0.046) * incisionNoise);
+      const lateralCut = clamp(Math.pow(flowAccum[i], 0.66) * valleyField[i] * 0.078);
+      const lowSettling = clamp(flow * (coastalLowland[i] * 0.036 + basinField[i] * 0.020 + (elevation[i] < 0.40 ? 0.012 : 0)) * (1 - slope[i] * 0.82));
+      erosionField[i] = steepValley + lateralCut;
+      depositionField[i] = lowSettling;
+      shapedElevation[i] = clamp(elevation[i] - steepValley - lateralCut + lowSettling * 0.72, seaLevel + 0.006, 1);
+    }
+  }
+  elevation.set(shapedElevation);
+
+  for (let y = 1; y < MAP_H - 1; y++) {
+    for (let x = 1; x < MAP_W - 1; x++) {
+      const i = indexOf(x, y);
+      if (sea[i]) continue;
+      const gx = elevation[indexOf(x + 1, y)] - elevation[indexOf(x - 1, y)];
+      const gy = elevation[indexOf(x, y + 1)] - elevation[indexOf(x, y - 1)];
+      slope[i] = clamp(Math.sqrt(gx * gx + gy * gy) * 10.5);
+      valleyField[i] = clamp(valleyField[i] + erosionField[i] * 2.1 + depositionField[i] * 0.8 - ridgeField[i] * 0.06);
+      basinField[i] = clamp(basinField[i] + depositionField[i] * 1.6);
+    }
+  }
+
+  const sourceCandidates = [];
+  for (let y = 4; y < MAP_H - 4; y++) {
+    for (let x = 4; x < MAP_W - 4; x++) {
+      const i = indexOf(x, y);
+      if (sea[i]) continue;
+      const score = elevation[i] * 0.38 + moisture[i] * 0.24 + ridgeField[i] * 0.08 + flowAccum[i] * 0.56 + valleyField[i] * 0.28 + hash2(x, y, seed + 9000) * 0.06;
+      if (elevation[i] > 0.40 && elevation[i] < 0.82 && moisture[i] > 0.28 && flowAccum[i] > 0.020 && ridgeField[i] < 0.88) sourceCandidates.push({ x, y, score });
+    }
+  }
+
+  const sources = pickEntities(sourceCandidates, {
+    max: 20 + Math.floor(rand(seed, 910) * 28),
+    minDistance: 8,
+    threshold: 0.53 + rand(seed, 911) * 0.11,
+    seed,
+  });
+
+  function nearestWaterGoal(from) {
+    let bestSea = null;
+    let bestScore = INF;
+    for (let y = 0; y < MAP_H; y++) {
+      for (let x = 0; x < MAP_W; x++) {
+        const i = indexOf(x, y);
+        if (!sea[i]) continue;
+        const d = Math.hypot(x - from.x, y - from.y);
+        const score = d - coastalLowland[indexOf(Math.max(0, Math.min(MAP_W - 1, from.x)), Math.max(0, Math.min(MAP_H - 1, from.y)))] * 2;
+        if (score < bestScore) {
+          bestScore = score;
+          bestSea = { x, y };
+        }
+      }
+    }
+    return bestSea;
+  }
+
+  function riverRouteCost(x, y, cx, cy) {
+    const i = indexOf(x, y);
+    const ci = indexOf(cx, cy);
+    if (sea[i]) return 0.18;
+    const uphill = Math.max(0, elevation[i] - elevation[ci]);
+    const downhill = Math.max(0, elevation[ci] - elevation[i]);
+    if (!sea[i] && uphill > 0.035 && flowAccum[i] < flowAccum[ci] + 0.015) return INF;
+    return Math.max(
+      0.18,
+      1 +
+        uphill * 86 +
+        slope[i] * 0.38 +
+        elevation[i] * 0.42 -
+        downhill * 2.1 -
+        valleyField[i] * 0.92 -
+        flowAccum[i] * 0.72 -
+        moisture[i] * 0.18 -
+        coastalLowland[i] * 0.22
+    );
+  }
+
+  function forceRiverToWater(path) {
+    if (!path.length) return path;
+    const [ex, ey] = path[path.length - 1];
+    if (sea[indexOf(ex, ey)]) return path;
+    const goal = nearestWaterGoal({ x: ex, y: ey });
+    if (!goal) return path;
+    const startElevation = elevation[indexOf(ex, ey)];
+    const tail = aStar({ x: ex, y: ey }, goal, (x, y, cx, cy) => {
+      const i = indexOf(x, y);
+      const ci = indexOf(cx, cy);
+      if (!sea[i] && elevation[i] > Math.max(startElevation + 0.045, elevation[ci] + 0.030)) return INF;
+      return riverRouteCost(x, y, cx, cy);
+    });
+    if (tail.length <= 2) return path;
+    return path.concat(tail.slice(1));
+  }
+
+  function confluenceAnglePenalty(nx, ny, dx, dy, lengthSoFar) {
+    if (lengthSoFar < 7 || river[indexOf(nx, ny)] < 0.24) return 0;
+    let best = 0.16;
+    const inLen = Math.hypot(dx, dy) || 1;
+    for (const [rx, ry] of neighbors8(nx, ny)) {
+      if (river[indexOf(rx, ry)] < 0.22) continue;
+      const rdx = rx - nx;
+      const rdy = ry - ny;
+      const cos = clamp((dx * rdx + dy * rdy) / Math.max(0.001, inLen * Math.hypot(rdx, rdy)), -1, 1);
+      const angle = Math.acos(cos);
+      const shallow = angle < 0.45 ? 0.28 : 0;
+      best = Math.min(best, Math.abs(angle - Math.PI * 0.62) * 0.045 + shallow);
+    }
+    return best;
+  }
+
+  function traceRiverPath(startX, startY, bonusSeed = 0) {
+    let x = startX;
+    let y = startY;
+    let lastDx = 0;
+    let lastDy = 0;
+    const path = [];
+    const seen = new Set();
+    let accum = 0;
+
+    for (let step = 0; step < 600; step++) {
+      const i = indexOf(x, y);
+      if (seen.has(i)) break;
+      seen.add(i);
+      path.push([x, y]);
+      river[i] += 0.44 + path.length / 160 + flowAccum[i] * 0.55;
+      accum += river[i] + flowAccum[i];
+      if (sea[i]) break;
+
+      let best = null;
+      let bestValue = INF;
+      const currentElevation = elevation[i];
+      const preferred = flowTo[i];
+
+      for (const [nx, ny] of neighbors8(x, y)) {
+        const ni = indexOf(nx, ny);
+        const dx = nx - x;
+        const dy = ny - y;
+        const drop = currentElevation - elevation[ni];
+        const uphill = Math.max(0, -drop);
+        if (!sea[ni] && uphill > 0.032 && flowAccum[ni] < flowAccum[i] + 0.018) continue;
+        let surrounding = 0;
+        let surroundingCount = 0;
+        for (const [vx, vy] of neighbors8(nx, ny)) {
+          surrounding += elevation[indexOf(vx, vy)];
+          surroundingCount++;
+        }
+        const valley = Math.max(0, surrounding / Math.max(1, surroundingCount) - elevation[ni]);
+        const sameDirection = lastDx || lastDy ? (dx * lastDx + dy * lastDy) / Math.max(0.001, Math.hypot(dx, dy) * Math.hypot(lastDx, lastDy)) : 0;
+        const straightPenalty = Math.max(0, sameDirection) * 0.075;
+        const turnPenalty = sameDirection < -0.35 ? 0.24 : 0;
+        const sideSwing = Math.abs(dx * lastDy - dy * lastDx);
+        const meanderPhase = Math.sin((path.length + bonusSeed * 0.013) * 0.73) * 0.5 + 0.5;
+        const meander = sideSwing * (0.032 + meanderPhase * 0.026);
+        const flowBonus = ni === preferred ? 0.62 : 0;
+        const junctionPenalty = confluenceAnglePenalty(nx, ny, dx, dy, path.length);
+        const noise = (hash2(nx, ny, seed + bonusSeed + step * 11) - 0.5) * 0.04;
+        const value =
+          elevation[ni] * 1.45 +
+          uphill * 88 -
+          Math.max(0, drop) * 2.05 -
+          valley * 1.05 -
+          valleyField[ni] * 1.72 -
+          flowAccum[ni] * 0.94 -
+          moisture[ni] * 0.14 -
+          coastalLowland[ni] * 0.28 -
+          (river[ni] > 0 ? 0.22 : 0) -
+          flowBonus +
+          slope[ni] * 0.04 +
+          straightPenalty +
+          turnPenalty +
+          junctionPenalty * 1.35 -
+          meander +
+          noise -
+          (sea[ni] ? 0.6 : 0);
+
+        if (value < bestValue) {
+          bestValue = value;
+          best = [nx, ny, dx, dy];
+        }
+      }
+      if (!best) break;
+      x = best[0];
+      y = best[1];
+      lastDx = best[2];
+      lastDy = best[3];
+    }
+
+    const forced = forceRiverToWater(path);
+    if (forced.length > path.length) {
+      for (const [rx, ry] of forced.slice(path.length)) {
+        const ri = indexOf(rx, ry);
+        river[ri] += 0.32 + flowAccum[ri] * 0.4;
+        accum += river[ri] + flowAccum[ri];
+      }
+    }
+    return { path: forced, accum };
+  }
+
+  function traceSmallStreamPath(startX, startY, bonusSeed = 0) {
+    let x = startX;
+    let y = startY;
+    let lastDx = 0;
+    let lastDy = 0;
+    const path = [];
+    const seen = new Set();
+    for (let step = 0; step < 160; step++) {
+      const i = indexOf(x, y);
+      if (seen.has(i)) break;
+      seen.add(i);
+      path.push([x, y]);
+      river[i] += 0.12 + flowAccum[i] * 0.18;
+      if ((river[i] > 0.48 && path.length > 5) || sea[i]) break;
+      let best = null;
+      let bestValue = INF;
+      for (const [nx, ny] of neighbors8(x, y)) {
+        const ni = indexOf(nx, ny);
+        const dx = nx - x;
+        const dy = ny - y;
+        const drop = elevation[i] - elevation[ni];
+        const sameDirection = lastDx || lastDy ? (dx * lastDx + dy * lastDy) / Math.max(0.001, Math.hypot(dx, dy) * Math.hypot(lastDx, lastDy)) : 0;
+        const value = elevation[ni] * 1.2 + Math.max(0, -drop) * 26 - Math.max(0, drop) * 1.4 - valleyField[ni] * 1.15 - flowAccum[ni] * 0.55 - moisture[ni] * 0.12 + Math.max(0, sameDirection) * 0.04 - Math.abs(dx * lastDy - dy * lastDx) * 0.018 + (hash2(nx, ny, seed + bonusSeed + step * 13) - 0.5) * 0.05;
+        if (value < bestValue) { bestValue = value; best = [nx, ny, dx, dy]; }
+      }
+      if (!best) break;
+      x = best[0];
+      y = best[1];
+      lastDx = best[2];
+      lastDy = best[3];
+    }
+    return path;
+  }
+
+  const riverPaths = [];
+  const riverScores = [];
+  for (const source of sources) {
+    const { path, accum } = traceRiverPath(source.x, source.y, 0);
+    if (path.length > 6) {
+      riverPaths.push(path);
+      riverScores.push(path.length + accum * 0.18);
+    }
+  }
+
+  const preliminaryMainRiverCells = new Set(riverPaths.slice().sort((a, b) => b.length - a.length).slice(0, 5).flatMap((path) => path.map(([x, y]) => `${x},${y}`)));
+  const tributarySources = pickEntities(sourceCandidates
+    .filter((p) => !preliminaryMainRiverCells.has(`${p.x},${p.y}`))
+    .map((p) => ({ ...p, score: p.score + flowAccum[indexOf(p.x, p.y)] * 0.75 + valleyField[indexOf(p.x, p.y)] * 0.24 })), {
+      max: 14 + Math.floor(rand(seed, 915) * 20),
+      minDistance: 6,
+      threshold: 0.45,
+      seed: seed + 916,
+      jitter: 0.02,
+    });
+  for (const source of tributarySources) {
+    const { path, accum } = traceRiverPath(source.x, source.y, 4000 + source.x * 7 + source.y * 11);
+    if (path.length > 8) {
+      riverPaths.push(path);
+      riverScores.push(path.length * 0.7 + accum * 0.12);
+    }
+  }
+
+  const streamPaths = [];
+  const streamSources = pickEntities(sourceCandidates
+    .map((p) => ({ ...p, score: valleyField[indexOf(p.x, p.y)] * 0.46 + flowAccum[indexOf(p.x, p.y)] * 0.36 + moisture[indexOf(p.x, p.y)] * 0.18 + hash2(p.x, p.y, seed + 918) * 0.05 }))
+    .filter((p) => p.score > 0.18), {
+      max: 22 + Math.floor(rand(seed, 919) * 20),
+      minDistance: 4,
+      threshold: 0.18,
+      seed: seed + 919,
+      jitter: 0.015,
+    });
+  for (const source of streamSources) {
+    const path = traceSmallStreamPath(source.x, source.y, 7000 + source.x * 5 + source.y * 17);
+    if (path.length > 4) streamPaths.push(path);
+  }
+
+  if (riverPaths.length === 0 && sourceCandidates.length > 0) {
+    const fallback = sourceCandidates.slice().sort((a, b) => b.score - a.score)[0];
+    let bestSea = null;
+    let bestSeaDist = INF;
+    for (let y = 0; y < MAP_H; y++) {
+      for (let x = 0; x < MAP_W; x++) {
+        if (!sea[indexOf(x, y)]) continue;
+        const d = Math.hypot(x - fallback.x, y - fallback.y);
+        if (d < bestSeaDist) {
+          bestSeaDist = d;
+          bestSea = { x, y };
+        }
+      }
+    }
+    if (bestSea) {
+      const fallbackPath = aStar(fallback, bestSea, (x, y, cx, cy) => {
+        const i = indexOf(x, y);
+        const ci = indexOf(cx, cy);
+        if (sea[i]) return 0.25;
+        const uphill = Math.max(0, elevation[i] - elevation[ci]) * 24;
+        const downhill = Math.max(0, elevation[ci] - elevation[i]) * 1.8;
+        return Math.max(0.24, 1 + uphill + slope[i] * 0.7 + elevation[i] * 0.8 - downhill - Math.min(0.55, river[i] * 0.1));
+      });
+      if (fallbackPath.length > 6) {
+        let accum = 0;
+        for (const [x, y] of fallbackPath) {
+          const i = indexOf(x, y);
+          river[i] += 0.42;
+          accum += river[i];
+        }
+        riverPaths.push(fallbackPath);
+        riverScores.push(fallbackPath.length + accum * 0.18);
+      }
+    }
+  }
+
+  function sanitizeDownhillRiverPath(path, tolerance = 0.040) {
+    if (!path || path.length < 2) return path || [];
+    const out = [path[0]];
+    for (let k = 1; k < path.length; k++) {
+      const [px, py] = out[out.length - 1];
+      const [x, y] = path[k];
+      const pi = indexOf(px, py);
+      const i = indexOf(x, y);
+      if (!sea[i] && elevation[i] > elevation[pi] + tolerance) break;
+      out.push(path[k]);
+      if (sea[i]) break;
+    }
+    return out.length >= 2 ? out : [];
+  }
+  function trimMountainHeadwaters(path) {
+    if (!path || path.length < 4) return path || [];
+    let start = 0;
+    while (start < path.length - 3) {
+      const [x, y] = path[start];
+      const i = indexOf(x, y);
+      if (sea[i]) break;
+      if (elevation[i] <= 0.72 && (valleyField[i] >= 0.18 || flowAccum[i] >= 0.05)) break;
+      start++;
+    }
+    return path.slice(start);
+  }
+  for (let r = 0; r < riverPaths.length; r++) riverPaths[r] = sanitizeDownhillRiverPath(trimMountainHeadwaters(riverPaths[r]), 0.032);
+  for (let r = riverPaths.length - 1; r >= 0; r--) if (riverPaths[r].length < 2) riverPaths.splice(r, 1);
+  for (let r = 0; r < streamPaths.length; r++) streamPaths[r] = sanitizeDownhillRiverPath(trimMountainHeadwaters(streamPaths[r]), 0.026);
+  for (let r = streamPaths.length - 1; r >= 0; r--) if (streamPaths[r].length < 2) streamPaths.splice(r, 1);
+  river.fill(0);
+  for (const path of riverPaths) {
+    for (let k = 0; k < path.length; k++) {
+      const [x, y] = path[k];
+      const i = indexOf(x, y);
+      river[i] += 0.42 + k / 170 + flowAccum[i] * 0.55;
+    }
+  }
+  for (const path of streamPaths) {
+    for (let k = 0; k < path.length; k++) {
+      const [x, y] = path[k];
+      const i = indexOf(x, y);
+      river[i] += 0.11 + flowAccum[i] * 0.18;
+    }
+  }
+
+  const expandedRiver = new Float32Array(river);
+  for (let y = 1; y < MAP_H - 1; y++) {
+    for (let x = 1; x < MAP_W - 1; x++) {
+      const i = indexOf(x, y);
+      if (river[i] <= 0) continue;
+      for (const [nx, ny] of neighbors8(x, y)) {
+        expandedRiver[indexOf(nx, ny)] = Math.max(expandedRiver[indexOf(nx, ny)], river[i] * 0.35);
+      }
+    }
+  }
+  river.set(expandedRiver);
+
+  // Second fluvial pass uses the actual traced river network. Main channels cut
+  // visible V-shaped valleys; lower reaches accumulate alluvial deposits.
+  const fluvialElevation = new Float32Array(elevation);
+  for (let y = 1; y < MAP_H - 1; y++) {
+    for (let x = 1; x < MAP_W - 1; x++) {
+      const i = indexOf(x, y);
+      if (sea[i] || river[i] <= 0.02) continue;
+      const r = clamp(river[i] / 3.4);
+      const channelCut = clamp(Math.pow(r, 0.55) * (0.060 + slope[i] * 0.145 + ridgeField[i] * 0.038));
+      const valleyWiden = clamp(Math.pow(r, 0.72) * (0.020 + Math.max(0, elevation[i] - seaLevel) * 0.058 + valleyField[i] * 0.040));
+      const alluvium = clamp(Math.pow(r, 0.72) * (coastalLowland[i] * 0.030 + basinField[i] * 0.020 + (slope[i] < 0.10 ? 0.010 : 0)));
+      erosionField[i] = clamp(erosionField[i] + channelCut + valleyWiden);
+      depositionField[i] = clamp(depositionField[i] + alluvium);
+      fluvialElevation[i] = clamp(elevation[i] - channelCut - valleyWiden + alluvium, seaLevel + 0.005, 1);
+      valleyField[i] = clamp(valleyField[i] + r * 0.62 + channelCut * 6.4);
+      basinField[i] = clamp(basinField[i] + alluvium * 3.2);
+    }
+  }
+  // Lateral valley carving around the traced river network deepens valleys and
+  // makes ridge/valley contrast legible at the map scale.
+  for (const path of riverPaths) {
+    for (const [rx, ry] of path) {
+      const ri = indexOf(rx, ry);
+      const r = clamp(river[ri] / 3.0);
+      const radius = r > 0.48 ? 2 : 1;
+      for (let dy = -radius; dy <= radius; dy++) {
+        for (let dx = -radius; dx <= radius; dx++) {
+          const nx = rx + dx;
+          const ny = ry + dy;
+          if (!inside(nx, ny)) continue;
+          const ni = indexOf(nx, ny);
+          if (sea[ni]) continue;
+          const d = Math.hypot(dx, dy);
+          if (d > radius || d === 0) continue;
+          const weight = (radius + 0.35 - d) / (radius + 0.35);
+          const highRidgeGuard = clamp((elevation[ni] - 0.68) / 0.18) * clamp(ridgeField[ni] * 1.2);
+          const carve = Math.max(0, weight) * (0.008 + r * 0.026) * Math.max(0.45, slope[ni] + 0.22) * (1 - highRidgeGuard * 0.72);
+          fluvialElevation[ni] = clamp(fluvialElevation[ni] - carve, seaLevel + 0.005, 1);
+          erosionField[ni] = clamp(erosionField[ni] + carve * 3.0);
+          valleyField[ni] = clamp(valleyField[ni] + carve * 12.0);
+        }
+      }
+    }
+  }
+
+  // Restore rugged summit relief after strong river incision. This prevents highlands
+  // from becoming unnaturally flat or visually concave while keeping valleys cut.
+  for (let y = 1; y < MAP_H - 1; y++) {
+    for (let x = 1; x < MAP_W - 1; x++) {
+      const i = indexOf(x, y);
+      if (sea[i]) continue;
+      const high = clamp((fluvialElevation[i] - 0.62) / 0.26);
+      const summit = high * clamp(ridgeField[i] * 1.4 - flowAccum[i] * 0.8);
+      const rugged = (valueNoise(x * 2.1 + 19, y * 2.1 - 23, seed + 9661, 3.2) - 0.5) * 0.035;
+      const uplift = summit * (0.018 + Math.max(0, rugged));
+      if (uplift > 0) {
+        fluvialElevation[i] = clamp(fluvialElevation[i] + uplift, seaLevel + 0.005, 1);
+        erosionField[i] = Math.max(0, erosionField[i] - uplift * 0.6);
+      }
+    }
+  }
+
+  elevation.set(fluvialElevation);
+  for (let y = 1; y < MAP_H - 1; y++) {
+    for (let x = 1; x < MAP_W - 1; x++) {
+      const i = indexOf(x, y);
+      if (sea[i]) continue;
+      const gx = elevation[indexOf(x + 1, y)] - elevation[indexOf(x - 1, y)];
+      const gy = elevation[indexOf(x, y + 1)] - elevation[indexOf(x, y - 1)];
+      slope[i] = clamp(Math.sqrt(gx * gx + gy * gy) * 11.2);
+    }
+  }
+
+  // Re-trim visible river paths after fluvial reshaping changes local elevation.
+  for (let r = 0; r < riverPaths.length; r++) riverPaths[r] = sanitizeDownhillRiverPath(trimMountainHeadwaters(riverPaths[r]), 0.028);
+  for (let r = riverPaths.length - 1; r >= 0; r--) if (riverPaths[r].length < 2) riverPaths.splice(r, 1);
+  for (let r = 0; r < streamPaths.length; r++) streamPaths[r] = sanitizeDownhillRiverPath(trimMountainHeadwaters(streamPaths[r]), 0.022);
+  for (let r = streamPaths.length - 1; r >= 0; r--) if (streamPaths[r].length < 2) streamPaths.splice(r, 1);
+
+  const mainRivers = riverPaths
+    .map((p, i) => ({ path: p, score: riverScores[i] }))
+    .sort((a, b) => b.score - a.score)
+    .slice(0, Math.min(6, riverPaths.length))
+    .map((x) => x.path);
+
+  if (mainRivers.length === 0 && riverPaths.length > 0) mainRivers.push(riverPaths[0]);
+  if (mainRivers.length === 0) {
+    let start = null;
+    let startScore = -INF;
+    for (let y = 4; y < MAP_H - 4; y++) {
+      for (let x = 4; x < MAP_W - 4; x++) {
+        const i = indexOf(x, y);
+        if (sea[i]) continue;
+        const score = elevation[i] * 0.55 + moisture[i] * 0.35 - slope[i] * 0.15;
+        if (score > startScore) {
+          startScore = score;
+          start = { x, y };
+        }
+      }
+    }
+    if (start) {
+      let goal = null;
+      let goalDist = INF;
+      for (let y = 0; y < MAP_H; y++) {
+        for (let x = 0; x < MAP_W; x++) {
+          if (!sea[indexOf(x, y)]) continue;
+          const d = Math.hypot(x - start.x, y - start.y);
+          if (d < goalDist) {
+            goalDist = d;
+            goal = { x, y };
+          }
+        }
+      }
+      if (goal) {
+        const fallbackPath = aStar(start, goal, (x, y, cx, cy) => {
+          const i = indexOf(x, y);
+          const ci = indexOf(cx, cy);
+          if (sea[i]) return 0.2;
+          const uphillBias = Math.max(0, elevation[i] - elevation[ci]) * 22;
+          const downhillBias = Math.max(0, elevation[ci] - elevation[i]) * 1.7;
+          return Math.max(0.25, 1 + uphillBias + slope[i] * 0.65 + elevation[i] * 0.8 - downhillBias);
+        });
+        if (fallbackPath.length > 4) {
+          riverPaths.push(fallbackPath);
+          mainRivers.push(fallbackPath);
+          for (const [x, y] of fallbackPath) river[indexOf(x, y)] += 0.4;
+        }
+      }
+    }
+  }
+
+  const mainRiverCells = new Set(mainRivers.flatMap((path) => path.map(([x, y]) => `${x},${y}`)));
+  const tributaryRivers = riverPaths.filter((path) => path.some(([x, y]) => !mainRiverCells.has(`${x},${y}`)) && !mainRivers.includes(path));
+  const smallStreams = streamPaths.filter((path) => path.length >= 5);
+
+  prefectureMask = makePrefectureMask(seed, sea, elevation, slope, river);
+  prefectureBorder = extractMaskBorder(prefectureMask, sea);
+  const regionalPrefectures = generateRegionalPrefectures(seed, sea, elevation, slope, river, ridgeField, flowAccum, prefectureMask);
+  const prefectureRegionId = regionalPrefectures.regionId;
+  const regionalPrefectureBorders = extractRegionBorderSegments(prefectureRegionId, sea);
+
+  for (let y = 1; y < MAP_H - 1; y++) {
+    for (let x = 1; x < MAP_W - 1; x++) {
+      const i = indexOf(x, y);
+      if (sea[i]) continue;
+      const low = 1 - clamp((elevation[i] - 0.28) / 0.4);
+      const flat = 1 - slope[i];
+      const valleyPlain = valleyField[i] * 0.44 + basinField[i] * 0.36 + coastalLowland[i] * 0.55;
+      plain[i] = clamp(low * 0.44 + flat * 0.58 + valleyPlain - ridgeField[i] * 0.28 - (elevation[i] > 0.62 ? 0.48 : 0));
+
+      let nearRiver = 0;
+      for (let dy = -4; dy <= 4; dy++) {
+        for (let dx = -4; dx <= 4; dx++) {
+          const nx = x + dx;
+          const ny = y + dy;
+          if (!inside(nx, ny)) continue;
+          nearRiver = Math.max(nearRiver, river[indexOf(nx, ny)] / (1 + Math.hypot(dx, dy)));
+        }
+      }
+
+      const fan = clamp(valleyField[i] * (1 - coastalLowland[i]) * (elevation[i] > 0.34 && elevation[i] < 0.58 ? 0.9 : 0.35) * (1 - slope[i] * 0.55));
+      floodplain[i] = clamp(nearRiver * plain[i] * 0.92 + coastalLowland[i] * nearRiver * 0.22);
+      agriculture[i] = clamp(plain[i] * 0.58 + fan * 0.26 + basinField[i] * 0.2 + moisture[i] * 0.14 + clamp(nearRiver) * 0.32 - slope[i] * 0.34 - ridgeField[i] * 0.18 - floodplain[i] * 0.06);
+    }
+  }
+
+  for (let y = 2; y < MAP_H - 2; y++) {
+    for (let x = 2; x < MAP_W - 2; x++) {
+      const i = indexOf(x, y);
+      if (sea[i]) continue;
+      let seaNear = 0;
+      let riverNear = 0;
+      let sheltered = 0;
+
+      for (let dy = -5; dy <= 5; dy++) {
+        for (let dx = -5; dx <= 5; dx++) {
+          const nx = x + dx;
+          const ny = y + dy;
+          if (!inside(nx, ny)) continue;
+          const d = Math.hypot(dx, dy);
+          if (sea[indexOf(nx, ny)]) seaNear += 1 / (1 + d);
+          riverNear = Math.max(riverNear, river[indexOf(nx, ny)] / (1 + d));
+        }
+      }
+
+      for (let dy = -2; dy <= 2; dy++) {
+        for (let dx = -2; dx <= 2; dx++) {
+          const nx = x + dx;
+          const ny = y + dy;
+          if (inside(nx, ny) && !sea[indexOf(nx, ny)]) sheltered += 1;
+        }
+      }
+
+      const isDelta = riverNear > 0.22 && coastalLowland[i] > 0.18;
+      const bayShelter = sheltered * 0.012 + seaNear * 0.055 + coastalLowland[i] * 0.16;
+      portSuitability[i] = clamp(bayShelter + riverNear * 0.24 + (isDelta ? 0.22 : 0) + plain[i] * 0.08 - slope[i] * 0.48 - ridgeField[i] * 0.16);
+    }
+  }
+
+  for (let y = 3; y < MAP_H - 3; y++) {
+    for (let x = 3; x < MAP_W - 3; x++) {
+      const i = indexOf(x, y);
+      if (sea[i]) continue;
+      const r = river[i];
+      if (r < 0.2 || r > 1.85) continue;
+      let bankPlain = 0;
+      for (const [nx, ny] of neighbors8(x, y)) bankPlain += plain[indexOf(nx, ny)];
+      crossingSuitability[i] = clamp(r * 0.34 + (bankPlain / 8) * 0.54 + valleyField[i] * 0.18 - slope[i] * 0.55 - floodplain[i] * 0.06);
+    }
+  }
+
+  for (let y = 4; y < MAP_H - 4; y++) {
+    for (let x = 4; x < MAP_W - 4; x++) {
+      const i = indexOf(x, y);
+      if (sea[i]) continue;
+      const e = elevation[i];
+      if (e < 0.43 || e > 0.82) continue;
+      const ewHigh = (elevation[indexOf(x - 3, y)] + elevation[indexOf(x + 3, y)]) / 2;
+      const nsHigh = (elevation[indexOf(x, y - 3)] + elevation[indexOf(x, y + 3)]) / 2;
+      const diagLow = Math.min(
+        elevation[indexOf(x - 3, y - 3)],
+        elevation[indexOf(x + 3, y + 3)],
+        elevation[indexOf(x - 3, y + 3)],
+        elevation[indexOf(x + 3, y - 3)]
+      );
+      passSuitability[i] = clamp((Math.max(ewHigh, nsHigh) - e) * 2.2 + (e - diagLow) * 0.55 + valleyField[i] * 0.28 - ridgeField[i] * 0.18 - slope[i] * 0.2);
+    }
+  }
+
+  function pickPoints(scoreArray, { threshold, max, minDistance, seedOffset = 0, predicate = () => true }) {
+    const candidates = [];
+    for (let y = 2; y < MAP_H - 2; y++) {
+      for (let x = 2; x < MAP_W - 2; x++) {
+        const i = indexOf(x, y);
+        if (!predicate(x, y, i)) continue;
+        const score = scoreArray[i] + hash2(x, y, seed + seedOffset) * 0.08;
+        if (score >= threshold) candidates.push({ x, y, score });
+      }
+    }
+    return pickEntities(candidates, { max, minDistance, threshold, seed: seed + seedOffset });
+  }
+
+  let ports = pickPoints(portSuitability, {
+    threshold: 0.3 + rand(seed, 1001) * 0.08,
+    max: 3 + Math.floor(rand(seed, 1002) * 7),
+    minDistance: 10,
+    seedOffset: 1000,
+    predicate: (x, y, i) => !sea[i],
+  }).map((p) => {
+    const i = indexOf(p.x, p.y);
+    let seaEdge = 0;
+    for (let dy = -3; dy <= 3; dy++) for (let dx = -3; dx <= 3; dx++) {
+      const nx = p.x + dx;
+      const ny = p.y + dy;
+      if (inside(nx, ny) && sea[indexOf(nx, ny)]) seaEdge += 1 / (1 + Math.hypot(dx, dy));
+    }
+    const harborPotential = p.score + coastalLowland[i] * 0.28 + river[i] * 0.08 + seaEdge * 0.025 - slope[i] * 0.2;
+    return { ...p, harborPotential, seaEdge, portClass: "fishing", kind: "Fishing Port" };
+  }).sort((a, b) => b.harborPotential - a.harborPotential)
+    .map((p, n) => {
+      const isLakeLike = p.seaEdge < 0.25 && river[indexOf(p.x, p.y)] > 0.32;
+      const portClass = isLakeLike ? "lake" : n === 0 ? "major" : n < 3 && p.harborPotential > 0.34 ? "regional" : "fishing";
+      const kind = portClass === "major" ? "Major Port" : portClass === "regional" ? "Regional Port" : portClass === "lake" ? "Lake Port" : "Fishing Port";
+      return { ...p, portClass, kind, score: p.harborPotential };
+    });
+  if (!ports.some((p) => p.portClass === "major")) {
+    const fallbackMajor = ports.find((p) => p.portClass !== "lake") || ports[0];
+    if (fallbackMajor) {
+      fallbackMajor.portClass = "major";
+      fallbackMajor.kind = "Major Port";
+      fallbackMajor.score += 0.16;
+    }
+  }
+  const majorPorts = ports.filter((p) => p.portClass === "major");
+  const commercialPorts = ports.filter((p) => p.portClass === "major" || p.portClass === "regional");
+
+  let crossings = pickPoints(crossingSuitability, {
+    threshold: 0.28 + rand(seed, 1011) * 0.08,
+    max: 8 + Math.floor(rand(seed, 1012) * 15),
+    minDistance: 8,
+    seedOffset: 1010,
+    predicate: (x, y, i) => !sea[i],
+  }).map((p) => ({ ...p, kind: "River Crossing" }));
+
+  let passes = pickPoints(passSuitability, {
+    threshold: 0.16 + rand(seed, 1021) * 0.08,
+    max: 4 + Math.floor(rand(seed, 1022) * 10),
+    minDistance: 9,
+    seedOffset: 1020,
+    predicate: (x, y, i) => !sea[i],
+  }).map((p) => ({ ...p, kind: "Pass" }));
+
+  const settlementScore = new Float32Array(SIZE);
+  for (let y = 2; y < MAP_H - 2; y++) {
+    for (let x = 2; x < MAP_W - 2; x++) {
+      const i = indexOf(x, y);
+      if (sea[i]) continue;
+      let nearFeature = 0;
+      for (const p of [...ports, ...crossings, ...passes]) nearFeature = Math.max(nearFeature, 1 / (1 + Math.hypot(x - p.x, y - p.y) / 4));
+      const riverPull = Math.min(0.32, river[i] * 0.14 + valleyField[i] * 0.16);
+      const mountainVillage = valleyField[i] * clamp(elevation[i] - 0.42, 0, 0.3) * 0.52;
+      settlementScore[i] = clamp(agriculture[i] * 0.55 + plain[i] * 0.16 + nearFeature * 0.24 + riverPull + basinField[i] * 0.12 + mountainVillage - slope[i] * 0.42 - ridgeField[i] * 0.2 - floodplain[i] * 0.06);
+    }
+  }
+
+  let villages = pickPoints(settlementScore, {
+    threshold: 0.32 + rand(seed, 1031) * 0.1,
+    max: 28 + Math.floor(rand(seed, 1032) * 44),
+    minDistance: 4 + Math.floor(rand(seed, 1033) * 4),
+    seedOffset: 1030,
+    predicate: (x, y, i) => !sea[i],
+  }).map((p) => ({ ...p, kind: "Village" }));
+
+  const marketScore = new Float32Array(SIZE);
+  for (let y = 4; y < MAP_H - 4; y++) {
+    for (let x = 4; x < MAP_W - 4; x++) {
+      const i = indexOf(x, y);
+      if (sea[i]) continue;
+
+      let villagePull = 0;
+      let nearbyVillages = 0;
+      for (const v of villages) {
+        const d = Math.hypot(x - v.x, y - v.y);
+        if (d < 24) {
+          villagePull += 1 / (1 + d);
+          nearbyVillages++;
+        }
+      }
+
+      let featurePull = 0;
+      for (const p of [...ports, ...crossings]) featurePull = Math.max(featurePull, 1 / (1 + Math.hypot(x - p.x, y - p.y) / 3));
+      const confluence = river[i] > 0.36 && valleyField[i] > 0.24 ? 0.12 : 0;
+      marketScore[i] = clamp(villagePull * 1.25 + featurePull * 0.34 + plain[i] * 0.2 + basinField[i] * 0.16 + confluence + coastalLowland[i] * 0.08 + river[i] * 0.035 - slope[i] * 0.32 - ridgeField[i] * 0.18 + nearbyVillages * 0.012);
+    }
+  }
+
+  let markets = pickPoints(marketScore, {
+    threshold: 0.2 + rand(seed, 1041) * 0.08,
+    max: 6 + Math.floor(rand(seed, 1042) * 12),
+    minDistance: 11,
+    seedOffset: 1040,
+    predicate: (x, y, i) => !sea[i],
+  }).map((p) => ({ ...p, kind: "Market Town" }));
+
+  const defenseScore = new Float32Array(SIZE);
+  for (let y = 3; y < MAP_H - 3; y++) {
+    for (let x = 3; x < MAP_W - 3; x++) {
+      const i = indexOf(x, y);
+      if (sea[i]) continue;
+      const hillShoulder = clamp(1 - Math.abs(elevation[i] - 0.50) / 0.24);
+      let riverArms = 0;
+      for (const [nx, ny] of neighbors8(x, y)) if (river[indexOf(nx, ny)] > 0.32) riverArms++;
+      const confluence = riverArms >= 3 ? 0.38 : riverArms === 2 ? 0.18 : 0;
+      const roadJunctionProxy = (
+        (distanceToNearest(markets, x, y) < 7 ? 1 : 0) +
+        (distanceToNearest(crossings, x, y) < 6 ? 1 : 0) +
+        (distanceToNearest(passes, x, y) < 7 ? 1 : 0) +
+        (distanceToNearest(commercialPorts, x, y) < 8 ? 1 : 0)
+      ) >= 2 ? 0.32 : 0;
+      const hillEdge = plain[i] > 0.2 && elevation[i] > 0.36 && elevation[i] < 0.62 && (slope[i] > 0.12 || ridgeField[i] > 0.12) ? 0.3 : 0;
+      const mountainRidgeCastle = elevation[i] > 0.56 && ridgeField[i] > 0.3 && valleyField[i] > 0.1 ? 0.28 : 0;
+      const validCastleSite = confluence > 0 || roadJunctionProxy > 0 || hillEdge > 0 || mountainRidgeCastle > 0;
+      defenseScore[i] = validCastleSite
+        ? clamp(hillShoulder * 0.28 + confluence + roadJunctionProxy + hillEdge + mountainRidgeCastle + slope[i] * 0.05 - floodplain[i] * 0.42 - coastalLowland[i] * 0.12)
+        : 0;
+    }
+  }
+
+  let castles = pickPoints(defenseScore, {
+    threshold: 0.34 + rand(seed, 1051) * 0.08,
+    max: 2 + Math.floor(rand(seed, 1052) * 4),
+    minDistance: 15,
+    seedOffset: 1050,
+    predicate: (x, y, i) => !sea[i] && defenseScore[i] > 0,
+  }).map((p) => ({
+    ...p,
+    kind: elevation[indexOf(p.x, p.y)] > 0.55 ? "Mountain Castle" : elevation[indexOf(p.x, p.y)] > 0.38 ? "Hilltop Castle" : "Flatland Castle",
+  }));
+
+  function normalEdgePenalty(x, y) {
+    if (nearMapEdge(x, y, 1)) return INF;
+    if (nearMapEdge(x, y, 2)) return 7;
+    if (nearMapEdge(x, y, 4)) return 2.8;
+    return 0;
+  }
+
+  function premodernCost(x, y) {
+    const i = indexOf(x, y);
+    if (sea[i]) return INF;
+    const crossingBonus = distanceToNearest(crossings, x, y) < 4 ? 0.65 : 0;
+    const passBonus = distanceToNearest(passes, x, y) < 4 ? 0.45 : 0;
+    const riverPenalty = river[i] > 0.28 ? (crossingBonus ? 0.45 : 2.4) : 0;
+    const highMountain = elevation[i] > 0.72 ? 4.2 : elevation[i] > 0.58 ? 1.4 : 0;
+    return Math.max(0.35, 1 + slope[i] * 5.8 + riverPenalty + highMountain + floodplain[i] * 0.62 - plain[i] * 0.32 - valleyField[i] * 0.42 - coastalLowland[i] * 0.12 - passBonus + normalEdgePenalty(x, y) + hash2(x, y, seed + 111) * 0.16);
+  }
+
+  const premodernRoads = [];
+  function addPremodernRoad(a, b) {
+    const path = aStar(a, b, premodernCost);
+    if (path.length > 3) premodernRoads.push(path);
+  }
+
+  for (const castle of castles) {
+    const near = pickEntities([...markets, ...ports, ...crossings, ...passes].map((p) => ({ ...p, score: 1 / (1 + Math.hypot(p.x - castle.x, p.y - castle.y)) })), { max: 2 + Math.floor(rand(seed, castle.x + castle.y) * 3), minDistance: 1, threshold: 0 });
+    for (const p of near) addPremodernRoad(castle, p);
+  }
+  for (const market of markets) {
+    const near = pickEntities([...markets.filter((p) => p !== market), ...ports, ...crossings].map((p) => ({ ...p, score: 1 / (1 + Math.hypot(p.x - market.x, p.y - market.y)) })), { max: 1 + Math.floor(rand(seed, market.x + market.y + 20) * 3), minDistance: 1, threshold: 0 });
+    for (const p of near) addPremodernRoad(market, p);
+  }
+
+  let castleTowns = castles.map((c) => ({ x: c.x, y: c.y, score: c.score + 0.45, kind: "Castle Town" }));
+  const cityCandidates = [
+    ...castleTowns.map((p) => ({ ...p, score: p.score + 0.4 })),
+    ...ports.map((p) => ({ ...p, kind: "Port Town", score: p.score + 0.28 })),
+    ...markets.map((p) => ({ ...p, kind: "Market City", score: p.score + 0.12 })),
+  ];
+
+  let modernCities = pickEntities(cityCandidates, {
+    max: 7 + Math.floor(rand(seed, 1061) * 10),
+    minDistance: 9,
+    threshold: 0.33 + rand(seed, 1062) * 0.12,
+    seed: seed + 1060,
+  }).map((p, n) => {
+    const rank = n === 0 ? "Prefectural Capital" : n < 4 ? "Regional Center" : "Small City";
+    const r = rand(seed, 1600 + n * 13 + p.x * 3 + p.y);
+    const rawScale = Math.pow(1 - n / Math.max(1, cityCandidates.length + 1), 1.55) * 0.58 + Math.pow(r, 3.4) * 0.42;
+    const rankBase = rank === "Prefectural Capital" ? 420000 : rank === "Regional Center" ? 115000 : 26000;
+    const rankSpread = rank === "Prefectural Capital" ? 1450000 : rank === "Regional Center" ? 520000 : 185000;
+    const pi = indexOf(p.x, p.y);
+    const geographyBoost = clamp(plain[pi] * 0.34 + agriculture[pi] * 0.18 + basinField[pi] * 0.2 + coastalLowland[pi] * 0.18 + valleyField[pi] * 0.12 + (p.kind === "Port Town" ? 0.22 : 0));
+    const population = Math.round((rankBase + rankSpread * Math.pow(rawScale + geographyBoost * 0.18, 1.75)) / 1000) * 1000;
+    const urbanRadius = clamp(7.5 + Math.sqrt(population) / 80 + (rank === "Prefectural Capital" ? 3.0 : rank === "Regional Center" ? 1.5 : 0), 8, 32);
+    const coreRadius = clamp(2.6 + Math.sqrt(population) / 320, 3, 9);
+    const urbanWeight = clamp(0.74 + Math.log10(Math.max(10000, population)) * 0.36, 1.15, 3.05);
+    return { ...p, population, urbanRadius, coreRadius, urbanWeight, rank, kind: p.kind || "City" };
+  });
+
+  if (modernCities.length > 0) {
+    modernCities.sort((a, b) => (b.population || 0) + b.score * 90000 - ((a.population || 0) + a.score * 90000));
+    modernCities[0] = {
+      ...modernCities[0],
+      rank: "Prefectural Capital",
+      kind: "Prefectural Capital",
+      isPrefecturalCapital: true,
+      population: Math.max(modernCities[0].population || 0, 620000),
+      urbanRadius: Math.max(modernCities[0].urbanRadius || 0, 18),
+      coreRadius: Math.max(modernCities[0].coreRadius || 0, 5.5),
+      urbanWeight: Math.max(modernCities[0].urbanWeight || 0, 2.15),
+    };
+    for (let i = 1; i < modernCities.length; i++) modernCities[i] = { ...modernCities[i], isPrefecturalCapital: false };
+  }
+
+  const capital = modernCities[0] || markets[0] || ports[0] || { x: Math.floor(MAP_W / 2), y: Math.floor(MAP_H / 2), score: 1, population: 0, urbanRadius: 12, coreRadius: 4, urbanWeight: 1, isPrefecturalCapital: true };
+
+  const populationDensity = new Float32Array(SIZE);
+  let maxPopulationDensity = 0;
+  for (let y = 0; y < MAP_H; y++) {
+    for (let x = 0; x < MAP_W; x++) {
+      const i = indexOf(x, y);
+      if (sea[i]) continue;
+      let density = 0;
+      for (const city of modernCities) {
+        const populationScale = clamp((Math.log10(Math.max(10000, city.population || 10000)) - 4) / 2.25, 0.12, 1.55);
+        const d = Math.hypot(city.x - x, city.y - y);
+        const urbanR = Math.max(5, city.urbanRadius || 11);
+        const coreR = Math.max(2.4, city.coreRadius || 4);
+        density += populationScale * 1.55 / (1 + Math.pow(d / urbanR, 2.35));
+        density += populationScale * 1.05 * Math.exp(-(d * d) / (coreR * coreR * 2.2));
+      }
+      for (const market of markets) {
+        const d = Math.hypot(market.x - x, market.y - y);
+        density += 0.22 / (1 + Math.pow(d / 7.5, 2.2));
+      }
+      for (const village of villages) {
+        const d = Math.hypot(village.x - x, village.y - y);
+        density += 0.055 / (1 + Math.pow(d / 4.2, 2));
+      }
+      density *= clamp(0.48 + plain[i] * 0.62 + agriculture[i] * 0.14 + basinField[i] * 0.22 + coastalLowland[i] * 0.18 + valleyField[i] * 0.1 - slope[i] * 1.05 - ridgeField[i] * 0.48 - Math.max(0, elevation[i] - 0.58) * 1.05, 0.018, 1.22);
+      populationDensity[i] = density;
+      if (density > maxPopulationDensity) maxPopulationDensity = density;
+    }
+  }
+  if (maxPopulationDensity > 0) {
+    for (let i = 0; i < SIZE; i++) populationDensity[i] = clamp(populationDensity[i] / maxPopulationDensity);
+  }
+
+  function densityValue(x, y) {
+    return populationDensity[indexOf(x, y)] || 0;
+  }
+
+  function midDensityAffinity(x, y) {
+    const d = densityValue(x, y);
+    return clamp(1 - Math.abs(d - 0.38) / 0.38);
+  }
+
+  function nearPassPoint(x, y, radius = 5) {
+    return distanceToNearest(passes, x, y) <= radius;
+  }
+
+  function mountainBarrierPenalty(x, y, type = "rail") {
+    const i = indexOf(x, y);
+    const e = elevation[i];
+    const s = slope[i];
+    const pass = nearPassPoint(x, y, type === "express" ? 7 : 5);
+    if (e > 0.86) return INF;
+    if (pass && e > 0.82 && s > 0.16) return INF;
+    if (!pass && e > 0.80) return INF;
+    if (!pass && e > 0.72 && s > 0.18) return INF;
+    if (!pass && e > 0.68 && s > 0.32) return INF;
+    if (!pass && e > 0.74) return type === "express" ? 175 : 215;
+    if (!pass && e > 0.66 && s > 0.22) return type === "express" ? 105 : 135;
+    const passDiscount = pass ? 0.18 : 1;
+    const mountain = Math.max(0, e - 0.50);
+    const steep = Math.max(0, s - 0.18);
+    const typeFactor = type === "express" ? 260 : type === "rail" ? 320 : 120;
+    return (mountain * mountain * typeFactor + steep * steep * 120) * passDiscount;
+  }
+
+  function transportAccessPoint(node, mode = "road", salt = 0) {
+    if (!node || nearMapEdge(node.x, node.y, 1) || node.kind === "External Gateway") return node;
+    const minR = mode === "express" ? 10 : mode === "rail" ? 2 : 4;
+    const maxR = mode === "express" ? 20 : mode === "rail" ? 6 : 10;
+    let best = null;
+    let bestScore = -INF;
+    for (let dy = -maxR; dy <= maxR; dy++) {
+      for (let dx = -maxR; dx <= maxR; dx++) {
+        const d = Math.hypot(dx, dy);
+        if (d < minR || d > maxR) continue;
+        const x = node.x + dx;
+        const y = node.y + dy;
+        if (!inside(x, y)) continue;
+        const i = indexOf(x, y);
+        if (sea[i]) continue;
+        const barrier = mode === "express" || mode === "rail" ? mountainBarrierPenalty(x, y, mode) : 0;
+        if (barrier >= INF) continue;
+        const targetD = (minR + maxR) * 0.5;
+        const flatness = plain[i] * 1.0 + agriculture[i] * 0.2 + valleyField[i] * 0.26 + coastalLowland[i] * 0.16 - slope[i] * 1.22 - ridgeField[i] * 0.72 - Math.max(0, elevation[i] - 0.58) * 2.35;
+        const ring = -Math.abs(d - targetD) * 0.08;
+        const riverPenalty = river[i] > 0.5 ? 0.45 : river[i] * 0.12;
+        const density = densityValue(x, y);
+        const densityAffinity = mode === "rail" ? density * 0.9 : mode === "express" ? midDensityAffinity(x, y) * 0.52 - Math.max(0, density - 0.72) * 0.9 : density * 0.24;
+        const noise = hash2(x, y, seed + salt + (mode === "rail" ? 6000 : mode === "express" ? 7000 : 5000)) * 0.12;
+        const score = flatness + densityAffinity + ring - riverPenalty - barrier * 0.012 + noise;
+        if (score > bestScore) {
+          bestScore = score;
+          best = { x, y, score: node.score || 0.5, kind: `${mode} Access`, parent: node };
+        }
+      }
+    }
+    return best || node;
+  }
+
+  function routePoint(node, mode, salt = 0) {
+    return transportAccessPoint(node, mode, salt);
+  }
+
+  const townAvoidNodes = [...modernCities, ...markets, ...ports];
+
+  const urbanCenters = modernCities.map((city, n) => {
+    let best = { x: city.x, y: city.y, score: city.score + 0.5 };
+    let bestScore = -INF;
+    const searchR = Math.max(2, Math.round(city.coreRadius));
+    for (let dy = -searchR; dy <= searchR; dy++) {
+      for (let dx = -searchR; dx <= searchR; dx++) {
+        const x = city.x + dx;
+        const y = city.y + dy;
+        if (!inside(x, y)) continue;
+        const i = indexOf(x, y);
+        if (sea[i]) continue;
+        const d = Math.hypot(dx, dy);
+        const score = plain[i] * 0.54 + agriculture[i] * 0.16 - slope[i] * 0.36 - d * 0.06 + hash2(x, y, seed + 1700 + n) * 0.07;
+        if (score > bestScore) { bestScore = score; best = { x, y, score: city.score + 0.5, cityIndex: n, parent: city }; }
+      }
+    }
+    return { ...best, kind: city.rank === "Prefectural Capital" ? "Central Business District" : "Urban Center", population: Math.round(city.population * (city.rank === "Prefectural Capital" ? 0.18 : 0.12)), insidePrefecture: Boolean(prefectureMask[indexOf(best.x, best.y)]) };
+  });
+
+  function railCost(x, y) {
+    const i = indexOf(x, y);
+    if (sea[i]) return INF;
+    const barrier = mountainBarrierPenalty(x, y, "rail");
+    if (barrier >= INF) return INF;
+    const density = densityValue(x, y);
+    const highPenalty = Math.max(0, elevation[i] - 0.52) * 14 + barrier;
+    const riverPenalty = river[i] > 0.5 ? 1.6 : river[i] > 0.25 ? 0.7 : 0;
+    return Math.max(0.42, 1 + slope[i] * 22 + highPenalty + riverPenalty + floodplain[i] * 0.28 - density * 0.88 - plain[i] * 0.28 - valleyField[i] * 0.62 - coastalLowland[i] * 0.48 + ridgeField[i] * 1.4 + normalEdgePenalty(x, y) + hash2(x, y, seed + 222) * 0.08);
+  }
+
+  const railways = [];
+  const branchRailways = [];
+  const railDegree = new Map();
+  const railCore = [capital];
+  const railHubs = [...modernCities, ...commercialPorts];
+
+  function addRailRoute(a, b, bucket = railways) {
+    const start = routePoint(a, "rail", a.x * 19 + a.y * 23);
+    const goal = routePoint(b, "rail", b.x * 19 + b.y * 23 + 11);
+    const existingRails = [...railways, ...branchRailways];
+    const cost = makeTransportCost(railCost, existingRails, railHubs, [start, goal], 5, 10.5, townAvoidNodes, 2.4, 4.2);
+    const path = aStar(start, goal, cost);
+    const length = pathLength(path);
+    const direct = pathEndpointDistance(path);
+    const overlap = pathOverlapRatio(path, existingRails, 2);
+    const densityPurpose = averagePathField(path, populationDensity) + averagePathField(path, plain) * 0.28 + averagePathField(path, valleyField) * 0.2;
+    const isMain = bucket === railways;
+    if (path.length > 3 && direct >= (isMain ? 18 : 12) && length >= (isMain ? 22 : 14) && pathCompactness(path) < (isMain ? 3.1 : 3.4) && overlap < (isMain ? 0.30 : 0.20) && densityPurpose > (isMain ? 0.18 : 0.12)) {
+      bucket.push(path);
+      incrementDegree(railDegree, a);
+      incrementDegree(railDegree, b);
+      return true;
+    }
+    return false;
+  }
+
+  const transportCities = modernCities.filter((city) => (city.population || 0) >= 120000);
+  const mainRailTargets = transportCities.filter((city) => city !== capital).slice(0, 2 + Math.floor(rand(seed, 1070) * 3));
+  for (const city of mainRailTargets) {
+    const anchor = nearestConnectable(railCore, city, railDegree, 3) || capital;
+    if (addRailRoute(anchor, city, railways)) railCore.push(city);
+  }
+  for (const city of modernCities.filter((city) => city !== capital && !mainRailTargets.includes(city))) {
+    const anchor = nearestConnectable(railCore, city, railDegree, 2) || capital;
+    if (anchor && rand(seed, city.x * 10 + city.y) > 0.2) {
+      if (addRailRoute(city, anchor, branchRailways)) railCore.push(city);
+    }
+  }
+  for (const port of majorPorts.slice(0, 1 + Math.floor(rand(seed, 1071) * 2))) {
+    const anchor = nearestConnectable(railCore, port, railDegree, 2) || capital;
+    if (anchor && addRailRoute(port, anchor, branchRailways)) railCore.push(port);
+  }
+
+  compactPathArray(railways, { minLength: 17, maxOverlap: 0.34, maxCount: 5 });
+  compactPathArray(branchRailways, { minLength: 11, maxOverlap: 0.22, maxCount: 9 });
+
+  const railInfluence = influenceFromPaths([...railways, ...branchRailways], 5);
+  const stationCandidates = [
+    ...modernCities.map((p, i) => ({ ...routePoint(p, "rail", 1900 + i), score: p.score + 0.46, kind: "Major Station", population: p.population })),
+    ...railways.flatMap((path) => samplePath(path, 18 + Math.floor(rand(seed, path.length) * 14))).map((p) => ({ ...p, kind: "Station", score: 0.52 + agriculture[indexOf(p.x, p.y)] * 0.2 })),
+    ...branchRailways.flatMap((path) => samplePath(path, 16 + Math.floor(rand(seed, path.length + 99) * 14))).map((p) => ({ ...p, kind: "Station", score: 0.42 + agriculture[indexOf(p.x, p.y)] * 0.2 })),
+  ];
+
+  let stations = pickEntities(stationCandidates, { max: 14 + Math.floor(rand(seed, 1080) * 22), minDistance: 6, threshold: 0.38, seed: seed + 1080 });
+
+  const industrialScore = new Float32Array(SIZE);
+  for (let y = 4; y < MAP_H - 4; y++) {
+    for (let x = 4; x < MAP_W - 4; x++) {
+      const i = indexOf(x, y);
+      if (sea[i]) continue;
+      const nearPort = 1 / (1 + distanceToNearest(majorPorts.length ? majorPorts : commercialPorts, x, y) / 5);
+      const nearCity = distanceToNearest(modernCities, x, y);
+      const cityEdge = nearCity > 5 && nearCity < 20 ? 0.22 : nearCity <= 5 ? -0.25 : 0;
+      industrialScore[i] = clamp(plain[i] * 0.24 + coastalLowland[i] * 0.24 + railInfluence[i] * 0.38 + nearPort * 0.58 + river[i] * 0.04 + cityEdge - slope[i] * 0.36 - ridgeField[i] * 0.18 - floodplain[i] * 0.03);
+    }
+  }
+
+  let industrialZones = pickPoints(industrialScore, {
+    threshold: 0.31 + rand(seed, 1091) * 0.09,
+    max: 4 + Math.floor(rand(seed, 1092) * 13),
+    minDistance: 10,
+    seedOffset: 1090,
+    predicate: (x, y, i) => !sea[i],
+  }).map((p) => ({ ...p, kind: "Industrial Zone" }));
+
+  function roadCost(x, y) {
+    const i = indexOf(x, y);
+    if (sea[i]) return INF;
+    const density = densityValue(x, y);
+    const nodeAvoid = distanceToNearest(townAvoidNodes, x, y) < 2.2 ? 2.0 : 0;
+    return Math.max(0.35, 1 + slope[i] * 15.8 + Math.max(0, elevation[i] - 0.56) * 2.6 + nodeAvoid + (river[i] > 0.45 ? 0.85 : 0) + floodplain[i] * 0.22 - density * 0.50 - plain[i] * 0.18 - valleyField[i] * 0.24 - coastalLowland[i] * 0.18 + ridgeField[i] * 0.90 + normalEdgePenalty(x, y) + hash2(x, y, seed + 333) * 0.08);
+  }
+
+  function expresswayCost(x, y) {
+    const i = indexOf(x, y);
+    if (sea[i]) return INF;
+    const barrier = mountainBarrierPenalty(x, y, "express");
+    if (barrier >= INF) return INF;
+    const density = densityValue(x, y);
+    const midDensity = midDensityAffinity(x, y);
+    const cityDistance = distanceToNearest(modernCities, x, y);
+    const cityAvoid = cityDistance < 5 ? 22.0 : cityDistance < 9 ? 11.0 : cityDistance < 13 ? 4.0 : distanceToNearest(markets, x, y) < 4 ? 3.2 : 0;
+    const densityPenalty = density > 0.66 ? (density - 0.66) * 9.5 : density < 0.08 ? (0.08 - density) * 2.4 : 0;
+    const highPenalty = barrier + (elevation[i] > 0.72 ? 26 : elevation[i] > 0.62 ? 8.5 : 0);
+    return Math.max(0.42, 1 + slope[i] * 23.0 + highPenalty + cityAvoid + densityPenalty + (river[i] > 0.45 ? 1.0 : 0) - midDensity * 0.82 - plain[i] * 0.16 - valleyField[i] * 0.16 - coastalLowland[i] * 0.18 + ridgeField[i] * 1.20 + normalEdgePenalty(x, y) + hash2(x, y, seed + 444) * 0.015);
+  }
+
+  const nationalRoads = [];
+  const roadDegree = new Map();
+  const roadTargets = pickEntities([...modernCities.filter((p) => (p.population || 0) >= 90000), ...ports, ...markets].map((p) => ({ ...p, score: p.score + ((p.population || 0) >= 180000 ? 0.18 : 0.05) })), {
+    max: 8 + Math.floor(rand(seed, 1101) * 10),
+    minDistance: 9,
+    threshold: 0,
+    seed: seed + 1100,
+  });
+  const roadHubs = [...modernCities, ...ports, ...markets, ...stations];
+  const roadCore = [capital];
+
+  function addNationalRoad(a, b) {
+    const start = routePoint(a, "road", a.x * 31 + a.y * 37);
+    const goal = routePoint(b, "road", b.x * 31 + b.y * 37 + 17);
+    const existing = [...nationalRoads, ...railways, ...branchRailways];
+    const path = aStar(start, goal, makeTransportCost(roadCost, existing, roadHubs, [start, goal], 3, 5.8, townAvoidNodes, 3.2, 5.4));
+    const direct = pathEndpointDistance(path);
+    const urbanPasses = modernCities.filter((city) => path.some(([x, y]) => Math.hypot(x - city.x, y - city.y) <= Math.max(6, Math.min(13, (city.urbanRadius || 8) * 0.78)))).length;
+    const passBonusOk = urbanPasses >= 2 || direct >= 24;
+    if (path.length > 3 && direct >= 16 && pathLength(path) >= 20 && pathCompactness(path) < 3.35 && pathOverlapRatio(path, existing, 2) < 0.48 && passBonusOk) {
+      nationalRoads.push(path);
+      incrementDegree(roadDegree, a);
+      incrementDegree(roadDegree, b);
+      return true;
+    }
+    return false;
+  }
+
+  for (const target of roadTargets.slice(1, 8 + Math.floor(rand(seed, 1102) * 7))) {
+    const anchor = nearestConnectable(roadCore, target, roadDegree, 3) || capital;
+    if (addNationalRoad(anchor, target)) roadCore.push(target);
+  }
+  for (let i = 1; i < roadTargets.length - 1; i++) {
+    const a = roadTargets[i];
+    const b = pickEntities(roadTargets.filter((p) => p !== a && getDegree(roadDegree, p) < 4).map((p) => ({ ...p, score: 1 / (1 + Math.hypot(p.x - a.x, p.y - a.y)) })), { max: 1, minDistance: 1, threshold: 0 })[0];
+    const d = b ? Math.hypot(a.x - b.x, a.y - b.y) : 0;
+    if (b && d >= 18 && d < 52 && getDegree(roadDegree, a) < 4 && rand(seed, i + 1111) > 0.24) {
+      addNationalRoad(a, b);
+    }
+  }
+
+  // National roads should behave like long trunk corridors: they intentionally
+  // pass near as many urbanized cells/cities as possible, unlike expressways.
+  const trunkCities = modernCities
+    .filter((city) => prefectureMask[indexOf(city.x, city.y)] && (city.population || 0) >= 90000)
+    .slice()
+    .sort((a, b) => a.x - b.x || a.y - b.y);
+  for (let i = 0; i < trunkCities.length - 1; i += 2) {
+    const a = trunkCities[i];
+    const b = trunkCities[Math.min(trunkCities.length - 1, i + 2)];
+    if (a && b && Math.hypot(a.x - b.x, a.y - b.y) >= 22 && getDegree(roadDegree, a) < 5) addNationalRoad(a, b);
+  }
+
+  const expressTargets = pickEntities(modernCities.filter((p) => p !== capital && (p.population || 0) >= 180000).map((p) => ({ ...p, score: p.score + Math.hypot(p.x - capital.x, p.y - capital.y) / 80 + 0.15 })).concat(majorPorts.map((p) => ({ ...p, score: p.score + 0.55 }))), {
+    max: 1 + Math.floor(rand(seed, 1120) * 3),
+    minDistance: 20,
+    threshold: 0.05,
+    seed: seed + 1120,
+  });
+
+  const expressways = [];
+  const expressDegree = new Map();
+  const expressCore = [capital];
+
+  function addExpressway(a, b, bucket = expressways) {
+    const start = routePoint(a, "express", a.x * 41 + a.y * 43);
+    const goal = routePoint(b, "express", b.x * 41 + b.y * 43 + 29);
+    const existing = [...expressways, ...nationalRoads, ...railways, ...branchRailways];
+    let path = aStar(start, goal, makeTransportCost(expresswayCost, existing, roadHubs, [start, goal], 5, 10.8, townAvoidNodes, 8.5, 14.0));
+    path = smoothPathByLineOfSight(path, (x, y) => expresswayCost(x, y, x, y) < INF && slope[indexOf(x, y)] < 0.54 && elevation[indexOf(x, y)] < 0.78, 10);
+    const direct = pathEndpointDistance(path);
+    if (path.length > 8 && direct >= 26 && pathLength(path) >= 30 && pathCompactness(path) < 2.35 && pathOverlapRatio(path, existing, 2) < 0.30) {
+      bucket.push(path);
+      incrementDegree(expressDegree, a);
+      incrementDegree(expressDegree, b);
+      return true;
+    }
+    return false;
+  }
+
+  for (const target of expressTargets) {
+    const anchor = nearestConnectable(expressCore, target, expressDegree, 2) || capital;
+    if (addExpressway(anchor, target)) expressCore.push(target);
+  }
+
+  const ringRoads = [];
+  const ringExpressways = [];
+  const ringRailways = [];
+
+  function ringAnchorCandidates(city, mode, targetRadius, sectors = 8) {
+    const anchors = [];
+    const minR = Math.max(5, targetRadius - 5);
+    const maxR = targetRadius + 7;
+    for (let s = 0; s < sectors; s++) {
+      const angle0 = (s / sectors) * Math.PI * 2;
+      let best = null;
+      let bestScore = -INF;
+      for (let dy = -Math.ceil(maxR); dy <= Math.ceil(maxR); dy++) {
+        for (let dx = -Math.ceil(maxR); dx <= Math.ceil(maxR); dx++) {
+          const d = Math.hypot(dx, dy);
+          if (d < minR || d > maxR) continue;
+          const angle = Math.atan2(dy, dx);
+          let delta = Math.abs(Math.atan2(Math.sin(angle - angle0), Math.cos(angle - angle0)));
+          if (delta > Math.PI / sectors * 0.95) continue;
+          const x = city.x + dx;
+          const y = city.y + dy;
+          if (!inside(x, y)) continue;
+          const i = indexOf(x, y);
+          if (sea[i] || !prefectureMask[i]) continue;
+          const barrier = mode === "road" ? 0 : mountainBarrierPenalty(x, y, mode === "express" ? "express" : "rail");
+          if (barrier >= INF) continue;
+          const density = densityValue(x, y);
+          const densityTerm = mode === "rail" ? density * 0.75 : mode === "express" ? midDensityAffinity(x, y) * 0.72 : density * 0.28 + midDensityAffinity(x, y) * 0.22;
+          const score = plain[i] * 0.72 + agriculture[i] * 0.12 + densityTerm - slope[i] * 1.25 - Math.max(0, elevation[i] - 0.58) * 1.3 - barrier * 0.01 - Math.abs(d - targetRadius) * 0.035 + hash2(x, y, seed + 4100 + s * 37 + mode.length * 101) * 0.08;
+          if (score > bestScore) {
+            bestScore = score;
+            best = { x, y, score, kind: `${mode} ring anchor`, parent: city };
+          }
+        }
+      }
+      if (best) anchors.push(best);
+    }
+    return anchors;
+  }
+
+  function ringCost(baseCost, city, targetRadius, mode) {
+    return (x, y, cx, cy) => {
+      const base = baseCost(x, y, cx, cy);
+      if (base >= INF) return base;
+      const d = Math.hypot(x - city.x, y - city.y);
+      const tooClose = Math.max(0, targetRadius * 0.46 - d);
+      const tooFar = Math.max(0, d - targetRadius * 1.55);
+      const bandPenalty = tooClose * 0.34 + tooFar * 0.16 + Math.abs(d - targetRadius) * 0.018;
+      const density = densityValue(x, y);
+      const densityBias = mode === "rail" ? -density * 0.42 : mode === "express" ? -midDensityAffinity(x, y) * 0.32 + Math.max(0, density - 0.82) * 0.8 : -density * 0.12;
+      return Math.max(0.36, base + bandPenalty + densityBias);
+    };
+  }
+
+  function softRingRailCost(x, y) {
+    const i = indexOf(x, y);
+    if (sea[i] || elevation[i] > 0.82) return INF;
+    const density = densityValue(x, y);
+    return Math.max(0.38, 1 + slope[i] * 12 + Math.max(0, elevation[i] - 0.58) * 16 + (river[i] > 0.5 ? 1.3 : river[i] * 0.6) - density * 0.62 - plain[i] * 0.18 + normalEdgePenalty(x, y) + hash2(x, y, seed + 7222) * 0.05);
+  }
+
+  function softRingExpressCost(x, y) {
+    const i = indexOf(x, y);
+    if (sea[i] || elevation[i] > 0.82) return INF;
+    return Math.max(0.38, 1 + slope[i] * 11 + Math.max(0, elevation[i] - 0.6) * 14 + (river[i] > 0.5 ? 1.0 : river[i] * 0.5) - midDensityAffinity(x, y) * 0.42 - plain[i] * 0.12 + normalEdgePenalty(x, y) + hash2(x, y, seed + 7444) * 0.05);
+  }
+
+  function addEnvironmentalRing(city, mode, bucket, baseCost, existingPaths, targetRadius) {
+    const anchors = ringAnchorCandidates(city, mode, targetRadius, mode === "road" ? 7 : 8);
+    if (anchors.length < 3) return 0;
+    let made = 0;
+    const cost = ringCost(baseCost, city, targetRadius, mode);
+    for (let i = 0; i < anchors.length - (anchors.length < 4 ? 1 : 0); i++) {
+      const a = anchors[i];
+      const b = anchors[(i + 1) % anchors.length];
+      if (Math.hypot(a.x - b.x, a.y - b.y) > targetRadius * 1.85) continue;
+      const path = aStar(a, b, makeTransportCost(cost, [...existingPaths, ...bucket], roadHubs, [a, b], mode === "road" ? 3 : 4, mode === "road" ? 4.8 : 7.0, townAvoidNodes, mode === "express" ? 3.8 : 2.2, mode === "express" ? 4.8 : 2.8));
+      if (path.length >= 5 && path.length <= targetRadius * 8.0) {
+        bucket.push(path);
+        made++;
+      }
+    }
+    return made;
+  }
+
+  function flexibleRingAnchors(city, targetRadius, maxAnchors = 6) {
+    const candidates = [];
+    const maxR = targetRadius + 11;
+    const minR = Math.max(5, targetRadius * 0.45);
+    for (let dy = -Math.ceil(maxR); dy <= Math.ceil(maxR); dy++) {
+      for (let dx = -Math.ceil(maxR); dx <= Math.ceil(maxR); dx++) {
+        const d = Math.hypot(dx, dy);
+        if (d < minR || d > maxR) continue;
+        const x = city.x + dx;
+        const y = city.y + dy;
+        if (!inside(x, y)) continue;
+        const i = indexOf(x, y);
+        if (sea[i] || !prefectureMask[i] || elevation[i] > 0.82) continue;
+        const score = plain[i] * 0.7 + midDensityAffinity(x, y) * 0.32 + densityValue(x, y) * 0.2 - slope[i] * 1.15 - Math.max(0, elevation[i] - 0.58) * 0.88 - Math.abs(d - targetRadius) * 0.02 + hash2(x, y, seed + 7555) * 0.06;
+        candidates.push({ x, y, score, angle: Math.atan2(dy, dx), kind: "flexible ring anchor", parent: city });
+      }
+    }
+    return pickEntities(candidates, { max: maxAnchors, minDistance: 5, threshold: -1, seed: seed + city.x * 83 + city.y * 89 })
+      .sort((a, b) => a.angle - b.angle);
+  }
+
+  function addLooseEnvironmentalRing(city, bucket, baseCost, targetRadius) {
+    let anchors = ringAnchorCandidates(city, "road", targetRadius, 6);
+    if (anchors.length < 3) anchors = flexibleRingAnchors(city, targetRadius, 6);
+    if (anchors.length < 2) return 0;
+    let made = 0;
+    for (let i = 0; i < anchors.length; i++) {
+      const a = anchors[i];
+      const b = anchors[(i + 1) % anchors.length];
+      const path = aStar(a, b, (x, y, cx, cy) => {
+        const base = baseCost(x, y, cx, cy);
+        if (base >= INF) return INF;
+        const d = Math.hypot(x - city.x, y - city.y);
+        const band = Math.max(0, targetRadius * 0.42 - d) * 0.22 + Math.max(0, d - targetRadius * 1.7) * 0.14 + Math.abs(d - targetRadius) * 0.012;
+        return Math.max(0.3, base + band);
+      });
+      if (path.length >= 4 && path.length <= targetRadius * 9.0) {
+        bucket.push(path);
+        made++;
+      }
+    }
+    return made;
+  }
+
+  const mediumRingCities = modernCities.filter((c) => (c.population || 0) >= 130000).slice(0, 6);
+  for (const city of mediumRingCities) {
+    const radius = clamp(8 + Math.sqrt(city.population || 100000) / 170, 10, 22);
+    addEnvironmentalRing(city, "road", ringRoads, roadCost, [...nationalRoads, ...railways, ...branchRailways], radius);
+  }
+  const largeRingCities = modernCities.filter((c) => (c.population || 0) >= 900000).slice(0, 1);
+  for (const city of largeRingCities) {
+    const roadRadius = clamp(10 + Math.sqrt(city.population || 400000) / 155, 13, 28);
+    const expressRadius = roadRadius + 3 + rand(seed, city.x * 71 + city.y * 73) * 3;
+    const railRadius = Math.max(8, roadRadius - 4);
+    addEnvironmentalRing(city, "road", ringRoads, roadCost, [...nationalRoads, ...expressways, ...railways, ...branchRailways], roadRadius);
+    const expressRingSegments = addEnvironmentalRing(city, "express", ringExpressways, expresswayCost, [...expressways, ...nationalRoads, ...railways, ...branchRailways], expressRadius);
+    const railRingSegments = addEnvironmentalRing(city, "rail", ringRailways, railCost, [...railways, ...branchRailways, ...nationalRoads, ...expressways], railRadius);
+    // Expressway rings should be rare; do not force a fallback ring when terrain rejects it.
+    if (railRingSegments === 0) addLooseEnvironmentalRing(city, ringRailways, softRingRailCost, railRadius);
+  }
+  compactPathArray(ringExpressways, { minLength: 10, maxOverlap: 0.22, maxCount: 2 });
+  compactPathArray(ringRoads, { minLength: 8, maxOverlap: 0.32, maxCount: 18 });
+  compactPathArray(ringRailways, { minLength: 8, maxOverlap: 0.26, maxCount: 8 });
+
+  const gatewayCandidates = [];
+  for (let x = 0; x < MAP_W; x++) for (const y of [0, MAP_H - 1]) { const i = indexOf(x, y); if (!sea[i]) gatewayCandidates.push({ x, y, side: y === 0 ? "N" : "S", score: plain[i] + agriculture[i] + (1 - slope[i]) * 0.5 }); }
+  for (let y = 0; y < MAP_H; y++) for (const x of [0, MAP_W - 1]) { const i = indexOf(x, y); if (!sea[i]) gatewayCandidates.push({ x, y, side: x === 0 ? "W" : "E", score: plain[i] + agriculture[i] + (1 - slope[i]) * 0.5 }); }
+
+  let externalGateways = pickEntities(gatewayCandidates, {
+    max: 2 + Math.floor(rand(seed, 1201) * 3),
+    minDistance: 28,
+    threshold: 0.4,
+    seed: seed + 1201,
+  }).map((p) => ({ ...p, kind: "External Gateway" }));
+
+  function externalRoadCost(goal) {
+    return (x, y) => {
+      const i = indexOf(x, y);
+      if (sea[i]) return INF;
+      const borderPenalty = nearMapEdge(x, y, 1) && !(Math.abs(x - goal.x) <= 2 && Math.abs(y - goal.y) <= 2) ? 7 : nearMapEdge(x, y, 3) ? 1.5 : 0;
+      const density = densityValue(x, y);
+      const nodeAvoid = distanceToNearest(townAvoidNodes, x, y) < 2.2 ? 2.0 : 0;
+      return Math.max(0.35, 1 + slope[i] * 10 + nodeAvoid + (river[i] > 0.45 ? 0.9 : 0) + floodplain[i] * 0.24 - density * 0.3 - plain[i] * 0.22 + borderPenalty + hash2(x, y, seed + 333) * 0.06);
+    };
+  }
+  function externalExpresswayCost(goal) {
+    return (x, y) => {
+      const i = indexOf(x, y);
+      if (sea[i]) return INF;
+      const barrier = mountainBarrierPenalty(x, y, "express");
+      if (barrier >= INF) return INF;
+      const borderPenalty = nearMapEdge(x, y, 1) && !(Math.abs(x - goal.x) <= 2 && Math.abs(y - goal.y) <= 2) ? 7 : nearMapEdge(x, y, 3) ? 1.5 : 0;
+      const density = densityValue(x, y);
+      const cityDistance = distanceToNearest(modernCities, x, y);
+      const cityAvoid = cityDistance < 5 ? 22.0 : cityDistance < 9 ? 11.0 : cityDistance < 13 ? 4.0 : distanceToNearest(markets, x, y) < 4 ? 3.2 : 0;
+      const densityPenalty = density > 0.66 ? (density - 0.66) * 9.5 : density < 0.08 ? (0.08 - density) * 2.4 : 0;
+      return Math.max(0.42, 1 + slope[i] * 19 + barrier + cityAvoid + densityPenalty + (river[i] > 0.45 ? 1 : 0) + floodplain[i] * 0.2 - midDensityAffinity(x, y) * 0.7 - plain[i] * 0.12 + borderPenalty + hash2(x, y, seed + 444) * 0.05);
+    };
+  }
+  function externalRailCost(goal) {
+    return (x, y) => {
+      const i = indexOf(x, y);
+      if (sea[i]) return INF;
+      const barrier = mountainBarrierPenalty(x, y, "rail");
+      if (barrier >= INF) return INF;
+      const borderPenalty = nearMapEdge(x, y, 1) && !(Math.abs(x - goal.x) <= 2 && Math.abs(y - goal.y) <= 2) ? 9 : nearMapEdge(x, y, 3) ? 1.8 : 0;
+      const density = densityValue(x, y);
+      return Math.max(0.42, 1 + slope[i] * 22 + barrier + Math.max(0, elevation[i] - 0.52) * 14 + (river[i] > 0.45 ? 1.2 : 0) + borderPenalty - density * 1.0 - plain[i] * 0.28 + hash2(x, y, seed + 222) * 0.05);
+    };
+  }
+
+  const externalRoads = [];
+  const externalExpressways = [];
+  const externalRailways = [];
+
+  function selectExternalStart(pool, gate, degreeMap, maxDegree = 2) {
+    const sorted = pool
+      .filter(Boolean)
+      .map((p) => ({ ...p, d: Math.hypot(p.x - gate.x, p.y - gate.y), degree: getDegree(degreeMap, p) }))
+      .sort((a, b) => a.d + a.degree * 16 + (a.degree >= maxDegree ? 30 : 0) - (b.d + b.degree * 16 + (b.degree >= maxDegree ? 30 : 0)));
+    return sorted.find((p) => p.degree < maxDegree) || sorted[0] || capital;
+  }
+
+  externalGateways.forEach((gate, idx) => {
+    const makeExpressLink = idx === 0 || rand(seed, 1210 + idx) > 0.4;
+    const roadStartRaw = selectExternalStart([...roadCore, ...modernCities, ...ports, ...markets], gate, roadDegree, 3);
+    const roadStart = routePoint(roadStartRaw, makeExpressLink ? "express" : "road", gate.x * 53 + gate.y * 59);
+    const roadExisting = [...nationalRoads, ...expressways, ...externalRoads, ...externalExpressways, ...railways, ...branchRailways];
+    const roadBaseCost = makeExpressLink ? externalExpresswayCost(gate) : externalRoadCost(gate);
+    const roadPath = aStar(roadStart, gate, makeTransportCost(roadBaseCost, roadExisting, roadHubs, [roadStart, gate], makeExpressLink ? 4 : 3, makeExpressLink ? 8.2 : 6.2, townAvoidNodes, makeExpressLink ? 5.4 : 3.2, makeExpressLink ? 7.8 : 5.6));
+    if (roadPath.length > 6) {
+      if (makeExpressLink) {
+        externalExpressways.push(roadPath);
+        incrementDegree(expressDegree, roadStartRaw);
+        incrementDegree(expressDegree, gate);
+        expressCore.push(gate);
+      } else {
+        externalRoads.push(roadPath);
+        incrementDegree(roadDegree, roadStartRaw);
+        incrementDegree(roadDegree, gate);
+      }
+    }
+    if ((idx === 0 || rand(seed, 1220 + idx) > 0.5) && modernCities.length > 0) {
+      const railStartRaw = selectExternalStart([...railCore, ...modernCities, ...ports], gate, railDegree, 2);
+      const railStart = routePoint(railStartRaw, "rail", gate.x * 61 + gate.y * 67);
+      const railExisting = [...railways, ...branchRailways, ...externalRailways, ...nationalRoads, ...expressways, ...externalExpressways];
+      const railPath = aStar(railStart, gate, makeTransportCost(externalRailCost(gate), railExisting, railHubs, [railStart, gate], 4, 8.2, townAvoidNodes, 2.5, 4.4));
+      if (railPath.length > 6) {
+        externalRailways.push(railPath);
+        incrementDegree(railDegree, railStartRaw);
+        incrementDegree(railDegree, gate);
+      }
+    }
+  });
+
+  function pruneHighMountainTransport(paths, threshold = 0.82) {
+    for (let i = paths.length - 1; i >= 0; i--) {
+      if (paths[i].some(([x, y]) => elevation[indexOf(x, y)] > threshold)) paths.splice(i, 1);
+    }
+  }
+  for (const paths of [railways, branchRailways, ringRailways, externalRailways, expressways, ringExpressways, externalExpressways]) pruneHighMountainTransport(paths, 0.82);
+
+  const expressInfluence = influenceFromPaths([...expressways, ...externalExpressways, ...ringExpressways], 6);
+  const roadInfluence = influenceFromPaths([...nationalRoads, ...ringRoads, ...expressways, ...ringExpressways, ...externalRoads, ...externalExpressways], 4);
+
+  const icCandidates = [];
+  for (const path of [...expressways, ...ringExpressways, ...externalExpressways]) {
+    icCandidates.push(...samplePath(path, 11 + Math.floor(rand(seed, path.length + 333) * 5)).map((p) => ({ ...p, score: 0.62 + plain[indexOf(p.x, p.y)] * 0.24 + midDensityAffinity(p.x, p.y) * 0.16, kind: "Interchange" })));
+    for (const city of modernCities) {
+      let best = null;
+      let bestDistance = 999;
+      for (const [x, y] of path) {
+        const d = Math.hypot(x - city.x, y - city.y);
+        if (d < bestDistance) { bestDistance = d; best = { x, y }; }
+      }
+      if (best && bestDistance > 4 && bestDistance < 18) icCandidates.push({ ...best, score: 0.8 + city.score * 0.1, kind: "Urban Interchange" });
+    }
+  }
+
+  let interchanges = pickEntities(icCandidates, { max: 14 + Math.floor(rand(seed, 1130) * 18), minDistance: 7, threshold: 0.44, seed: seed + 1130 });
+
+  const icAccessRoads = [];
+  const nationalRoadAccessPoints = nationalRoads.flatMap((path) => samplePath(path, 8));
+  for (const ic of interchanges) {
+    const accessTargets = [
+      ...industrialZones.map((p) => ({ ...p, score: 0.95 / (1 + Math.hypot(p.x - ic.x, p.y - ic.y) / 7) })),
+      ...modernCities.map((p) => ({ ...routePoint(p, "road", 8200 + p.x * 7 + p.y), score: 0.72 / (1 + Math.hypot(p.x - ic.x, p.y - ic.y) / 10) })),
+      ...nationalRoadAccessPoints.map((p) => ({ ...p, score: 0.62 / (1 + Math.hypot(p.x - ic.x, p.y - ic.y) / 6), kind: "National Road Access" })),
+    ];
+    const target = pickEntities(accessTargets, { max: 1, minDistance: 1, threshold: 0, seed: seed + 1134 + ic.x * 3 + ic.y })[0];
+    if (!target || Math.hypot(target.x - ic.x, target.y - ic.y) > 22) continue;
+    const path = aStar(ic, target, roadCost);
+    if (path.length > 2 && path.length < 36) icAccessRoads.push(path);
+  }
+
+  const logisticsScore = new Float32Array(SIZE);
+  for (let y = 4; y < MAP_H - 4; y++) {
+    for (let x = 4; x < MAP_W - 4; x++) {
+      const i = indexOf(x, y);
+      if (sea[i]) continue;
+      const nearIC = 1 / (1 + distanceToNearest(interchanges, x, y) / 3);
+      const cityPenalty = distanceToNearest(modernCities, x, y) < 5 ? 0.28 : 0;
+      logisticsScore[i] = clamp(nearIC * 0.56 + plain[i] * 0.24 + roadInfluence[i] * 0.22 + expressInfluence[i] * 0.16 - slope[i] * 0.32 - cityPenalty);
+    }
+  }
+
+  let logisticsParks = pickPoints(logisticsScore, {
+    threshold: 0.32 + rand(seed, 1141) * 0.1,
+    max: 3 + Math.floor(rand(seed, 1142) * 13),
+    minDistance: 9,
+    seedOffset: 1140,
+    predicate: (x, y, i) => !sea[i],
+  }).map((p) => ({ ...p, kind: "Logistics Park" }));
+
+  const cityInfluence = influenceFromPoints(modernCities, 34, (p) => p.urbanWeight || 1.2);
+  const cityCoreInfluence = influenceFromPoints(urbanCenters, 11, (p) => p.parent?.coreRadius ? 1.35 + p.parent.coreRadius / 5 : 1.2);
+  const stationInfluence = influenceFromPoints(stations, 10, () => 1);
+  const railInfluence2 = influenceFromPaths([...railways, ...branchRailways, ...ringRailways, ...externalRailways], 6);
+  const satelliteScore = new Float32Array(SIZE);
+  const largeCitiesForSatellites = modernCities.filter((c) => (c.population || 0) >= 320000);
+  for (let y = 4; y < MAP_H - 4; y++) {
+    for (let x = 4; x < MAP_W - 4; x++) {
+      const i = indexOf(x, y);
+      if (sea[i] || !prefectureMask[i]) continue;
+      let ringPull = 0;
+      let parent = null;
+      for (const city of largeCitiesForSatellites) {
+        const d = Math.hypot(city.x - x, city.y - y);
+        const ideal = clamp(11 + Math.sqrt(city.population || 320000) / 150, 13, 27);
+        const v = clamp(1 - Math.abs(d - ideal) / 9);
+        if (v > ringPull) { ringPull = v; parent = city; }
+      }
+      if (!parent) continue;
+      const railPull = Math.max(railInfluence2[i], stationInfluence[i] * 0.84);
+      const separated = distanceToNearest(modernCities, x, y) > 7 ? 1 : 0;
+      satelliteScore[i] = clamp(ringPull * 0.42 + railPull * 0.38 + populationDensity[i] * 0.14 + plain[i] * 0.2 + basinField[i] * 0.08 + agriculture[i] * 0.05 - slope[i] * 0.86 - ridgeField[i] * 0.34 - Math.max(0, elevation[i] - 0.56) * 0.72 + separated * 0.1 + hash2(x, y, seed + 1160) * 0.035);
+    }
+  }
+  let satelliteCities = pickPoints(satelliteScore, {
+    threshold: 0.43 + rand(seed, 1161) * 0.07,
+    max: Math.min(14, 2 + largeCitiesForSatellites.length * 4 + Math.floor(rand(seed, 1162) * 4)),
+    minDistance: 8,
+    seedOffset: 1160,
+    predicate: (x, y, i) => !sea[i] && prefectureMask[i],
+  }).map((p, n) => {
+    const parent = largeCitiesForSatellites.slice().sort((a, b) => Math.hypot(a.x - p.x, a.y - p.y) - Math.hypot(b.x - p.x, b.y - p.y))[0];
+    const basePop = parent ? parent.population * (0.045 + rand(seed, 1165 + n) * 0.11) : 42000 + rand(seed, 1165 + n) * 90000;
+    return { ...p, kind: "Satellite City", parentCityIndex: parent ? modernCities.indexOf(parent) : -1, population: Math.round(basePop / 1000) * 1000, urbanRadius: 5 + Math.sqrt(basePop) / 135, coreRadius: 1.5 + Math.sqrt(basePop) / 420, urbanWeight: 0.55 + Math.sqrt(basePop) / 720 };
+  });
+  const satelliteInfluence = influenceFromPoints(satelliteCities, 16, (p) => p.urbanWeight || 0.8);
+  const oldCoreInfluence = influenceFromPoints([...castleTowns, ...markets, ...ports], 12, () => 1);
+  const industrialInfluence = influenceFromPoints(industrialZones, 9, () => 1);
+  const logisticsInfluence = influenceFromPoints(logisticsParks, 9, () => 1);
+  const interchangeInfluence = influenceFromPoints(interchanges, 8, () => 1);
+  const premodernInfluence = influenceFromPaths(premodernRoads, 4);
+  const villageInfluence = influenceFromPoints(villages, 7, () => 1);
+
+  const newTownScore = new Float32Array(SIZE);
+  for (let y = 4; y < MAP_H - 4; y++) {
+    for (let x = 4; x < MAP_W - 4; x++) {
+      const i = indexOf(x, y);
+      if (sea[i]) continue;
+      const dCity = distanceToNearest(modernCities, x, y);
+      const ring = dCity > 8 && dCity < 22 ? 1 : 0;
+      const uplandTerrace = elevation[i] > 0.36 && elevation[i] < 0.58 && slope[i] < 0.34 && ridgeField[i] < 0.34 ? 0.24 : 0;
+      newTownScore[i] = clamp(ring * 0.34 + stationInfluence[i] * 0.24 + roadInfluence[i] * 0.08 + railInfluence2[i] * 0.1 + plain[i] * 0.14 + uplandTerrace + agriculture[i] * 0.06 - slope[i] * 0.72 - ridgeField[i] * 0.22 - floodplain[i] * 0.22 - satelliteInfluence[i] * 0.18);
+    }
+  }
+
+  let newTowns = pickPoints(newTownScore, {
+    threshold: 0.32 + rand(seed, 1151) * 0.1,
+    max: 2 + Math.floor(rand(seed, 1152) * 10),
+    minDistance: 11,
+    seedOffset: 1150,
+    predicate: (x, y, i) => !sea[i],
+  }).map((p) => ({ ...p, kind: "New Town" }));
+
+  const minorRoads = [];
+  const trunkNodes = [...markets, ...modernCities, ...stations.slice(0, 24), ...crossings.slice(0, 16)];
+  const roadNetInfluence = influenceFromPaths([...nationalRoads, ...ringRoads, ...expressways, ...ringExpressways, ...externalRoads, ...externalExpressways, ...premodernRoads], 3);
+
+  function minorRoadCost(x, y) {
+    const i = indexOf(x, y);
+    if (sea[i]) return INF;
+    return Math.max(0.3, 1 + slope[i] * 7.2 + floodplain[i] * 0.18 + (river[i] > 0.5 ? 1.0 : 0.18 * river[i]) - plain[i] * 0.22 - valleyField[i] * 0.34 - coastalLowland[i] * 0.12 + ridgeField[i] * 0.4 - roadNetInfluence[i] * 0.35 + normalEdgePenalty(x, y) + hash2(x, y, seed + 555) * 0.15);
+  }
+
+  const connectedPairs = new Set();
+  function addMinorRoad(a, b) {
+    const key = `${a.x},${a.y}|${b.x},${b.y}`;
+    if (connectedPairs.has(key)) return;
+    connectedPairs.add(key);
+    const path = aStar(a, b, minorRoadCost);
+    if (path.length > 2 && path.length < 90) minorRoads.push(path);
+  }
+
+  for (const village of villages) {
+    if (rand(seed, village.x * 13 + village.y * 17) < 0.42) {
+      const target = pickEntities(trunkNodes.map((p) => ({ ...p, score: 1 / (1 + Math.hypot(p.x - village.x, p.y - village.y)) })), { max: 1, minDistance: 1, threshold: 0 })[0];
+      if (target && Math.hypot(target.x - village.x, target.y - village.y) < 28) addMinorRoad(village, target);
+    }
+  }
+  for (const market of markets) {
+    const localVillages = pickEntities(villages.map((v) => ({ ...v, score: 1 / (1 + Math.hypot(v.x - market.x, v.y - market.y)) })), { max: 3, minDistance: 1, threshold: 0 });
+    for (const v of localVillages) addMinorRoad(market, v);
+  }
+  for (const pass of passes.slice(0, 8)) {
+    const target = pickEntities([...markets, ...villages].map((p) => ({ ...p, score: 1 / (1 + Math.hypot(p.x - pass.x, p.y - pass.y)) })), { max: 1, minDistance: 1, threshold: 0 })[0];
+    if (target) addMinorRoad(pass, target);
+  }
+
+  const newTownInfluence = influenceFromPoints(newTowns, 8, () => 1);
+  const landuse = new Uint8Array(SIZE);
+  for (let y = 0; y < MAP_H; y++) {
+    for (let x = 0; x < MAP_W; x++) {
+      const i = indexOf(x, y);
+      if (sea[i]) continue;
+      const mountain = elevation[i] > 0.62 || slope[i] > 0.46 || ridgeField[i] > 0.64;
+      const farm = agriculture[i] > 0.26 && (plain[i] > 0.2 || valleyField[i] > 0.32 || basinField[i] > 0.25);
+      let nearestCity = null;
+      let nearestCityDistance = INF;
+      for (const city of modernCities) {
+        const d = Math.hypot(city.x - x, city.y - y);
+        if (d < nearestCityDistance) { nearestCityDistance = d; nearestCity = city; }
+      }
+      const dCity = nearestCityDistance;
+      const populationScale = nearestCity ? clamp(Math.log10(Math.max(10000, nearestCity.population)) - 4, 0.25, 2.2) : 0.5;
+      const normalizedUrbanDistance = nearestCity ? dCity / Math.max(6, nearestCity.urbanRadius) : 99;
+      const cityClusterBoost = nearestCity ? clamp(1 - normalizedUrbanDistance) * (0.18 + populationScale * 0.16) : 0;
+      const density = populationDensity[i];
+      const oldTownScore = oldCoreInfluence[i] * 0.64 + premodernInfluence[i] * 0.32 + plain[i] * 0.12 + density * 0.08;
+      const terrainUrbanPenalty = slope[i] * 1.02 + ridgeField[i] * 0.55 + Math.max(0, elevation[i] - 0.56) * 0.56;
+      const nodeCausalPull = Math.max(stationInfluence[i] * 0.18, premodernInfluence[i] * 0.13, coastalLowland[i] * river[i] * 0.12, valleyField[i] * 0.08);
+      const satelliteEnvelope = satelliteInfluence[i] * 0.54;
+      const urbanEnvelope = cityInfluence[i] * 0.58 + cityCoreInfluence[i] * 0.3 + satelliteEnvelope + density * 0.47 + stationInfluence[i] * 0.18 + oldCoreInfluence[i] * 0.14 + newTownInfluence[i] * 0.12 + cityClusterBoost + nodeCausalPull - terrainUrbanPenalty;
+      const coreScore = cityCoreInfluence[i] * 0.74 + urbanEnvelope * 0.3 + density * 0.36 + satelliteInfluence[i] * 0.16 + stationInfluence[i] * 0.06 + railInfluence2[i] * 0.04 - slope[i] * 0.82 - ridgeField[i] * 0.28;
+      const suburbScore = urbanEnvelope * 0.54 + density * 0.14 + satelliteInfluence[i] * 0.22 + stationInfluence[i] * 0.09 + roadInfluence[i] * 0.05 + railInfluence2[i] * 0.05 + plain[i] * 0.16 + valleyField[i] * 0.04 + populationScale * 0.05 + (coreScore < 0.58 ? 0.05 : 0) - slope[i] * 0.76 - ridgeField[i] * 0.22;
+      const roadsideScore = interchangeInfluence[i] * 0.54 + logisticsInfluence[i] * 0.18 + roadInfluence[i] * 0.1 + plain[i] * 0.1 - cityInfluence[i] * 0.02;
+      const isolatedCorridor = roadInfluence[i] > 0.22 && cityInfluence[i] < 0.08 && stationInfluence[i] < 0.08 && interchangeInfluence[i] < 0.18;
+      const ruralScore = villageInfluence[i] * 0.3 + agriculture[i] * 0.38 + plain[i] * 0.18 - slope[i] * 0.08;
+
+      if (mountain) landuse[i] = 9;
+      else if (industrialInfluence[i] > 0.44) landuse[i] = 5;
+      else if (logisticsInfluence[i] > 0.42) landuse[i] = 6;
+      else if (newTownInfluence[i] > 0.42 && urbanEnvelope > 0.16) landuse[i] = 7;
+      else if (coreScore > 0.68 && density > 0.48 && stationInfluence[i] > 0.05 && slope[i] < 0.24 && ridgeField[i] < 0.36) landuse[i] = 3;
+      else if (oldTownScore > 0.49) landuse[i] = 2;
+      else if (suburbScore > 0.235 && !isolatedCorridor && slope[i] < 0.32 && ridgeField[i] < 0.48 && (normalizedUrbanDistance < 1.42 || satelliteInfluence[i] > 0.24)) landuse[i] = 4;
+      else if (roadsideScore > 0.5 && plain[i] > 0.18 && slope[i] < 0.34 && ridgeField[i] < 0.5 && !isolatedCorridor && (interchangeInfluence[i] > 0.24 || logisticsInfluence[i] > 0.16 || cityInfluence[i] > 0.09)) landuse[i] = 8;
+      else if (farm) landuse[i] = 1;
+      else if (ruralScore > 0.3) landuse[i] = 0;
+      else landuse[i] = 0;
+    }
+  }
+
+  function hasUrbanNeighborCluster(x, y, radius = 2, minUrban = 7) {
+    let urban = 0;
+    for (let dy = -radius; dy <= radius; dy++) {
+      for (let dx = -radius; dx <= radius; dx++) {
+        const nx = x + dx;
+        const ny = y + dy;
+        if (!inside(nx, ny)) continue;
+        const lu = landuse[indexOf(nx, ny)];
+        if (lu === 2 || lu === 3 || lu === 4 || lu === 7 || lu === 8) urban++;
+      }
+    }
+    return urban >= minUrban;
+  }
+
+  function removeIsolatedUrbanPatches(maxCells = 22) {
+    const seen = new Uint8Array(SIZE);
+    const namedCenters = [...modernCities, ...(satelliteCities || []), ...markets, ...ports, ...newTowns, ...stations];
+    const queue = [];
+    for (let i = 0; i < SIZE; i++) {
+      if (seen[i] || !prefectureMask[i] || sea[i]) continue;
+      const lu0 = landuse[i];
+      if (!(lu0 >= 2 && lu0 <= 8)) continue;
+      const component = [];
+      let maxDensity = 0;
+      queue.length = 0;
+      queue.push(i);
+      seen[i] = 1;
+      for (let q = 0; q < queue.length; q++) {
+        const cur = queue[q];
+        component.push(cur);
+        maxDensity = Math.max(maxDensity, populationDensity[cur]);
+        const [x, y] = xyOf(cur);
+        for (const [nx, ny] of neighbors8(x, y)) {
+          const ni = indexOf(nx, ny);
+          if (seen[ni] || !prefectureMask[ni] || sea[ni]) continue;
+          if (!(landuse[ni] >= 2 && landuse[ni] <= 8)) continue;
+          seen[ni] = 1;
+          queue.push(ni);
+        }
+      }
+      if (component.length > maxCells) continue;
+      let hasAnchor = false;
+      for (const ci of component) {
+        const [x, y] = xyOf(ci);
+        if (distanceToNearest(namedCenters, x, y) <= 5.8) {
+          hasAnchor = true;
+          break;
+        }
+      }
+      if (!hasAnchor) {
+        for (const ci of component) landuse[ci] = agriculture[ci] > 0.34 ? 1 : 0;
+      }
+    }
+  }
+
+  for (let pass = 0; pass < 2; pass++) removeIsolatedUrbanPatches(36);
+
+  // CBD is no longer a marker. It is a DID-like contiguous high-density core:
+  // first remove isolated core cells, then grow connected high-density cells
+  // from each urban center according to population scale.
+  for (let y = 1; y < MAP_H - 1; y++) {
+    for (let x = 1; x < MAP_W - 1; x++) {
+      const i = indexOf(x, y);
+      if (landuse[i] === 3 && !hasUrbanNeighborCluster(x, y, 2, 8)) landuse[i] = 4;
+    }
+  }
+
+  function growDidCore(center, city, salt) {
+    if (!center || !city) return 0;
+    const start = indexOf(center.x, center.y);
+    if (sea[start] || !prefectureMask[start]) return 0;
+    if ((city.population || 0) < 220000) return 0;
+    const targetCells = Math.round(clamp(2 + Math.sqrt(city.population || 80000) / 74, 4, 22));
+    const maxRadius = clamp((city.coreRadius || 3) * 2.4 + Math.sqrt(city.population || 80000) / 260, 6, 16);
+    const selected = new Set();
+    const queued = new Set([start]);
+    const heap = new MinHeap();
+    heap.push({ i: start, f: -10 });
+    let made = 0;
+
+    while (heap.length > 0 && made < targetCells) {
+      const cur = heap.pop();
+      if (!cur || selected.has(cur.i)) continue;
+      const [x, y] = xyOf(cur.i);
+      const i = cur.i;
+      const d = Math.hypot(x - center.x, y - center.y);
+      const support = populationDensity[i] * 1.18 + cityInfluence[i] * 0.22 + stationInfluence[i] * 0.18 + plain[i] * 0.12 - slope[i] * 1.24 - ridgeField[i] * 0.54 - Math.max(0, elevation[i] - 0.58) * 0.50 - floodplain[i] * 0.08 - d / maxRadius * 0.22;
+      if (d > maxRadius || support < 0.44 || sea[i] || !prefectureMask[i]) continue;
+      if (!(landuse[i] === 2 || landuse[i] === 3 || landuse[i] === 4 || landuse[i] === 7 || populationDensity[i] > 0.22 || stationInfluence[i] > 0.14)) continue;
+
+      selected.add(i);
+      landuse[i] = 3;
+      made++;
+
+      for (const [nx, ny] of neighbors8(x, y)) {
+        const ni = indexOf(nx, ny);
+        if (queued.has(ni) || selected.has(ni) || sea[ni] || !prefectureMask[ni]) continue;
+        const nd = Math.hypot(nx - center.x, ny - center.y);
+        if (nd > maxRadius + 1) continue;
+        const score = populationDensity[ni] * 1.24 + cityInfluence[ni] * 0.22 + stationInfluence[ni] * 0.18 + plain[ni] * 0.12 - slope[ni] * 1.25 - ridgeField[ni] * 0.54 - nd / maxRadius * 0.22 + hash2(nx, ny, seed + salt) * 0.03;
+        queued.add(ni);
+        heap.push({ i: ni, f: -score });
+      }
+    }
+    return made;
+  }
+
+  urbanCenters.forEach((center, n) => growDidCore(center, center.parent || modernCities[n], 9400 + n * 17));
+  for (let pass = 0; pass < 3; pass++) removeIsolatedUrbanPatches(42);
+  for (let y = 1; y < MAP_H - 1; y++) {
+    for (let x = 1; x < MAP_W - 1; x++) {
+      const i = indexOf(x, y);
+      if (landuse[i] === 3 && !hasUrbanNeighborCluster(x, y, 2, 8)) landuse[i] = 4;
+    }
+  }
+
+  const prefectureArea = prefectureMask.reduce((sum, v) => sum + (v ? 1 : 0), 0);
+  const municipalityCandidates = [];
+  for (let y = 2; y < MAP_H - 2; y++) {
+    for (let x = 2; x < MAP_W - 2; x++) {
+      const i = indexOf(x, y);
+      if (!prefectureMask[i] || sea[i]) continue;
+      const urbanBias = landuse[i] === 3 ? 0.62 : landuse[i] === 2 ? 0.56 : landuse[i] === 4 ? 0.5 : landuse[i] === 1 ? 0.4 : 0.28;
+      const score = urbanBias + settlementScore[i] * 0.22 + roadInfluence[i] * 0.08 + railInfluence2[i] * 0.05 + villageInfluence[i] * 0.04 - slope[i] * 0.18 - ridgeField[i] * 0.06 + hash2(x, y, seed + 1300) * 0.025;
+      if (score > 0.40) municipalityCandidates.push({ x, y, score });
+    }
+  }
+  const majorMunicipalSeeds = modernCities
+    .filter((city) => (city.population || 0) >= 220000 && prefectureMask[indexOf(city.x, city.y)])
+    .map((city) => ({ x: city.x, y: city.y, score: 1.55 + (city.population || 0) / 700000, protectedCity: city }));
+  const filteredMunicipalityCandidates = municipalityCandidates.filter((p) => {
+    const nearMajor = majorMunicipalSeeds.some((city) => Math.hypot(city.x - p.x, city.y - p.y) < clamp(12 + Math.sqrt(city.protectedCity.population || 300000) / 130, 14, 28));
+    const nearSmallUrban = modernCities.some((city) => (city.population || 0) < 260000 && Math.hypot(city.x - p.x, city.y - p.y) < 8 && p.x !== city.x && p.y !== city.y);
+    return !nearMajor && !nearSmallUrban;
+  });
+  const satelliteMunicipalSeeds = (satelliteCities || [])
+    .filter((city) => prefectureMask[indexOf(city.x, city.y)])
+    .map((city) => ({ x: city.x, y: city.y, score: 1.05 + (city.population || 40000) / 260000, protectedSatellite: city }));
+  let adminCentersRaw = [
+    ...majorMunicipalSeeds,
+    ...satelliteMunicipalSeeds,
+    ...pickEntities(filteredMunicipalityCandidates.filter((p) => satelliteMunicipalSeeds.every((s) => Math.hypot(s.x - p.x, s.y - p.y) >= 6)), {
+      max: Math.min(20, Math.max(10, Math.floor(prefectureArea / 950) + 6 + Math.floor(rand(seed, 1301) * 3))),
+      minDistance: 9 + Math.floor(rand(seed, 1302) * 3),
+      threshold: 0.40,
+      seed: seed + 1300,
+      jitter: 0.025,
+    }),
+  ];
+  if (adminCentersRaw.length < 12) {
+    const fallback = [...modernCities, ...satelliteCities, ...markets, ...newTowns, ...stations, ...villages]
+      .filter((p) => prefectureMask[indexOf(p.x, p.y)])
+      .map((p) => ({ x: p.x, y: p.y, score: p.score || 0.5 }));
+    adminCentersRaw = pickEntities(fallback, { max: 12, minDistance: 8, threshold: 0, seed: seed + 1303 });
+  }
+  if (adminCentersRaw.length < 10) {
+    const extra = pickEntities(municipalityCandidates, { max: 10 - adminCentersRaw.length, minDistance: 8, threshold: 0.32, seed: seed + 1304 });
+    adminCentersRaw.push(...extra.filter((p) => adminCentersRaw.every((q) => Math.hypot(p.x - q.x, p.y - q.y) >= 6)));
+  }
+  const adminId = generateAdminRegions(adminCentersRaw, prefectureMask, sea, elevation, slope, river, ridgeField, valleyField, populationDensity, landuse);
+
+  function lockUrbanClusterToMunicipality(city, radius, allowSuburban = true) {
+    if (!city || !prefectureMask[indexOf(city.x, city.y)]) return;
+    let bestAdmin = -1;
+    let bestD = INF;
+    adminCentersRaw.forEach((center, id) => {
+      const d = Math.hypot(center.x - city.x, center.y - city.y);
+      if (d < bestD) { bestD = d; bestAdmin = id; }
+    });
+    if (bestAdmin < 0) return;
+    const r = Math.ceil(radius);
+    for (let dy = -r; dy <= r; dy++) {
+      for (let dx = -r; dx <= r; dx++) {
+        const x = city.x + dx;
+        const y = city.y + dy;
+        if (!inside(x, y)) continue;
+        const i = indexOf(x, y);
+        if (!prefectureMask[i] || sea[i]) continue;
+        const d = Math.hypot(dx, dy);
+        if (d > radius) continue;
+        const urban = landuse[i] === 2 || landuse[i] === 3 || (allowSuburban && (landuse[i] === 4 || landuse[i] === 7 || landuse[i] === 8));
+        if (urban || populationDensity[i] > 0.22) adminId[i] = bestAdmin;
+      }
+    }
+  }
+  for (const city of modernCities) {
+    const radius = (city.population || 0) >= 500000
+      ? clamp(17 + Math.sqrt(city.population) / 120, 20, 38)
+      : clamp(5 + Math.sqrt(city.population || 70000) / 210, 6, 11);
+    lockUrbanClusterToMunicipality(city, radius, true);
+  }
+  // Satellite cities should remain independent municipalities, not swallowed by the parent core city.
+  for (const sat of satelliteCities || []) {
+    if (!prefectureMask[indexOf(sat.x, sat.y)]) continue;
+    let bestAdmin = -1;
+    let bestD = INF;
+    adminCentersRaw.forEach((center, id) => {
+      const d = Math.hypot(center.x - sat.x, center.y - sat.y);
+      if (d < bestD) { bestD = d; bestAdmin = id; }
+    });
+    if (bestAdmin >= 0) {
+      const r = 5;
+      for (let dy = -r; dy <= r; dy++) {
+        for (let dx = -r; dx <= r; dx++) {
+          const x = sat.x + dx;
+          const y = sat.y + dy;
+          if (!inside(x, y)) continue;
+          const i = indexOf(x, y);
+          if (!prefectureMask[i] || sea[i] || Math.hypot(dx, dy) > r) continue;
+          if ((landuse[i] >= 2 && landuse[i] <= 4) || landuse[i] === 7 || populationDensity[i] > 0.18) adminId[i] = bestAdmin;
+        }
+      }
+    }
+  }
+  lockSmallUrbanComponentsToMunicipality(adminId, prefectureMask, sea, landuse, populationDensity, 520);
+  lockSmallUrbanComponentsToMunicipality(adminId, prefectureMask, sea, landuse, populationDensity, 620);
+  const adminBorders = extractAdminBorderSegments(adminId, prefectureMask);
+  function makeHarborWorks(ports) {
+    const out = [];
+    for (const port of ports) {
+      const parts = [];
+      const limit = port.portClass === "major" ? 5 : port.portClass === "regional" ? 3 : 1;
+      for (const [dx, dy] of [[1,0],[-1,0],[0,1],[0,-1],[1,1],[-1,1],[1,-1],[-1,-1]]) {
+        const sx = port.x + dx;
+        const sy = port.y + dy;
+        if (!inside(sx, sy) || !sea[indexOf(sx, sy)]) continue;
+        parts.push([[port.x, port.y], [sx, sy]]);
+        const wx = sx + dx;
+        const wy = sy + dy;
+        if (port.portClass === "major" && inside(wx, wy) && sea[indexOf(wx, wy)] && rand(seed, sx * 101 + sy * 103) > 0.22) parts.push([[sx, sy], [wx, wy]]);
+        if (parts.length >= limit) break;
+      }
+      if (parts.length) out.push({ port, segments: parts, kind: port.portClass === "major" ? "Major Harbor Works" : "Harbor Works" });
+    }
+    return out;
+  }
+
+  // Bridge and tunnel icon systems were removed from the visual model.
+  // Arrays remain empty for backward-compatible tests and downstream code.
+  const bridges = [];
+  const tunnels = [];
+  const harborWorks = makeHarborWorks(ports);
+  const abandonedRailways = branchRailways.filter((_, i) => i % 3 === 0);
+  let castleRuins = castles.filter((_, i) => i % 2 === 1).map((c) => ({ ...c, kind: "Castle Ruins" }));
+  const preservedOldRoads = premodernRoads.filter((_, i) => i % 2 === 0);
+
+  villages = attachIdsAndNames(tagInsidePrefecture(villages, prefectureMask), "village", seed);
+  ports = attachIdsAndNames(tagInsidePrefecture(ports, prefectureMask), "port", seed);
+  crossings = attachIdsAndNames(tagInsidePrefecture(crossings, prefectureMask), "crossing", seed);
+  passes = attachIdsAndNames(tagInsidePrefecture(passes, prefectureMask), "pass", seed);
+  markets = attachIdsAndNames(tagInsidePrefecture(markets, prefectureMask), "market", seed);
+  castles = attachIdsAndNames(tagInsidePrefecture(castles, prefectureMask), "castle", seed);
+  castleTowns = attachIdsAndNames(tagInsidePrefecture(castleTowns, prefectureMask), "castleTown", seed);
+  modernCities = attachIdsAndNames(tagInsidePrefecture(modernCities, prefectureMask), "city", seed);
+  stations = attachIdsAndNames(tagInsidePrefecture(stations, prefectureMask), "station", seed);
+  industrialZones = attachIdsAndNames(tagInsidePrefecture(industrialZones, prefectureMask), "industrial", seed);
+  interchanges = attachIdsAndNames(tagInsidePrefecture(interchanges, prefectureMask), "interchange", seed);
+  logisticsParks = attachIdsAndNames(tagInsidePrefecture(logisticsParks, prefectureMask), "logistics", seed);
+  satelliteCities = attachIdsAndNames(tagInsidePrefecture(satelliteCities, prefectureMask), "satellite", seed);
+  newTowns = attachIdsAndNames(tagInsidePrefecture(newTowns, prefectureMask), "newtown", seed);
+  castleRuins = attachIdsAndNames(tagInsidePrefecture(castleRuins, prefectureMask), "castleRuin", seed);
+  externalGateways = attachIdsAndNames(tagInsidePrefecture(externalGateways, prefectureMask), "gateway", seed, "External Gateway");
+  const adminCenters = attachIdsAndNames(tagInsidePrefecture(adminCentersRaw, prefectureMask), "admin", seed, "Municipal Center");
+
+  const entitiesForNames = [
+    ...modernCities,
+    ...ports,
+    ...markets,
+    ...castles,
+    ...stations,
+    ...industrialZones,
+    ...interchanges,
+    ...logisticsParks,
+    ...satelliteCities,
+    ...newTowns,
+    ...passes,
+    ...crossings,
+    ...externalGateways,
+  ].filter((p) => p.insidePrefecture || p.kind === "External Gateway");
+
+  return {
+    width: MAP_W,
+    height: MAP_H,
+    cellSize: CELL_SIZE,
+    prefectureMask,
+    prefectureBorder,
+    prefectureRegionId,
+    regionalPrefectureBorders,
+    elevation,
+    moisture,
+    slope,
+    sea,
+    river,
+    floodplain,
+    plain,
+    agriculture,
+    ridgeField,
+    valleyField,
+    basinField,
+    coastalLowland,
+    flowAccum,
+    erosionField,
+    depositionField,
+    villages,
+    ports,
+    crossings,
+    passes,
+    markets,
+    castles,
+    castleTowns,
+    premodernRoads,
+    minorRoads,
+    modernCities,
+    prefecturalCapital: modernCities.find((city) => city.isPrefecturalCapital) || modernCities[0] || null,
+    totalPopulation: [...modernCities, ...satelliteCities].reduce((sum, city) => sum + (city.population || 0), 0),
+    populationDensity,
+    railways,
+    branchRailways,
+    ringRailways,
+    externalRailways,
+    stations,
+    industrialZones,
+    nationalRoads,
+    ringRoads,
+    expressways,
+    ringExpressways,
+    icAccessRoads,
+    externalRoads,
+    externalExpressways,
+    interchanges,
+    logisticsParks,
+    satelliteCities,
+    newTowns,
+    bridges,
+    tunnels,
+    harborWorks,
+    landuse,
+    adminCenters,
+    adminId,
+    adminBorders,
+    abandonedRailways,
+    castleRuins,
+    preservedOldRoads,
+    riverPaths,
+    mainRivers,
+    tributaryRivers,
+    smallStreams,
+    externalGateways,
+    entitiesForNames,
+  };
+}
diff --git a/names.js b/names.js
new file mode 100644
index 0000000..2e82d5e
--- /dev/null
+++ b/names.js
@@ -0,0 +1,34 @@
+// Default and custom place-name resources.
+// Edit only this file to change generated names or override individual IDs.
+
+export const NAME_PARTS = {
+  prefixes: ["青", "白", "黒", "赤", "東", "西", "南", "北", "中", "大", "小", "浅", "高", "川", "山", "森", "松", "原", "桜", "海", "新", "古", "上", "下"],
+  infixes: ["野", "原", "川", "浜", "崎", "丘", "谷", "峰", "浦", "沢", "島", "岡", "井", "瀬", "関", "橋", "口", "田", "津", "森", "台", "見"],
+  suffixes: ["町", "市", "郷", "台", "丘", "浦", "港", "里", "野", "沢", "原", "橋", "森", "浜", "崎", "峠"],
+};
+
+export const KIND_SUFFIXES = {
+  city: " City",
+  port: " Port",
+  market: " Town",
+  village: " Village",
+  castle: " Castle",
+  castleTown: " Castle Town",
+  castleRuin: " Castle Ruins",
+  station: " Station",
+  interchange: "IC",
+  industrial: " Industrial Park",
+  logistics: " Logistics Park",
+  newtown: " New Town",
+  satellite: " Satellite City",
+  pass: " Pass",
+  crossing: " Crossing",
+  gateway: " Gate",
+  admin: " District",
+};
+
+export const CUSTOM_NAMES = {
+  // "city-0": "Aohara",
+  // "port-0": "Shirahama",
+  // "castle-0": "Kurono",
+};
diff --git a/renderer.js b/renderer.js
new file mode 100644
index 0000000..74f3e32
--- /dev/null
+++ b/renderer.js
@@ -0,0 +1,493 @@
+import { MAP_W, MAP_H, CELL_SIZE, indexOf } from "./mapGenerator.js";
+
+function clamp(v, a = 0, b = 1) {
+  return Math.max(a, Math.min(b, v));
+}
+
+function distToNearest(points, x, y, fallback = 999) {
+  let best = fallback;
+  for (const p of points) best = Math.min(best, Math.hypot(p.x - x, p.y - y));
+  return best;
+}
+
+function blendOutside(color, isInside) {
+  if (isInside) return color;
+  return [
+    Math.round(color[0] * 0.55 + 112),
+    Math.round(color[1] * 0.55 + 112),
+    Math.round(color[2] * 0.55 + 112),
+  ];
+}
+
+function fieldSample(field, fx, fy) {
+  const x0 = Math.max(0, Math.min(MAP_W - 1, Math.floor(fx)));
+  const y0 = Math.max(0, Math.min(MAP_H - 1, Math.floor(fy)));
+  const x1 = Math.max(0, Math.min(MAP_W - 1, x0 + 1));
+  const y1 = Math.max(0, Math.min(MAP_H - 1, y0 + 1));
+  const tx = fx - x0;
+  const ty = fy - y0;
+
+  const a = field[indexOf(x0, y0)];
+  const b = field[indexOf(x1, y0)];
+  const c = field[indexOf(x0, y1)];
+  const d = field[indexOf(x1, y1)];
+
+  return ((a * (1 - tx) + b * tx) * (1 - ty)) + ((c * (1 - tx) + d * tx) * ty);
+}
+
+function terrainColorContinuous(map, fx, fy, mode) {
+  const i = indexOf(Math.max(0, Math.min(MAP_W - 1, Math.floor(fx))), Math.max(0, Math.min(MAP_H - 1, Math.floor(fy))));
+  const isInside = Boolean(map.prefectureMask[i]);
+
+  let color;
+
+  if (map.sea[i]) {
+    // Google Map風の海の色（明るい青）
+    const depth = clamp((0.35 - fieldSample(map.elevation, fx, fy)) * 2.4);
+    color = [Math.round(170 + depth * 10), Math.round(211 + depth * 15), Math.round(223 + depth * 20)];
+  } else if (mode === "suitability") {
+    const a = fieldSample(map.agriculture, fx, fy);
+    const p = fieldSample(map.plain, fx, fy);
+    const f = fieldSample(map.floodplain, fx, fy);
+    color = [
+      Math.round(230 - p * 25 + f * 15),
+      Math.round(235 + a * 15),
+      Math.round(210 - a * 25 + p * 20),
+    ];
+  } else if (mode === "development") {
+    const x = Math.floor(fx);
+    const y = Math.floor(fy);
+    const baseIndex = indexOf(Math.max(0, Math.min(MAP_W - 1, x)), Math.max(0, Math.min(MAP_H - 1, y)));
+    const dCity = distToNearest(map.modernCities, fx, fy);
+    const dInd = distToNearest(map.industrialZones, fx, fy);
+    const dLog = distToNearest(map.logisticsParks, fx, fy);
+    const dNew = distToNearest(map.newTowns, fx, fy);
+    const urban = clamp(1 - dCity / 25);
+    const density = map.populationDensity ? fieldSample(map.populationDensity, fx, fy) : urban;
+    const industrial = clamp(1 - dInd / 10);
+    const logistics = clamp(1 - dLog / 9);
+    const newTown = clamp(1 - dNew / 9);
+    const base = 214 + map.plain[baseIndex] * 22;
+    color = [
+      Math.round(base + density * 30 + urban * 8 + industrial * 14),
+      Math.round(base + density * 10 + logistics * 15 + newTown * 12),
+      Math.round(208 + map.agriculture[baseIndex] * 22 + density * 18 + newTown * 22),
+    ];
+  } else {
+    // 起伏の大きさが読めるよう、標高段彩をやや強める
+    const e = fieldSample(map.elevation, fx, fy);
+    const m = fieldSample(map.moisture, fx, fy);
+    if (e > 0.82) color = [178, 170, 160];
+    else if (e > 0.68) color = [198, 188, 164];
+    else if (e > 0.52) color = [205, 222 + m * 5, 184];
+    else if (e > 0.34) color = [224, 238 + m * 6, 206];
+    else if (e > 0.24) color = [236, 245 + m * 5, 220];
+    else color = [218, 232 + m * 6, 206];
+  }
+
+  return blendOutside(color, isInside);
+}
+
+function discreteColor(map, x, y, mode) {
+  const i = indexOf(x, y);
+  let color;
+
+  if (map.sea[i]) {
+    // Google Map風の海色
+    color = [170, 218, 255];
+  } else if (mode === "landuse") {
+    const colors = {
+      0: [230, 242, 220], // 農地
+      1: [235, 245, 225], // 平地
+      2: [235, 230, 220], // 旧市街
+      3: [224, 202, 190], // 中心市街地 / CBD
+      4: [245, 240, 230], // 郊外
+      5: [220, 220, 225], // 工業地域
+      6: [225, 235, 225], // 物流エリア
+      7: [238, 242, 248], // ニュータウン
+      8: [248, 242, 230], // 沿道開発
+      9: [225, 238, 220], // その他
+    };
+    color = colors[map.landuse[i]] || colors[0];
+  } else if (mode === "admin") {
+    const palette = [
+      [245, 235, 230],
+      [235, 245, 235],
+      [240, 240, 250],
+      [250, 245, 230],
+      [245, 240, 248],
+      [230, 245, 245],
+      [250, 240, 240],
+      [240, 250, 235],
+    ];
+    const a = map.adminId[i];
+    color = a >= 0 ? palette[a % palette.length] : [220, 225, 220];
+  } else {
+    color = terrainColorContinuous(map, x, y, "terrain");
+  }
+
+  return blendOutside(color, Boolean(map.prefectureMask[i]));
+}
+
+function drawBase(ctx, map, mode, continuousTerrain) {
+  const width = MAP_W * CELL_SIZE;
+  const height = MAP_H * CELL_SIZE;
+  const img = ctx.createImageData(width, height);
+  const continuousModes = ["terrain", "suitability", "development", "all"];
+
+  if (continuousTerrain && continuousModes.includes(mode)) {
+    for (let py = 0; py < height; py++) {
+      const fy = py / CELL_SIZE;
+      for (let px = 0; px < width; px++) {
+        const fx = px / CELL_SIZE;
+        const [r, g, b] = terrainColorContinuous(map, fx, fy, mode === "all" ? "terrain" : mode);
+
+        const eL = fieldSample(map.elevation, fx - 0.6, fy);
+        const eR = fieldSample(map.elevation, fx + 0.6, fy);
+        const eU = fieldSample(map.elevation, fx, fy - 0.6);
+        const eD = fieldSample(map.elevation, fx, fy + 0.6);
+        const shade = clamp(0.9 + (eL - eR) * 1.0 + (eU - eD) * 0.65, 0.72, 1.18);
+        const elevation = fieldSample(map.elevation, fx, fy);
+        const contour = Math.abs((elevation * 16) - Math.round(elevation * 16));
+        const majorContour = Math.abs((elevation * 8) - Math.round(elevation * 8));
+        const isLand = !map.sea[indexOf(Math.max(0, Math.min(MAP_W - 1, Math.floor(fx))), Math.max(0, Math.min(MAP_H - 1, Math.floor(fy))))];
+        const contourFactor = isLand && majorContour < 0.022 ? 0.86 : isLand && contour < 0.028 ? 0.94 : 1;
+
+        const ii = (py * width + px) * 4;
+        img.data[ii] = Math.round(r * shade * contourFactor);
+        img.data[ii + 1] = Math.round(g * shade * contourFactor);
+        img.data[ii + 2] = Math.round(b * shade * contourFactor);
+        img.data[ii + 3] = 255;
+      }
+    }
+  } else {
+    for (let y = 0; y < MAP_H; y++) {
+      for (let x = 0; x < MAP_W; x++) {
+        const [r, g, b] = discreteColor(map, x, y, mode);
+        for (let dy = 0; dy < CELL_SIZE; dy++) {
+          for (let dx = 0; dx < CELL_SIZE; dx++) {
+            const ii = ((y * CELL_SIZE + dy) * width + (x * CELL_SIZE + dx)) * 4;
+            img.data[ii] = r;
+            img.data[ii + 1] = g;
+            img.data[ii + 2] = b;
+            img.data[ii + 3] = 255;
+          }
+        }
+      }
+    }
+  }
+
+  ctx.putImageData(img, 0, 0);
+}
+
+function drawPath(ctx, path, color, width, dashed = false) {
+  if (!path || path.length < 2) return;
+  ctx.save();
+  ctx.lineCap = "round";
+  ctx.lineJoin = "round";
+  ctx.strokeStyle = color;
+  ctx.lineWidth = width;
+  if (dashed) ctx.setLineDash([6, 5]);
+  ctx.beginPath();
+  ctx.moveTo(path[0][0] * CELL_SIZE + CELL_SIZE / 2, path[0][1] * CELL_SIZE + CELL_SIZE / 2);
+  for (let k = 1; k < path.length; k++) {
+    ctx.lineTo(path[k][0] * CELL_SIZE + CELL_SIZE / 2, path[k][1] * CELL_SIZE + CELL_SIZE / 2);
+  }
+  ctx.stroke();
+  ctx.restore();
+}
+
+function drawSegments(ctx, segments, color, width, dashed = false) {
+  ctx.save();
+  ctx.strokeStyle = color;
+  ctx.lineWidth = width;
+  if (dashed) ctx.setLineDash([4, 4]);
+
+  for (const seg of segments) {
+    ctx.beginPath();
+    ctx.moveTo(seg[0][0] * CELL_SIZE, seg[0][1] * CELL_SIZE);
+    ctx.lineTo(seg[1][0] * CELL_SIZE, seg[1][1] * CELL_SIZE);
+    ctx.stroke();
+  }
+  ctx.restore();
+}
+
+function drawUrbanAreas(ctx, map, mode) {
+  const visibleModes = ["all", "modern", "development", "landuse", "roads", "admin"];
+  if (!visibleModes.includes(mode)) return;
+
+  // Google Map風の都市部の色
+  const colors = {
+    2: "rgba(235, 230, 220, 0.75)", // 旧市街 - 薄いベージュ
+    3: "rgba(224, 202, 190, 0.9)", // 中心市街地 / CBD - cell fill
+    4: "rgba(245, 242, 235, 0.7)", // 郊外 - 薄いクリーム
+    5: "rgba(220, 220, 228, 0.8)", // 工業地域 - 薄いグレー
+    6: "rgba(225, 235, 228, 0.75)", // 物流 - 薄い緑グレー
+    7: "rgba(238, 242, 250, 0.75)", // ニュータウン - 薄い青白
+    8: "rgba(248, 245, 238, 0.7)", // 沿道 - クリーム
+  };
+
+  ctx.save();
+  for (let y = 0; y < MAP_H; y++) {
+    for (let x = 0; x < MAP_W; x++) {
+      const i = indexOf(x, y);
+      if (!map.prefectureMask[i]) continue;
+      const lu = map.landuse[i];
+      if (!colors[lu]) continue;
+
+      const px = x * CELL_SIZE;
+      const py = y * CELL_SIZE;
+      ctx.fillStyle = colors[lu];
+      ctx.fillRect(px, py, CELL_SIZE, CELL_SIZE);
+
+      const h = ((x * 92821 + y * 68917 + lu * 131) >>> 0);
+      if (lu === 3 || lu === 2 || lu === 5 || lu === 6) {
+        // 建物の表現を控えめに
+        ctx.fillStyle = lu === 3 ? "rgba(200,200,200,0.25)" : "rgba(210,210,210,0.2)";
+        if (h % 3 !== 0) ctx.fillRect(px + 1, py + 1, 2, 2);
+        if (h % 5 !== 0) ctx.fillRect(px + 3, py + 2, 2, 2);
+        if (h % 7 !== 0) ctx.fillRect(px + 2, py + 4, 2, 1.5);
+      } else if (lu === 4 || lu === 7) {
+        ctx.strokeStyle = lu === 7 ? "rgba(220,220,230,0.15)" : "rgba(200,190,180,0.15)";
+        ctx.lineWidth = 0.8;
+        ctx.beginPath();
+        if (h % 2 === 0) {
+          ctx.moveTo(px + 1, py + 1);
+          ctx.lineTo(px + CELL_SIZE - 1, py + 1);
+          ctx.moveTo(px + 1, py + 4);
+          ctx.lineTo(px + CELL_SIZE - 1, py + 4);
+        } else {
+          ctx.moveTo(px + 1, py + 1);
+          ctx.lineTo(px + 1, py + CELL_SIZE - 1);
+          ctx.moveTo(px + 4, py + 1);
+          ctx.lineTo(px + 4, py + CELL_SIZE - 1);
+        }
+        ctx.stroke();
+      } else if (lu === 8) {
+        ctx.strokeStyle = "rgba(180,170,160,0.2)";
+        ctx.lineWidth = 0.9;
+        ctx.beginPath();
+        ctx.moveTo(px + 1, py + 3);
+        ctx.lineTo(px + CELL_SIZE - 1, py + 3);
+        ctx.stroke();
+      }
+    }
+  }
+  ctx.restore();
+}
+
+function dot(ctx, p, radius, fill, stroke = "white") {
+  ctx.beginPath();
+  ctx.arc(p.x * CELL_SIZE + CELL_SIZE / 2, p.y * CELL_SIZE + CELL_SIZE / 2, radius, 0, Math.PI * 2);
+  ctx.fillStyle = fill;
+  ctx.fill();
+  ctx.lineWidth = 1.5;
+  ctx.strokeStyle = stroke;
+  ctx.stroke();
+}
+
+function squareIcon(ctx, p, size, fill, stroke = "white") {
+  const x = p.x * CELL_SIZE + CELL_SIZE / 2;
+  const y = p.y * CELL_SIZE + CELL_SIZE / 2;
+  ctx.save();
+  ctx.fillStyle = fill;
+  ctx.strokeStyle = stroke;
+  ctx.lineWidth = 1.5;
+  ctx.beginPath();
+  ctx.rect(x - size / 2, y - size / 2, size, size);
+  ctx.fill();
+  ctx.stroke();
+  ctx.restore();
+}
+
+function triangleIcon(ctx, p, size, fill, stroke = "white") {
+  const x = p.x * CELL_SIZE + CELL_SIZE / 2;
+  const y = p.y * CELL_SIZE + CELL_SIZE / 2;
+  ctx.save();
+  ctx.fillStyle = fill;
+  ctx.strokeStyle = stroke;
+  ctx.lineWidth = 1.5;
+  ctx.beginPath();
+  ctx.moveTo(x, y - size / 2);
+  ctx.lineTo(x + size / 2, y + size / 2);
+  ctx.lineTo(x - size / 2, y + size / 2);
+  ctx.closePath();
+  ctx.fill();
+  ctx.stroke();
+  ctx.restore();
+}
+
+function railStationIcon(ctx, p) {
+  squareIcon(ctx, p, 5.2, "rgba(255,255,255,0.96)", "rgba(55,55,55,0.92)");
+}
+
+
+function drawHarborWorks(ctx, map) {
+  if (!map.harborWorks) return;
+  ctx.save();
+  ctx.strokeStyle = "rgba(95, 120, 150, 0.9)";
+  ctx.lineWidth = 2.2;
+  ctx.lineCap = "round";
+  for (const harbor of map.harborWorks) {
+    for (const seg of harbor.segments || []) {
+      ctx.beginPath();
+      ctx.moveTo(seg[0][0] * CELL_SIZE + CELL_SIZE / 2, seg[0][1] * CELL_SIZE + CELL_SIZE / 2);
+      ctx.lineTo(seg[1][0] * CELL_SIZE + CELL_SIZE / 2, seg[1][1] * CELL_SIZE + CELL_SIZE / 2);
+      ctx.stroke();
+    }
+  }
+  ctx.restore();
+}
+
+function boxesOverlap(a, b, pad = 2) {
+  return !(a.x2 + pad < b.x1 || a.x1 - pad > b.x2 || a.y2 + pad < b.y1 || a.y1 - pad > b.y2);
+}
+
+function labelWithCollision(ctx, p, occupied) {
+  if (!p.name) return false;
+  ctx.save();
+  ctx.font = "11px ui-sans-serif, system-ui, sans-serif";
+  const baseX = p.x * CELL_SIZE + CELL_SIZE / 2;
+  const baseY = p.y * CELL_SIZE + CELL_SIZE / 2;
+  const textW = ctx.measureText(p.name).width;
+  const textH = 12;
+  const candidates = [
+    [7, -5], [7, 12], [-textW - 7, -5], [-textW - 7, 12],
+    [-textW / 2, -13], [-textW / 2, 20], [12, 2], [-textW - 12, 2],
+  ];
+
+  for (const [ox, oy] of candidates) {
+    const x = baseX + ox;
+    const y = baseY + oy;
+    const box = { x1: x - 2, y1: y - textH, x2: x + textW + 2, y2: y + 3 };
+    if (box.x1 < 0 || box.y1 < 0 || box.x2 > MAP_W * CELL_SIZE || box.y2 > MAP_H * CELL_SIZE) continue;
+    if (occupied.some((b) => boxesOverlap(box, b))) continue;
+    ctx.lineWidth = 3;
+    ctx.strokeStyle = "rgba(255,255,255,0.95)";
+    ctx.fillStyle = "rgba(40,40,40,0.95)";
+    ctx.strokeText(p.name, x, y);
+    ctx.fillText(p.name, x, y);
+    occupied.push(box);
+    ctx.restore();
+    return true;
+  }
+  ctx.restore();
+  return false;
+}
+
+function drawLabels(ctx, points) {
+  const occupied = [];
+  const prioritized = points
+    .filter((p) => p?.name)
+    .map((p) => ({ ...p, labelPriority: (p.isPrefecturalCapital ? 1000 : 0) + (p.population || 0) / 1000 + (p.kind === "Major Port" ? 160 : 0) + (p.kind === "Market Town" ? 55 : 0) + (p.kind?.includes("Castle") ? 45 : 0) }))
+    .sort((a, b) => b.labelPriority - a.labelPriority);
+  for (const p of prioritized) labelWithCollision(ctx, p, occupied);
+}
+
+export function drawMap(canvas, map, options) {
+  const ctx = canvas.getContext("2d");
+  if (!ctx) return;
+
+  const mode = options.mode || "all";
+  const showFeatures = options.showFeatures !== false;
+  const showLabels = options.showLabels !== false;
+  const continuousTerrain = true;
+
+  const width = MAP_W * CELL_SIZE;
+  const height = MAP_H * CELL_SIZE;
+  canvas.width = width;
+  canvas.height = height;
+
+  drawBase(ctx, map, mode, continuousTerrain);
+  drawUrbanAreas(ctx, map, mode);
+
+  // Rivers use the same hue family as the sea; hierarchy is expressed by width/opacity.
+  const waterBlue = "rgba(170, 218, 255, 0.95)";
+  // Small streams remain in the data model but are not drawn by default.
+  for (const path of map.tributaryRivers || map.riverPaths || []) drawPath(ctx, path, "rgba(170, 218, 255, 0.78)", 1.35);
+  for (const path of map.mainRivers) drawPath(ctx, path, waterBlue, 3.2);
+  drawHarborWorks(ctx, map);
+
+  if (map.regionalPrefectureBorders) drawSegments(ctx, map.regionalPrefectureBorders, "rgba(95,95,95,0.30)", 1.0);
+  drawSegments(ctx, map.prefectureBorder, "rgba(30,30,30,0.82)", 2.4);
+  drawSegments(ctx, map.prefectureBorder, "rgba(255,255,255,0.74)", 1.05);
+
+  if (!showFeatures) return;
+
+  const showHistory = ["history", "all", "terrain", "suitability"].includes(mode);
+  const showModern = ["modern", "all", "development", "landuse"].includes(mode);
+  const showRoads = ["roads", "all", "development", "landuse"].includes(mode);
+  const showAdmin = ["admin", "all"].includes(mode);
+
+  if (showAdmin) drawSegments(ctx, map.adminBorders, "rgba(120,120,120,0.65)", 1.3);
+
+  if (showHistory) {
+    for (const path of map.premodernRoads) drawPath(ctx, path, "rgba(150, 120, 90, 0.55)", 1.45, true);
+    for (const path of map.minorRoads) drawPath(ctx, path, "rgba(180, 150, 120, 0.62)", 1.05);
+  }
+
+  if (showModern) {
+    // 鉄道 - 濃いグレー
+    for (const path of map.railways) drawPath(ctx, path, "rgba(80, 80, 80, 0.9)", 2.8);
+    for (const path of map.ringRailways || []) drawPath(ctx, path, "rgba(70, 70, 70, 0.82)", 2.1);
+    for (const path of map.branchRailways) drawPath(ctx, path, "rgba(100, 100, 100, 0.82)", 1.9);
+    for (const path of map.externalRailways) drawPath(ctx, path, "rgba(90, 90, 90, 0.9)", 2.4);
+  }
+
+  if (showRoads) {
+    // Google Map風の道路 - 白と黄色とオレンジ
+    for (const path of map.nationalRoads) drawPath(ctx, path, "rgba(252, 210, 90, 0.85)", 2.2);
+    for (const path of map.icAccessRoads || []) drawPath(ctx, path, "rgba(255, 230, 150, 0.82)", 1.45);
+    for (const path of map.ringRoads || []) drawPath(ctx, path, "rgba(252, 210, 90, 0.85)", 2.0);
+    for (const path of map.expressways) drawPath(ctx, path, "rgba(245, 140, 60, 0.95)", 4.0);
+    for (const path of map.ringExpressways || []) drawPath(ctx, path, "rgba(245, 140, 60, 0.95)", 3.3);
+    for (const path of map.externalRoads) drawPath(ctx, path, "rgba(252, 210, 90, 0.85)", 2.5);
+    for (const path of map.externalExpressways) drawPath(ctx, path, "rgba(245, 140, 60, 0.95)", 4.2);
+  }
+
+  if (showHistory) {
+    for (const p of map.villages) dot(ctx, p, 1.9, "rgba(120, 100, 80, 0.72)");
+    for (const p of map.markets) dot(ctx, p, 4.8, "rgba(200, 130, 80, 0.95)");
+    for (const p of map.ports) {
+      const color = p.portClass === "major" ? "rgba(40, 105, 190, 0.98)" : p.portClass === "regional" ? "rgba(70, 130, 200, 0.95)" : p.portClass === "lake" ? "rgba(80, 155, 180, 0.92)" : "rgba(95, 150, 195, 0.82)";
+      triangleIcon(ctx, p, p.portClass === "major" ? 8.2 : 6.5, color);
+    }
+    for (const p of map.crossings) dot(ctx, p, 3.5, "rgba(255, 240, 180, 0.95)", "rgba(100,90,70,0.8)");
+    for (const p of map.passes) dot(ctx, p, 3.9, "rgba(150, 120, 180, 0.95)");
+    for (const p of map.castles) squareIcon(ctx, p, 7.0, "rgba(180, 70, 70, 0.96)");
+    for (const p of map.castleRuins) dot(ctx, p, 3.2, "rgba(110, 90, 90, 0.9)", "rgba(220,220,220,0.8)");
+  }
+
+  if (showModern) {
+    for (const p of map.industrialZones) squareIcon(ctx, p, 6.5, "rgba(140, 140, 150, 0.96)");
+    for (const p of map.stations) railStationIcon(ctx, p);
+    for (const p of map.satelliteCities || []) dot(ctx, p, 4.8, "rgba(215, 95, 145, 0.95)");
+    for (const p of map.newTowns) triangleIcon(ctx, p, 6.5, "rgba(180, 210, 240, 0.95)");
+    for (const p of map.modernCities) {
+      const popRadius = p.population ? Math.min(9.2, 3.4 + Math.sqrt(p.population) / 360) : 4.7;
+      const rankBoost = p.isPrefecturalCapital || p.rank === "Prefectural Capital" ? 1.6 : p.rank === "Regional Center" ? 0.45 : 0;
+      dot(ctx, p, popRadius + rankBoost, "rgba(230, 100, 100, 0.95)");
+      if (p.isPrefecturalCapital) dot(ctx, p, popRadius + 4.2, "rgba(255,255,255,0.0)", "rgba(180,60,60,0.95)");
+    }
+  }
+
+  if (showRoads) {
+    for (const p of map.logisticsParks) squareIcon(ctx, p, 6.2, "rgba(110, 170, 140, 0.96)");
+    for (const p of map.interchanges) dot(ctx, p, 4.1, "rgba(255, 255, 255, 0.98)", "rgba(220, 90, 60, 0.95)");
+    for (const p of map.externalGateways) dot(ctx, p, 4.4, "rgba(255, 250, 200, 0.98)", "rgba(60,60,60,0.92)");
+  }
+
+  if (showLabels) {
+    const important = [
+      ...map.modernCities,
+      ...map.ports,
+      ...map.markets.slice(0, 10),
+      ...map.castles.slice(0, 8),
+      ...(map.satelliteCities || []),
+      ...map.newTowns,
+      ...map.externalGateways,
+    ].filter((p) => p.insidePrefecture || p.kind === "External Gateway");
+
+    drawLabels(ctx, important);
+  }
+}
diff --git a/styles.css b/styles.css
new file mode 100644
index 0000000..92d07c0
--- /dev/null
+++ b/styles.css
@@ -0,0 +1,11 @@
+*{box-sizing:border-box} body{margin:0;background:#f5f5f5;color:#2c2c2c;font-family:ui-sans-serif,system-ui,-apple-system,BlinkMacSystemFont,"Segoe UI",sans-serif} button,input{font:inherit} code{background:#e8e8e8;border-radius:4px;padding:1px 4px} .app{min-height:100vh;padding:24px}.layout{display:grid;grid-template-columns:minmax(0,1fr) 330px;gap:16px;max-width:1400px;margin:0 auto}.header{margin-bottom:16px}.header h1{margin:0 0 6px;font-size:24px;letter-spacing:-0.02em;color:#1a1a1a}.header p{margin:0;color:#5a5a5a;line-height:1.65;font-size:14px}.canvas-shell,.card{background:#ffffff;border:1px solid rgb(0 0 0 / 0.12);border-radius:18px;box-shadow:0 2px 8px rgb(0 0 0 / 0.08)}.canvas-shell{padding:12px;overflow:auto;position:relative}.map-canvas{display:block;border-radius:12px;background:#f8f8f8}.sidebar{display:flex;flex-direction:column;gap:14px}.card{padding:16px}.label,.card-title{display:block;margin-bottom:10px;color:#2c2c2c;font-size:14px;font-weight:650}.input{width:100%;border:1px solid rgb(0 0 0 / 0.18);background:#fafafa;color:#2c2c2c;border-radius:12px;padding:9px 11px;outline:none}.input:focus{border-color:rgb(66 133 244 / 0.6)}.primary-button,.mode-button{border:0;border-radius:12px;padding:9px 11px;cursor:pointer}.primary-button{margin-top:10px;width:100%;background:#1a73e8;color:#fff;font-weight:650}.primary-button:hover{background:#1557b0}.mode-grid{display:grid;grid-template-columns:1fr 1fr;gap:8px}.mode-button{background:#f1f3f4;color:#3c4043;border:1px solid transparent}.mode-button:hover{background:#e8eaed}.mode-button.active{background:#1a73e8;color:#fff;font-weight:650;border:1px solid #1a73e8}.checkbox-row{display:flex;gap:8px;align-items:center;margin-top:12px;color:#3c4043;font-size:14px}.stats{display:flex;flex-direction:column;gap:7px}.stat-row{display:flex;justify-content:space-between;gap:12px;color:#5f6368;font-size:13px;align-items:baseline}.stat-row strong{color:#202124;font-family:ui-monospace,SFMono-Regular,Menlo,Monaco,Consolas,monospace}.legend{color:#5f6368;font-size:12px;line-height:1.65}.legend p{margin:8px 0 0}.example{margin:10px 0;padding:10px;background:#f8f9fa;border:1px solid rgb(0 0 0 / 0.1);border-radius:10px;color:#3c4043;overflow:auto}.id-list{max-height:220px;overflow:auto;margin-top:10px;display:flex;flex-direction:column;gap:6px}.id-row{display:grid;grid-template-columns:112px 1fr;gap:8px;align-items:center;color:#5f6368;font-size:12px}@media (max-width:1100px){.layout{grid-template-columns:1fr}}
+
+.legend-grid{display:flex;flex-direction:column;gap:7px;margin-top:8px}.legend-row{display:grid;grid-template-columns:30px 1fr;gap:8px;align-items:center;min-height:20px}.legend-line{display:inline-block;width:28px;height:0;border-top:3px solid #777;border-radius:999px}.legend-swatch{display:inline-block;width:26px;height:14px;border-radius:5px;background:#f5f5f5}.border-swatch{border:2px solid rgba(80,80,80,.8);box-shadow:inset 0 0 0 1px rgba(255,255,255,.9)}.river-major{border-top:4px solid rgba(100,170,210,.95);box-shadow:0 3px 0 rgba(120,180,215,.55)}.rail-line{border-top:3px solid rgba(70,70,70,.95)}.road-line{border-top:3px solid rgba(252,210,90,.95)}.express-line{border-top:5px solid rgba(245,140,60,.95)}.old-road-line{border-top:2px dashed rgba(150,120,90,.75)}.legend-icon{display:inline-block;width:15px;height:15px;justify-self:center;border:2px solid #fff;box-shadow:0 0 0 1px rgb(0 0 0 / .28)}.city-icon{border-radius:50%;background:rgba(230,100,100,.95);width:17px;height:17px}.port-icon{width:0;height:0;border-left:8px solid transparent;border-right:8px solid transparent;border-bottom:15px solid rgba(70,130,200,.95);border-top:0;box-shadow:none;background:transparent}.castle-icon{background:rgba(180,70,70,.96);border-radius:2px}.station-icon{background:#fff;border-color:rgba(60,60,60,.9);border-radius:2px}.industry-icon{background:rgba(110,170,140,.96);border-radius:2px}.newtown-icon{width:0;height:0;border-left:8px solid transparent;border-right:8px solid transparent;border-bottom:15px solid rgba(180,210,240,.95);border-top:0;box-shadow:none;background:transparent}
+
+
+
+.legend-swatch{width:18px;height:14px;border-radius:4px;border:1px solid rgb(0 0 0 / 0.18);display:inline-block}.cbd-swatch{background:rgb(224 202 190)}.satellite-icon{background:rgba(215,95,145,0.95);border-radius:999px;border:2px solid #fff}
+
+.legend-line.harbor-line::before{background:#6b86a0;height:3px;top:7px}
+
+.map-tooltip{position:absolute;z-index:20;pointer-events:none;min-width:190px;max-width:270px;background:rgba(255,255,255,.96);border:1px solid rgb(0 0 0 / .16);border-radius:10px;box-shadow:0 8px 24px rgb(0 0 0 / .16);padding:8px 10px;color:#2c2c2c;font-size:12px;line-height:1.5;opacity:0;transform:translateY(2px);transition:opacity .08s ease,transform .08s ease}.map-tooltip.visible{opacity:1;transform:translateY(0)}
diff --git a/test.html b/test.html
new file mode 100644
index 0000000..9e0c8f7
--- /dev/null
+++ b/test.html
@@ -0,0 +1,18 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <title>Prefecture Map Generator v7 Tests</title>
+    <style>
+      body { font-family: ui-sans-serif, system-ui, sans-serif; background: #111; color: #eee; padding: 24px; }
+      pre { background: #222; border-radius: 8px; padding: 16px; white-space: pre-wrap; }
+      .ok { color: #9fdf9f; }
+      .ng { color: #ff9f9f; }
+    </style>
+  </head>
+  <body>
+    <h1>Tests</h1>
+    <pre id="result">Running...</pre>
+    <script type="module" src="./test.js"></script>
+  </body>
+</html>
diff --git a/test.js b/test.js
new file mode 100644
index 0000000..78b2dab
--- /dev/null
+++ b/test.js
@@ -0,0 +1,152 @@
+import { generateMap, MAP_W, MAP_H, indexOf } from "./mapGenerator.js";
+
+const result = document.getElementById("result");
+const logLines = [];
+let failed = 0;
+
+function assert(condition, message) {
+  if (condition) logLines.push(`OK: ${message}`);
+  else {
+    failed += 1;
+    logLines.push(`NG: ${message}`);
+  }
+}
+
+try {
+  const map = generateMap(12345);
+  const other = generateMap(54321);
+  const size = MAP_W * MAP_H;
+  const urbanCellCount = [...map.landuse].filter((value) => value >= 2 && value <= 8).length;
+  const cityPopulations = map.modernCities.map((city) => city.population || 0);
+  const maxPopulation = Math.max(...cityPopulations);
+  const minPopulation = Math.min(...cityPopulations);
+  const landElevations = [...map.elevation].filter((_, i) => !map.sea[i]);
+  const meanElevation = landElevations.reduce((sum, value) => sum + value, 0) / landElevations.length;
+  const elevationStdDev = Math.sqrt(landElevations.reduce((sum, value) => sum + (value - meanElevation) ** 2, 0) / landElevations.length);
+  const modernPaths = [
+    ...map.railways,
+    ...map.branchRailways,
+    ...map.externalRailways,
+    ...(map.ringRailways || []),
+    ...map.nationalRoads,
+    ...(map.ringRoads || []),
+    ...map.expressways,
+    ...(map.ringExpressways || []),
+    ...map.externalRoads,
+    ...map.externalExpressways,
+  ];
+  const endpointDegree = new Map();
+  for (const path of modernPaths) {
+    if (path.length < 2) continue;
+    for (const point of [path[0], path[path.length - 1]]) {
+      const key = point.join(",");
+      endpointDegree.set(key, (endpointDegree.get(key) || 0) + 1);
+    }
+  }
+  const maxModernEndpointDegree = Math.max(0, ...endpointDegree.values());
+  let maxCoastalElevationStep = 0;
+  for (let y = 1; y < MAP_H - 1; y++) {
+    for (let x = 1; x < MAP_W - 1; x++) {
+      const i = indexOf(x, y);
+      if (map.sea[i]) continue;
+      for (const [dx, dy] of [[1, 0], [-1, 0], [0, 1], [0, -1]]) {
+        const ni = indexOf(x + dx, y + dy);
+        if (map.sea[ni]) maxCoastalElevationStep = Math.max(maxCoastalElevationStep, Math.abs(map.elevation[i] - map.elevation[ni]));
+      }
+    }
+  }
+  let railExpressHighMountainCells = 0;
+  for (const path of [...map.railways, ...map.branchRailways, ...(map.ringRailways || []), ...map.externalRailways, ...map.expressways, ...(map.ringExpressways || []), ...map.externalExpressways]) {
+    for (const [x, y] of path) {
+      const i = indexOf(x, y);
+      if (map.elevation[i] > 0.82) railExpressHighMountainCells += 1;
+    }
+  }
+
+  assert(map.elevation.length === size, "elevation length matches map size");
+  assert(map.sea.length === size, "sea length matches map size");
+  assert(map.river.length === size, "river length matches map size");
+  assert(map.landuse.length === size, "land-use length matches map size");
+  assert(map.adminId.length === size, "municipal id length matches map size");
+  assert(map.prefectureMask.length === size, "prefecture mask length matches map size");
+  assert(map.populationDensity.length === size, "population density length matches map size");
+  assert(map.ridgeField.length === size && map.valleyField.length === size && map.flowAccum.length === size, "causal terrain fields match map size");
+  assert(map.erosionField.length === size && map.depositionField.length === size, "erosion and deposition fields match map size");
+  assert(Array.isArray(map.bridges) && Array.isArray(map.tunnels) && Array.isArray(map.harborWorks), "legacy bridge/tunnel arrays and harbor arrays exist");
+  assert(map.prefectureRegionId.length === size && Array.isArray(map.regionalPrefectureBorders), "neighbor prefecture regions exist");
+  assert(Array.isArray(map.tributaryRivers) && Array.isArray(map.smallStreams), "river hierarchy arrays exist");
+  assert(Array.isArray(map.icAccessRoads), "IC access road array exists");
+  assert(Array.isArray(map.satelliteCities), "satelliteCities is an array");
+  assert(Array.isArray(map.ringRoads) && Array.isArray(map.ringExpressways) && Array.isArray(map.ringRailways), "ring transport arrays exist");
+
+  assert(Array.isArray(map.mainRivers), "mainRivers is an array");
+  assert(Array.isArray(map.minorRoads), "minorRoads is an array");
+  assert(Array.isArray(map.externalGateways), "externalGateways is an array");
+
+  let prefectureComponents = 0;
+  const seenPrefecture = new Uint8Array(size);
+  for (let i = 0; i < size; i++) {
+    if (!map.prefectureMask[i] || seenPrefecture[i]) continue;
+    prefectureComponents++;
+    const queue = [i];
+    seenPrefecture[i] = 1;
+    for (let q = 0; q < queue.length; q++) {
+      const cur = queue[q];
+      const x = cur % MAP_W;
+      const y = Math.floor(cur / MAP_W);
+      for (let dy = -1; dy <= 1; dy++) {
+        for (let dx = -1; dx <= 1; dx++) {
+          if (dx === 0 && dy === 0) continue;
+          const nx = x + dx;
+          const ny = y + dy;
+          if (nx < 0 || ny < 0 || nx >= MAP_W || ny >= MAP_H) continue;
+          const ni = ny * MAP_W + nx;
+          if (!map.prefectureMask[ni] || seenPrefecture[ni]) continue;
+          seenPrefecture[ni] = 1;
+          queue.push(ni);
+        }
+      }
+    }
+  }
+  assert(prefectureComponents === 1, "prefecture area is a single connected component");
+  assert(map.prefectureBorder.length > 0, "prefecture border exists");
+  assert(map.adminBorders.length > 0, "municipal borders exist");
+  assert(map.mainRivers.length > 0, "at least one major river exists");
+  assert(map.tributaryRivers.length > 0, "tributary river network exists");
+  assert(map.smallStreams.length > 0, "small stream network exists");
+  assert(map.harborWorks.length <= map.ports.length, "harbor works are attached to ports");
+  assert(map.ports.some((p) => p.portClass === "major"), "at least one major port is classified");
+  assert(map.ports.every((p) => ["major", "regional", "fishing", "lake"].includes(p.portClass)), "ports have explicit classes");
+  assert(map.externalGateways.length > 0, "external gateways exist");
+  assert(map.minorRoads.length > 0, "minor roads exist");
+  assert(map.adminCenters.length >= 12, "municipality count is sufficiently large");
+  assert(urbanCellCount > 1000, "large-city urbanized cells are broad enough");
+  const cbdCells = [...map.landuse].filter((value) => value === 3).length;
+  assert(cbdCells > 0, "CBD is represented as land-use cells rather than markers");
+  assert(map.modernCities.every((city) => Number.isFinite(city.population) && city.population > 0), "modern cities have population properties");
+  assert(maxPopulation / Math.max(1, minPopulation) > 3, "city populations vary strongly");
+  assert(map.totalPopulation >= cityPopulations.reduce((sum, value) => sum + value, 0), "total population includes city and satellite populations");
+  assert(Math.max(...map.populationDensity) > 0.9, "population density is normalized and populated");
+  assert(elevationStdDev > 0.18, "terrain relief has sufficient contrast");
+  assert(maxCoastalElevationStep < 0.12, "coastline and elevation do not create cliff artifacts");
+  assert(railExpressHighMountainCells === 0, "railways and expressways avoid huge mountain cells");
+  assert(maxModernEndpointDegree <= 10, "modern transport endpoints are not over-centralized");
+  assert(map.entitiesForNames.every((item) => item.id && item.name), "nameable entities have ids and names");
+
+  assert(
+    map.adminCenters.length !== other.adminCenters.length ||
+      map.villages.length !== other.villages.length ||
+      map.markets.length !== other.markets.length,
+    "feature counts vary between seeds"
+  );
+
+  const againA = generateMap(999);
+  const againB = generateMap(999);
+  assert(JSON.stringify(againA.modernCities) === JSON.stringify(againB.modernCities), "generation is deterministic for the same seed");
+
+  result.className = failed === 0 ? "ok" : "ng";
+  result.textContent = `${failed === 0 ? "All tests passed." : `${failed} tests failed.`}\n\n${logLines.join("\n")}`;
+} catch (error) {
+  result.className = "ng";
+  result.textContent = String(error?.stack || error);
+}