map/mapGeneratorHelpers.js

import { generateEntityName } from "./names.js";
import { INF, MAP_H, MAP_W, SIZE, MinHeap, clamp, hash2, indexOf, inside, nearMapEdge, pickEntities, rand, xyOf } from "./mapUtils.js";


export 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;
}

export function neighbors4(x, y) {
  const out = [];
  for (const [dx, dy] of [[1, 0], [-1, 0], [0, 1], [0, -1]]) {
    const nx = x + dx;
    const ny = y + dy;
    if (inside(nx, ny)) out.push([nx, ny, 1]);
  }
  return out;
}

export 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;
}

export function createPointSpatialIndex(points, cellSize = 12) {
  const buckets = new Map();
  const normalized = (points || [])
    .filter((p) => p && Number.isFinite(p.x) && Number.isFinite(p.y))
    .map((p) => ({ ...p, x: Math.round(p.x), y: Math.round(p.y) }));
  const keyOf = (cx, cy) => `${cx},${cy}`;
  for (const p of normalized) {
    const cx = Math.floor(p.x / cellSize);
    const cy = Math.floor(p.y / cellSize);
    const key = keyOf(cx, cy);
    let bucket = buckets.get(key);
    if (!bucket) {
      bucket = [];
      buckets.set(key, bucket);
    }
    bucket.push(p);
  }

  function nearestDistanceSq(x, y, maxDistance = Math.max(MAP_W, MAP_H)) {
    if (!normalized.length) return maxDistance * maxDistance;
    const cx = Math.floor(x / cellSize);
    const cy = Math.floor(y / cellSize);
    const maxRing = Number.isFinite(maxDistance) ? Math.ceil(maxDistance / cellSize) : Math.ceil(Math.max(MAP_W, MAP_H) / cellSize);
    let best = maxDistance * maxDistance;
    for (let ring = 0; ring <= maxRing; ring++) {
      for (let by = cy - ring; by <= cy + ring; by++) {
        for (let bx = cx - ring; bx <= cx + ring; bx++) {
          if (ring > 0 && bx > cx - ring && bx < cx + ring && by > cy - ring && by < cy + ring) continue;
          const bucket = buckets.get(keyOf(bx, by));
          if (!bucket) continue;
          for (const p of bucket) {
            const dx = p.x - x;
            const dy = p.y - y;
            const d2 = dx * dx + dy * dy;
            if (d2 < best) best = d2;
          }
        }
      }
    }
    return best;
  }

  return {
    points: normalized,
    hasWithin(x, y, radius) {
      return nearestDistanceSq(x, y, radius) < radius * radius;
    },
    distance(x, y, fallback = 999) {
      const d2 = nearestDistanceSq(x, y, fallback);
      return d2 < fallback * fallback ? Math.sqrt(d2) : fallback;
    },
    nearestDistanceSq,
  };
}

export 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 [];
}

export function influenceFromPaths(paths, radius) {
  const grid = new Float32Array(SIZE);
  const r = Math.ceil(radius);
  const r2 = radius * radius;
  for (const path of paths) {
    for (const [x, y] of path) {
      for (let dy = -r; dy <= r; dy++) {
        for (let dx = -r; dx <= r; dx++) {
          const nx = x + dx;
          const ny = y + dy;
          if (!inside(nx, ny)) continue;
          const d2 = dx * dx + dy * dy;
          if (d2 > r2) continue;
          const d = Math.sqrt(d2);
          const i = indexOf(nx, ny);
          grid[i] = Math.max(grid[i], 1 / (1 + d));
        }
      }
    }
  }
  return grid;
}

export function pointKey(p) {
  return `${p.x},${p.y}`;
}

export function getDegree(degreeMap, p) {
  return degreeMap.get(pointKey(p)) || 0;
}

export function incrementDegree(degreeMap, p) {
  degreeMap.set(pointKey(p), getDegree(degreeMap, p) + 1);
}

export 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];
}

export 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;
}

export 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;
}

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

export 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;
}

export 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]);
}

export function pathCompactness(path) {
  const direct = pathEndpointDistance(path);
  if (direct <= 0.001) return INF;
  return pathLength(path) / direct;
}

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

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

export 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;
}

export 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;
}

export 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;
}

export function influenceFromPoints(points, radius, weightFn = () => 1) {
  const grid = new Float32Array(SIZE);
  const r = Math.ceil(radius);
  const r2 = radius * radius;
  for (const p of points) {
    const weight = weightFn(p);
    for (let dy = -r; dy <= r; dy++) {
      for (let dx = -r; dx <= r; dx++) {
        const nx = p.x + dx;
        const ny = p.y + dy;
        if (!inside(nx, ny)) continue;
        const d2 = dx * dx + dy * dy;
        if (d2 > r2) continue;
        const d = Math.sqrt(d2);
        const i = indexOf(nx, ny);
        grid[i] = Math.max(grid[i], weight / (1 + d));
      }
    }
  }
  return grid;
}

export 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;
}

export 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;
}

export 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;
}

export 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;
}


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

export function generateRegionalPrefectures(seed, sea, elevation, slope, river, ridgeField, flowAccum, anchorMask) {
  const seeded = generateRegionalPrefecturesSeedGrowth(seed, sea, elevation, slope, river, ridgeField, flowAccum, anchorMask);
  const beforeRegionId = new Int16Array(seeded.regionId);
  const naturalBarrierScore = buildRegionalNaturalBarrierScore(sea, elevation, slope, river, ridgeField, flowAccum);
  const beforeBorderCount = countRegionBorderEdges(beforeRegionId, sea);
  const beforeNaturalAverage = averageRegionBorderBarrier(beforeRegionId, sea, naturalBarrierScore);
  const beforeVoronoiLikeRate = regionalVoronoiLikeRate(beforeRegionId, seeded.centers, sea, naturalBarrierScore);

  const { compartmentId, compartments } = buildRegionalNaturalCompartments(sea, elevation, slope, river, ridgeField, flowAccum, naturalBarrierScore);
  const owner = new Int16Array(compartments.length);
  owner.fill(-1);
  for (let id = 0; id < seeded.centers.length; id++) {
    const center = seeded.centers[id];
    if (!center || !inside(center.x, center.y)) continue;
    const ci = compartmentId[indexOf(center.x, center.y)];
    if (ci >= 0) owner[ci] = id;
  }
  for (const unit of compartments) {
    if (!unit || unit.area === 0) continue;
    if (unit.cells.some((i) => anchorMask[i])) owner[unit.id] = 0;
  }
  for (let pass = 0; pass < compartments.length + 6; pass++) {
    let changedThisPass = 0;
    for (const unit of compartments) {
      if (!unit || unit.area === 0 || owner[unit.id] >= 0) continue;
      let bestOwner = -1;
      let bestScore = -INF;
      for (const [neighborId, edge] of unit.adjacent || []) {
        const neighborOwner = owner[neighborId];
        if (neighborOwner < 0) continue;
        const neighbor = compartments[neighborId];
        const center = seeded.centers[neighborOwner];
        const barrier = edge.target / Math.max(1, edge.count);
        const sameClass = neighbor?.classId === unit.classId ? 1.0 : 0;
        const d = center ? Math.hypot(unit.x - center.x, unit.y - center.y) : 0;
        const score = edge.count * 0.45 + sameClass + neighbor.coastalExposure * 0.08 + neighbor.ridgeExposure * 0.05 - barrier * 2.6 - d * 0.008;
        if (score > bestScore) { bestScore = score; bestOwner = neighborOwner; }
      }
      if (bestOwner >= 0) {
        owner[unit.id] = bestOwner;
        changedThisPass++;
      }
    }
    if (changedThisPass === 0) break;
  }
  for (const unit of compartments) {
    if (!unit || unit.area === 0 || owner[unit.id] >= 0) continue;
    let bestId = 0;
    let best = -INF;
    for (let id = 0; id < seeded.centers.length; id++) {
      const center = seeded.centers[id];
      if (!center) continue;
      const d = Math.hypot(unit.x - center.x, unit.y - center.y);
      const score = -d + (id === 0 ? (unit.cells.some((i) => anchorMask[i]) ? 1000 : -12) : 0);
      if (score > best) { best = score; bestId = id; }
    }
    owner[unit.id] = bestId;
  }

  const regionId = new Int16Array(beforeRegionId);
  for (const unit of compartments) {
    const id = owner[unit.id];
    if (id < 0) continue;
    for (const i of unit.cells) regionId[i] = anchorMask[i] ? 0 : id;
  }
  for (let i = 0; i < SIZE; i++) if (anchorMask[i] && !sea[i]) regionId[i] = 0;
  for (let pass = 0; pass < 4; pass++) repairRegionalTopology(regionId, sea, seeded.centers, anchorMask, 260);
  repairDisconnectedRegionalPrefectures(regionId, sea, seeded.centers, anchorMask);
  mergeTinyRegionalPrefectures(regionId, sea, seeded.centers, anchorMask, 720);
  rebalanceOversizedRegionalPrefectures(regionId, sea, seeded.centers, anchorMask, naturalBarrierScore);
  snapRegionalBoundariesToNaturalFeatures(regionId, sea, anchorMask, naturalBarrierScore, 2);
  repairFinalRegionalTopology(regionId, sea, seeded.centers, anchorMask, naturalBarrierScore);

  let changed = 0;
  for (let i = 0; i < SIZE; i++) if (!sea[i] && beforeRegionId[i] !== regionId[i]) changed++;
  const afterBorderCount = countRegionBorderEdges(regionId, sea);
  const measuredAfterNaturalAverage = averageRegionBorderBarrier(regionId, sea, naturalBarrierScore);
  const afterNaturalAverage = measuredAfterNaturalAverage;
  const afterVoronoiLikeRate = regionalVoronoiLikeRate(regionId, seeded.centers, sea, naturalBarrierScore);

  return {
    regionId,
    centers: seeded.centers,
    naturalBarrierScore,
    debug: {
      regionalChangedAfterNaturalPartition: changed,
      regionalBorderCountBefore: beforeBorderCount,
      regionalBorderCountAfter: afterBorderCount,
      regionalVoronoiLikeRateBefore: beforeVoronoiLikeRate,
      regionalVoronoiLikeRateAfter: afterVoronoiLikeRate,
      regionalNaturalBarrierAverageBefore: beforeNaturalAverage,
      regionalNaturalBarrierAverageAfter: afterNaturalAverage,
      regionalDisplayBorderCount: countRegionBorderEdges(regionId, sea),
      regionalDisplayNaturalBarrierAverage: averageRegionBorderBarrier(regionId, sea, naturalBarrierScore),
      regionalCompartmentCount: compartments.filter((unit) => unit.area > 0).length,
      compartmentCount: compartments.filter((unit) => unit.area > 0).length,
      changedAfterCompartmentAssignment: changed,
      borderNaturalBarrierAverage: afterNaturalAverage,
      voronoiLikeRate: afterVoronoiLikeRate,
      finalRegionConnectivityMaxComponents: Math.max(0, ...[...new Set([...regionId].filter((id, i) => id >= 0 && !sea[i]))].map((id) => collectRegionComponents(regionId, sea, id).length)),
      finalRegionalEnclaveCount: countRegionalEnclaves(regionId, sea),
      finalRegionalMaxAreaShare: maxRegionalAreaShare(regionId, sea),
    },
  };
}

function generateRegionalPrefecturesSeedGrowth(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: 6 + Math.floor(rand(seed, 6101) * 4),
    minDistance: 31,
    threshold: 0.42,
    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 collectRegionComponents(regionId, sea, id) {
  const seen = new Uint8Array(SIZE);
  const components = [];
  for (let i = 0; i < SIZE; i++) {
    if (seen[i] || sea[i] || regionId[i] !== id) continue;
    const queue = [i];
    const cells = [];
    seen[i] = 1;
    for (let q = 0; q < queue.length; q++) {
      const cur = queue[q];
      cells.push(cur);
      const [x, y] = xyOf(cur);
      for (const [nx, ny] of neighbors4(x, y)) {
        const ni = indexOf(nx, ny);
        if (seen[ni] || sea[ni] || regionId[ni] !== id) continue;
        seen[ni] = 1;
        queue.push(ni);
      }
    }
    components.push(cells);
  }
  return components.sort((a, b) => b.length - a.length);
}

function chooseRegionalReassignment(cells, regionId, sea, centers, forbiddenId = -1) {
  const adjacent = new Map();
  let sx = 0, sy = 0;
  for (const i of cells) {
    const [x, y] = xyOf(i);
    sx += x; sy += y;
    for (const [nx, ny] of neighbors4(x, y)) {
      const ni = indexOf(nx, ny);
      const id = regionId[ni];
      if (sea[ni] || id < 0 || id === forbiddenId) continue;
      adjacent.set(id, (adjacent.get(id) || 0) + 1);
    }
  }
  let bestId = -1;
  let bestScore = -INF;
  const cx = sx / Math.max(1, cells.length);
  const cy = sy / Math.max(1, cells.length);
  for (const [id, edge] of adjacent) {
    const center = centers[id];
    const d = center ? Math.hypot(center.x - cx, center.y - cy) : 0;
    const score = edge * 4 - d * 0.04 + (id === 0 ? -1.5 : 0);
    if (score > bestScore) { bestScore = score; bestId = id; }
  }
  if (bestId >= 0) return bestId;
  for (let id = 0; id < centers.length; id++) {
    if (id === forbiddenId || !centers[id]) continue;
    const d = Math.hypot(centers[id].x - cx, centers[id].y - cy);
    const score = -d + (id === 0 ? -8 : 0);
    if (score > bestScore) { bestScore = score; bestId = id; }
  }
  return bestId;
}

function nearestRegionalReassignmentByLand(cells, regionId, sea, forbiddenId = -1) {
  const seen = new Uint8Array(SIZE);
  const queue = [];
  for (const i of cells) {
    seen[i] = 1;
    queue.push(i);
  }
  for (let q = 0; q < queue.length; q++) {
    const cur = queue[q];
    const [x, y] = xyOf(cur);
    for (const [nx, ny] of neighbors4(x, y)) {
      const ni = indexOf(nx, ny);
      if (sea[ni] || seen[ni]) continue;
      const id = regionId[ni];
      if (id >= 0 && id !== forbiddenId) return id;
      seen[ni] = 1;
      queue.push(ni);
    }
  }
  return -1;
}

function repairDisconnectedRegionalPrefectures(regionId, sea, centers, anchorMask) {
  let totalChanged = 0;
  for (let pass = 0; pass < 10; pass++) {
    let changedThisPass = 0;
    const ids = [...new Set([...regionId].filter((id, i) => id >= 0 && !sea[i]))].sort((a, b) => a - b);
    for (const id of ids) {
      const components = collectRegionComponents(regionId, sea, id);
      if (components.length <= 1) continue;
      let keepIndex = 0;
      if (id === 0) {
        const anchorIndex = components.findIndex((cells) => cells.some((i) => anchorMask[i]));
        if (anchorIndex >= 0) keepIndex = anchorIndex;
      }
      for (let c = 0; c < components.length; c++) {
        if (c === keepIndex) continue;
        const replacement =
          chooseRegionalReassignment(components[c], regionId, sea, centers, id) ??
          nearestRegionalReassignmentByLand(components[c], regionId, sea, id);
        const target = replacement >= 0 ? replacement : nearestRegionalReassignmentByLand(components[c], regionId, sea, id);
        if (target < 0) continue;
        for (const i of components[c]) {
          if (anchorMask[i]) continue;
          regionId[i] = target;
          changedThisPass++;
        }
      }
    }
    totalChanged += changedThisPass;
    for (let i = 0; i < SIZE; i++) if (anchorMask[i] && !sea[i]) regionId[i] = 0;
    if (changedThisPass === 0) break;
  }
  return totalChanged;
}

function componentTouchesOutside(cells, sea) {
  for (const i of cells) {
    const [x, y] = xyOf(i);
    if (x === 0 || y === 0 || x === MAP_W - 1 || y === MAP_H - 1) return true;
    for (const [nx, ny] of neighbors4(x, y)) if (sea[indexOf(nx, ny)]) return true;
  }
  return false;
}

function boundaryNeighborIds(cells, regionId, sea, ownId) {
  const ids = new Set();
  for (const i of cells) {
    const [x, y] = xyOf(i);
    for (const [nx, ny] of neighbors4(x, y)) {
      const ni = indexOf(nx, ny);
      const id = regionId[ni];
      if (!sea[ni] && id >= 0 && id !== ownId) ids.add(id);
    }
  }
  return ids;
}

function countRegionalEnclaves(regionId, sea) {
  let count = 0;
  const ids = [...new Set([...regionId].filter((id, i) => id >= 0 && !sea[i]))].sort((a, b) => a - b);
  for (const id of ids) {
    for (const cells of collectRegionComponents(regionId, sea, id)) {
      if (componentTouchesOutside(cells, sea)) continue;
      if (boundaryNeighborIds(cells, regionId, sea, id).size === 1) count++;
    }
  }
  return count;
}

function carveRegionalCorridor(regionId, sea, cells, ownId, enclosingId, naturalBarrierScore) {
  const best = new Float32Array(SIZE);
  const cameFrom = new Int32Array(SIZE);
  best.fill(INF);
  cameFrom.fill(-1);
  const heap = new MinHeap();
  const source = new Uint8Array(SIZE);
  for (const i of cells) {
    source[i] = 1;
    best[i] = 0;
    heap.push({ i, f: 0 });
  }
  let target = -1;
  while (heap.length) {
    const cur = heap.pop();
    if (!cur || cur.f > best[cur.i] + 1e-5) continue;
    const [x, y] = xyOf(cur.i);
    if (!source[cur.i]) {
      if (x === 0 || y === 0 || x === MAP_W - 1 || y === MAP_H - 1) { target = cur.i; break; }
      let seaAdjacent = false;
      let otherAdjacent = false;
      for (const [nx, ny] of neighbors4(x, y)) {
        const ni = indexOf(nx, ny);
        if (sea[ni]) seaAdjacent = true;
        else if (regionId[ni] >= 0 && regionId[ni] !== ownId && regionId[ni] !== enclosingId) otherAdjacent = true;
      }
      if (seaAdjacent || otherAdjacent) { target = cur.i; break; }
    }
    for (const [nx, ny] of neighbors4(x, y)) {
      const ni = indexOf(nx, ny);
      if (sea[ni] || regionId[ni] === ownId) continue;
      const id = regionId[ni];
      const regionPenalty = id === enclosingId ? 0 : 8;
      const barrier = naturalBarrierScore?.[ni] || 0;
      const nd = cur.f + 1 + barrier * 3.2 + regionPenalty;
      if (nd < best[ni]) {
        best[ni] = nd;
        cameFrom[ni] = cur.i;
        heap.push({ i: ni, f: nd });
      }
    }
  }
  if (target < 0) return 0;
  let changed = 0;
  for (let i = target; i >= 0 && regionId[i] !== ownId; i = cameFrom[i]) {
    if (!sea[i] && regionId[i] !== ownId) {
      regionId[i] = ownId;
      changed++;
    }
    if (cameFrom[i] < 0) break;
  }
  return changed;
}

function repairRegionalEnclaves(regionId, sea, centers, anchorMask, naturalBarrierScore) {
  let changed = 0;
  const ids = [...new Set([...regionId].filter((id, i) => id >= 0 && !sea[i]))].sort((a, b) => a - b);
  for (const id of ids) {
    const components = collectRegionComponents(regionId, sea, id);
    for (const cells of components) {
      if (componentTouchesOutside(cells, sea)) continue;
      const neighbors = boundaryNeighborIds(cells, regionId, sea, id);
      if (neighbors.size !== 1) continue;
      const enclosingId = [...neighbors][0];
      const protectedAnchor = id === 0 && cells.some((i) => anchorMask[i]);
      if (protectedAnchor) {
        changed += carveRegionalCorridor(regionId, sea, cells, id, enclosingId, naturalBarrierScore);
      } else {
        for (const i of cells) {
          if (anchorMask[i]) continue;
          regionId[i] = enclosingId;
          changed++;
        }
      }
    }
  }
  for (let i = 0; i < SIZE; i++) if (anchorMask[i] && !sea[i]) regionId[i] = 0;
  return changed;
}

function repairFinalRegionalTopology(regionId, sea, centers, anchorMask, naturalBarrierScore) {
  let totalChanged = 0;
  for (let pass = 0; pass < 12; pass++) {
    const disconnected = repairDisconnectedRegionalPrefectures(regionId, sea, centers, anchorMask);
    const enclaves = repairRegionalEnclaves(regionId, sea, centers, anchorMask, naturalBarrierScore);
    totalChanged += disconnected + enclaves;
    if (disconnected + enclaves === 0) break;
  }
  return totalChanged;
}

function regionalAreaById(regionId, sea) {
  const area = new Map();
  for (let i = 0; i < SIZE; i++) if (!sea[i] && regionId[i] >= 0) area.set(regionId[i], (area.get(regionId[i]) || 0) + 1);
  return area;
}

function maxRegionalAreaShare(regionId, sea) {
  const area = regionalAreaById(regionId, sea);
  const land = [...area.values()].reduce((sum, value) => sum + value, 0);
  return land ? Math.max(0, ...area.values()) / land : 0;
}

function canMoveRegionalBoundaryCell(regionId, sea, i, ownId) {
  const [x, y] = xyOf(i);
  let ownNeighbors = 0;
  let otherNeighbors = 0;
  for (const [nx, ny] of neighbors4(x, y)) {
    const ni = indexOf(nx, ny);
    if (sea[ni]) continue;
    if (regionId[ni] === ownId) ownNeighbors++;
    else if (regionId[ni] >= 0) otherNeighbors++;
  }
  return ownNeighbors >= 2 && otherNeighbors > 0;
}

function rebalanceOversizedRegionalPrefectures(regionId, sea, centers, anchorMask, naturalBarrierScore) {
  const minArea = 720;
  for (let pass = 0; pass < 4; pass++) {
    const area = regionalAreaById(regionId, sea);
    const land = [...area.values()].reduce((sum, value) => sum + value, 0);
    const maxArea = Math.max(minArea * 2, Math.floor(land * 0.32));
    let changed = 0;
    const oversized = [...area.entries()].filter(([, value]) => value > maxArea).sort((a, b) => b[1] - a[1]);
    for (const [id] of oversized) {
      const candidates = [];
      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] || regionId[i] !== id || anchorMask[i] || !canMoveRegionalBoundaryCell(regionId, sea, i, id)) continue;
          const counts = new Map();
          for (const [nx, ny] of neighbors4(x, y)) {
            const ni = indexOf(nx, ny);
            const other = regionId[ni];
            if (!sea[ni] && other >= 0 && other !== id && (area.get(other) || 0) < maxArea) counts.set(other, (counts.get(other) || 0) + 1);
          }
          for (const [other, edge] of counts) {
            const center = centers[other];
            const d = center ? Math.hypot(center.x - x, center.y - y) : 0;
            candidates.push({ i, other, score: edge * 2.0 + (naturalBarrierScore?.[i] || 0) * 1.4 - d * 0.006 });
          }
        }
      }
      candidates.sort((a, b) => b.score - a.score || a.i - b.i);
      for (const candidate of candidates) {
        if ((area.get(id) || 0) <= maxArea) break;
        if ((area.get(candidate.other) || 0) >= maxArea || regionId[candidate.i] !== id) continue;
        regionId[candidate.i] = candidate.other;
        area.set(id, (area.get(id) || 0) - 1);
        area.set(candidate.other, (area.get(candidate.other) || 0) + 1);
        changed++;
      }
    }
    repairDisconnectedRegionalPrefectures(regionId, sea, centers, anchorMask);
    if (!changed) break;
  }
}

function snapRegionalBoundariesToNaturalFeatures(regionId, sea, anchorMask, naturalBarrierScore, passes = 2) {
  for (let pass = 0; pass < passes; pass++) {
    const before = new Int16Array(regionId);
    let changed = 0;
    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 = before[i];
        if (sea[i] || own < 0 || anchorMask[i]) continue;
        const hereBarrier = naturalBarrierScore?.[i] || 0;
        if (hereBarrier > 0.54 || !canMoveRegionalBoundaryCell(before, sea, i, own)) continue;
        const counts = new Map();
        let bestNeighborBarrier = 0;
        for (const [nx, ny] of neighbors4(x, y)) {
          const ni = indexOf(nx, ny);
          const other = before[ni];
          if (sea[ni] || other < 0) continue;
          bestNeighborBarrier = Math.max(bestNeighborBarrier, naturalBarrierScore?.[ni] || 0);
          if (other !== own) counts.set(other, (counts.get(other) || 0) + 1);
        }
        if (counts.size === 0 || bestNeighborBarrier < hereBarrier + 0.18) continue;
        let target = -1, best = -1;
        for (const [other, count] of counts) if (count > best) { best = count; target = other; }
        if (target >= 0 && best >= 2) {
          regionId[i] = target;
          changed++;
        }
      }
    }
    if (!changed) break;
  }
}

function mergeTinyRegionalPrefectures(regionId, sea, centers, anchorMask, minArea) {
  const ids = [...new Set([...regionId].filter((id, i) => id >= 0 && !sea[i]))].sort((a, b) => a - b);
  for (const id of ids) {
    if (id === 0) continue;
    const cells = [];
    for (let i = 0; i < SIZE; i++) if (!sea[i] && regionId[i] === id) cells.push(i);
    if (cells.length === 0 || cells.length >= minArea) continue;
    const replacement = chooseRegionalReassignment(cells, regionId, sea, centers, id);
    if (replacement < 0) continue;
    for (const i of cells) if (!anchorMask[i]) regionId[i] = replacement;
  }
}

function buildRegionalNaturalBarrierScore(sea, elevation, slope, river, ridgeField, flowAccum) {
  const score = new Float32Array(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;
      let coast = 0;
      for (const [nx, ny] of neighbors8(x, y)) if (sea[indexOf(nx, ny)]) coast = 1;
      const highRidge = clamp(ridgeField[i] * 1.75 + Math.max(0, elevation[i] - 0.56) * 0.72);
      const slopeBreak = clamp(slope[i] * 0.92 + Math.max(0, slope[i] - 0.32) * 0.80);
      const majorRiver = clamp(Math.max(0, river[i] - 0.26) * 1.85 + Math.max(0, flowAccum[i] - 0.36) * 0.86);
      const watershedDivide = clamp(ridgeField[i] * Math.max(0, 0.62 - flowAccum[i]) * 1.08 + Math.max(0, elevation[i] - 0.50) * slope[i] * 0.72);
      score[i] = clamp(highRidge * 0.88 + slopeBreak * 0.48 + majorRiver * 0.82 + watershedDivide * 0.58 + coast * 0.46);
    }
  }
  return score;
}

function regionalLandscapeClass(i, sea, elevation, slope, river, ridgeField, flowAccum) {
  if (sea[i]) return -1;
  if (ridgeField[i] > 0.56 || elevation[i] > 0.68) return 1;
  if (river[i] > 0.44 || flowAccum[i] > 0.58) return 2;
  if (slope[i] > 0.42 || (ridgeField[i] > 0.36 && elevation[i] > 0.52)) return 3;
  if (elevation[i] < 0.36 && slope[i] < 0.20) return 4;
  if (elevation[i] < 0.48 && flowAccum[i] > 0.18) return 5;
  return 6;
}

function canShareRegionalCompartment(a, b, classA, classB, barrier, river, flowAccum) {
  const sameFamily = classA === classB || ([4, 5, 6].includes(classA) && [4, 5, 6].includes(classB));
  if (!sameFamily) return false;
  const majorRiver = Math.max(river[a], river[b]) > 0.58 || Math.max(flowAccum[a], flowAccum[b]) > 0.72;
  const threshold = classA === 1 || classB === 1 ? 0.38 : classA === 2 || classB === 2 ? 0.52 : 0.62;
  return barrier < threshold && !majorRiver;
}

function buildRegionalNaturalCompartments(sea, elevation, slope, river, ridgeField, flowAccum, naturalBarrierScore) {
  const compartmentId = new Int32Array(SIZE);
  const cellClass = new Int16Array(SIZE);
  compartmentId.fill(-1);
  cellClass.fill(-1);
  for (let i = 0; i < SIZE; i++) cellClass[i] = regionalLandscapeClass(i, sea, elevation, slope, river, ridgeField, flowAccum);

  const compartments = [];
  const queue = [];
  for (let i = 0; i < SIZE; i++) {
    if (cellClass[i] < 0 || compartmentId[i] >= 0) continue;
    const id = compartments.length;
    const klass = cellClass[i];
    const cells = [];
    let sx = 0, sy = 0, ridgeExposure = 0, riverExposure = 0, coastalExposure = 0;
    queue.length = 0;
    queue.push(i);
    compartmentId[i] = id;
    for (let q = 0; q < queue.length; q++) {
      const cur = queue[q];
      const [x, y] = xyOf(cur);
      cells.push(cur);
      sx += x;
      sy += y;
      ridgeExposure += ridgeField[cur];
      riverExposure += river[cur] + flowAccum[cur] * 0.45;
      let coast = 0;
      for (const [nx, ny] of neighbors8(x, y)) if (sea[indexOf(nx, ny)]) coast = 1;
      coastalExposure += coast;
      for (const [nx, ny] of neighbors4(x, y)) {
        const ni = indexOf(nx, ny);
        if (compartmentId[ni] >= 0 || cellClass[ni] < 0) continue;
        const barrier = (naturalBarrierScore[cur] + naturalBarrierScore[ni]) * 0.5;
        if (!canShareRegionalCompartment(cur, ni, klass, cellClass[ni], barrier, river, flowAccum)) continue;
        compartmentId[ni] = id;
        queue.push(ni);
      }
    }
    const area = cells.length;
    compartments.push({
      id,
      cells,
      area,
      classId: klass,
      x: sx / Math.max(1, area),
      y: sy / Math.max(1, area),
      ridgeExposure: ridgeExposure / Math.max(1, area),
      riverExposure: riverExposure / Math.max(1, area),
      coastalExposure: coastalExposure / Math.max(1, area),
      adjacent: new Map(),
    });
  }
  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 a = compartmentId[i];
      if (a < 0 || !compartments[a]) continue;
      for (const [nx, ny] of [[x + 1, y], [x, y + 1]]) {
        if (!inside(nx, ny)) continue;
        const ni = indexOf(nx, ny);
        if (sea[ni]) continue;
        const b = compartmentId[ni];
        if (b < 0 || a === b || !compartments[b]) continue;
        const v = (naturalBarrierScore[i] + naturalBarrierScore[ni]) * 0.5;
        const edgeA = compartments[a].adjacent.get(b) || { count: 0, target: 0 };
        edgeA.count++;
        edgeA.target += v;
        compartments[a].adjacent.set(b, edgeA);
        const edgeB = compartments[b].adjacent.get(a) || { count: 0, target: 0 };
        edgeB.count++;
        edgeB.target += v;
        compartments[b].adjacent.set(a, edgeB);
      }
    }
  }
  return { compartmentId, compartments };
}

function countRegionBorderEdges(regionId, sea) {
  let count = 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] || regionId[i] < 0) continue;
      for (const [nx, ny] of [[x + 1, y], [x, y + 1]]) {
        if (!inside(nx, ny)) continue;
        const ni = indexOf(nx, ny);
        if (!sea[ni] && regionId[ni] >= 0 && regionId[ni] !== regionId[i]) count++;
      }
    }
  }
  return count;
}

function averageRegionBorderBarrier(regionId, sea, naturalBarrierScore) {
  let sum = 0;
  let count = 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] || regionId[i] < 0) continue;
      for (const [nx, ny] of [[x + 1, y], [x, y + 1]]) {
        if (!inside(nx, ny)) continue;
        const ni = indexOf(nx, ny);
        if (sea[ni] || regionId[ni] < 0 || regionId[ni] === regionId[i]) continue;
        sum += (naturalBarrierScore[i] + naturalBarrierScore[ni]) * 0.5;
        count++;
      }
    }
  }
  return count ? sum / count : 0;
}

function regionalVoronoiLikeRate(regionId, centers, sea, naturalBarrierScore) {
  let weak = 0;
  let total = 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] || regionId[i] < 0) continue;
      for (const [nx, ny] of [[x + 1, y], [x, y + 1]]) {
        if (!inside(nx, ny)) continue;
        const ni = indexOf(nx, ny);
        const a = regionId[i];
        const b = regionId[ni];
        if (sea[ni] || a < 0 || b < 0 || a === b) continue;
        total++;
        const ca = centers[a], cb = centers[b];
        if (!ca || !cb) continue;
        const mx = (x + nx) * 0.5;
        const my = (y + ny) * 0.5;
        const nearBisector = Math.abs(Math.hypot(mx - ca.x, my - ca.y) - Math.hypot(mx - cb.x, my - cb.y)) < 4.5;
        if (nearBisector && (naturalBarrierScore[i] + naturalBarrierScore[ni]) * 0.5 < 0.36) weak++;
      }
    }
  }
  return total ? weak / total : 0;
}

function repairRegionalTopology(regionId, sea, centers, anchorMask, maxIslandCells = 260) {
  const ids = new Set();
  for (let i = 0; i < SIZE; i++) if (!sea[i] && regionId[i] >= 0) ids.add(regionId[i]);
  const queue = [];
  for (const id of ids) {
    const seen = new Uint8Array(SIZE);
    const components = [];
    for (let i = 0; i < SIZE; i++) {
      if (seen[i] || sea[i] || regionId[i] !== id) continue;
      const cells = [];
      let hasAnchor = false;
      let hasCenter = false;
      const centerIndex = centers[id] && inside(centers[id].x, centers[id].y) ? indexOf(centers[id].x, centers[id].y) : -1;
      queue.length = 0;
      queue.push(i);
      seen[i] = 1;
      for (let q = 0; q < queue.length; q++) {
        const cur = queue[q];
        cells.push(cur);
        if (anchorMask[cur]) hasAnchor = true;
        if (cur === centerIndex) hasCenter = true;
        const [x, y] = xyOf(cur);
        for (const [nx, ny] of neighbors4(x, y)) {
          const ni = indexOf(nx, ny);
          if (seen[ni] || sea[ni] || regionId[ni] !== id) continue;
          seen[ni] = 1;
          queue.push(ni);
        }
      }
      components.push({ cells, hasAnchor, hasCenter });
    }
    if (components.length <= 1) continue;
    components.sort((a, b) => (b.hasAnchor ? 2000000 : 0) + (b.hasCenter ? 1000000 : 0) + b.cells.length - ((a.hasAnchor ? 2000000 : 0) + (a.hasCenter ? 1000000 : 0) + a.cells.length));
    for (const comp of components.slice(1)) {
      const counts = new Map();
      for (const ci of comp.cells) {
        const [x, y] = xyOf(ci);
        for (const [nx, ny] of neighbors4(x, y)) {
          const ni = indexOf(nx, ny);
          const other = regionId[ni];
          if (!sea[ni] && other >= 0 && other !== id) counts.set(other, (counts.get(other) || 0) + 1);
        }
      }
      let target = -1;
      let best = -1;
      for (const [other, count] of counts) if (count > best) { best = count; target = other; }
      if (target >= 0) for (const ci of comp.cells) if (!anchorMask[ci]) regionId[ci] = target;
    }
  }
  for (let i = 0; i < SIZE; i++) if (anchorMask[i] && !sea[i]) regionId[i] = 0;
}

export function extractRegionBorderSegments(regionId, sea, options = {}) {
  const segments = [];
  const nameById = options.prefectureRegions
    ? new Map(options.prefectureRegions.map((region) => [region.id, region.name]))
    : null;
  const fail = (message) => {
    if (options.throwOnInvalid) throw new Error(message);
    if (options.logInvalid) console.error(message);
  };
  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 ni = indexOf(x + 1, y);
        const b = regionId[ni];
        if (b >= 0 && a !== b) segments.push([[x + 1, y], [x + 1, y + 1]]);
        else if (options.validateSameId && b >= 0 && a === b) fail(`Invalid prefecture border candidate at (${x},${y})/(${x + 1},${y}): both id=${a}, name=${nameById?.get(a) || "-"}`);
      }
      if (y + 1 < MAP_H && !sea[indexOf(x, y + 1)]) {
        const ni = indexOf(x, y + 1);
        const b = regionId[ni];
        if (b >= 0 && a !== b) segments.push([[x, y + 1], [x + 1, y + 1]]);
        else if (options.validateSameId && b >= 0 && a === b) fail(`Invalid prefecture border candidate at (${x},${y})/(${x},${y + 1}): both id=${a}, name=${nameById?.get(a) || "-"}`);
      }
    }
  }
  if (options.throwOnInvalid) {
    for (const segment of segments) {
      const [[x1, y1], [x2, y2]] = segment;
      let ax = -1, ay = -1, bx = -1, by = -1;
      if (x1 === x2) {
        ax = x1 - 1; bx = x1; ay = by = Math.min(y1, y2);
      } else if (y1 === y2) {
        ax = bx = Math.min(x1, x2); ay = y1 - 1; by = y1;
      }
      if (!inside(ax, ay) || !inside(bx, by)) continue;
      const ai = indexOf(ax, ay);
      const bi = indexOf(bx, by);
      const a = regionId[ai];
      const b = regionId[bi];
      if (sea[ai] || sea[bi] || a < 0 || b < 0 || a === b) {
        throw new Error(`Invalid emitted prefecture border ${JSON.stringify(segment)} between (${ax},${ay}) id=${a} name=${nameById?.get(a) || "-"} and (${bx},${by}) id=${b} name=${nameById?.get(b) || "-"}`);
      }
    }
  }
  return segments;
}

export 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;
}

export 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;
}

export function tagInsidePrefecture(points, prefectureMask) {
  return points.map((p) => ({ ...p, insidePrefecture: Boolean(prefectureMask[indexOf(p.x, p.y)]) }));
}

export function attachIdsAndNames(points, prefix, seed, kindOverride = null, nameFields = null, usedNames = null, nameDebug = null) {
  return points.map((p, i) => {
    const id = `${prefix}-${i}`;
    const kind = kindOverride || p.kind;
    if (prefix === "logistics") {
      return {
        ...p,
        id,
        name: null,
        facilityLabel: p.facilityLabel || "Logistics Park",
        kind,
        labelStyle: "facility",
        suppressSettlementLabel: true,
        insidePrefecture: Boolean(p.insidePrefecture),
      };
    }
    const name = generateEntityName(seed + prefix.length * 1000, id, { ...p, kind }, nameFields, usedNames, nameDebug);
    if (usedNames) usedNames.add(name);
    return {
      ...p,
      id,
      name,
      kind,
      insidePrefecture: Boolean(p.insidePrefecture),
    };
  });
}

export function applyOutputOptions(map, options = {}) {
  if (options.includeDebugFields !== false) return map;
  const slim = { ...map };
  delete slim.settlementCluster;
  delete slim.ridgeField;
  delete slim.valleyField;
  delete slim.basinField;
  delete slim.coastalLowland;
  delete slim.flowAccum;
  delete slim.erosionField;
  delete slim.depositionField;
  delete slim.terrainTemplate;
  delete slim.ocean;
  delete slim.lake;
  delete slim.arcSpineField;
  delete slim.branchRidgeField;
  delete slim.depositionalLowland;
  delete slim.alluvialFanField;
  delete slim.deltaField;
  delete slim.naturalBarrierScore;
  return slim;
}