@diagrammo/dgmo 0.60.0 → 0.62.0

package/dist/{chunk-DXSRQLD4.js → chunk-37EHGTQ2.js}

@@ -4,11 +4,11 @@ import {
   pointInGeometry
 } from "./chunk-4QV26TEG.js";
 import {
+  createLabelPlacement,
   rectCircleOverlap,
   rectsOverlap,
-  segmentRectOverlap,
-  segmentsCross
-} from "./chunk-VHO3YBTB.js";
+  segmentRectOverlap
+} from "./chunk-CVVICCSB.js";
 import {
   TITLE_FONT_SIZE,
   TITLE_Y
@@ -22,7 +22,7 @@ import {
 } from "./chunk-SCJ7CAJF.js";
 import {
   tagAttrKey
-} from "./chunk-LLA5C2TM.js";
+} from "./chunk-MDI5FMWO.js";
 import {
   contrastRatio,
   mix,
@@ -92,7 +92,7 @@ function mapLegendBox(legend, opts) {
 
 // src/map/layout.ts
 import {
-  geoPath,
+  geoPath as geoPath2,
   geoNaturalEarth1,
   geoEqualEarth,
   geoEquirectangular,
@@ -424,1607 +424,2249 @@ function placeContextLabels(args) {
   return placed;
 }
 
-// src/map/layout.ts
-var FIT_PAD = 24;
-var PATH_DIGITS = 1;
-var THIN_TOL = 0.6;
-var ALBERS_SKEW_MAX = 1.25;
-function geoThin() {
-  const tol2 = THIN_TOL * THIN_TOL;
-  return geoTransform({
-    lineStart() {
-      const t = this;
-      t._has = false;
-      t._pending = false;
-      t.stream.lineStart();
-    },
-    point(x, y) {
-      const t = this;
-      t._lx = x;
-      t._ly = y;
-      if (t._has) {
-        const dx = x - t._ex;
-        const dy = y - t._ey;
-        if (dx * dx + dy * dy < tol2) {
-          t._pending = true;
-          return;
-        }
+// src/map/city-dots.ts
+var CITY_DOT_SPACING = 12;
+var CITY_DOT_CAP = 220;
+var SPACING_SQ = CITY_DOT_SPACING * CITY_DOT_SPACING;
+var CITY_DOT_R_MIN = 0.7;
+var CITY_DOT_R_MAX = 2.6;
+var CITY_POP_MIN = 5e4;
+var CITY_POP_MAX = 15e6;
+var LOG_MIN = Math.log10(CITY_POP_MIN);
+var LOG_SPAN = Math.log10(CITY_POP_MAX) - LOG_MIN;
+function cityDotRadius(pop) {
+  if (!(pop > CITY_POP_MIN)) return CITY_DOT_R_MIN;
+  const t = Math.min(1, (Math.log10(pop) - LOG_MIN) / LOG_SPAN);
+  return CITY_DOT_R_MIN + t * (CITY_DOT_R_MAX - CITY_DOT_R_MIN);
+}
+function layoutCityDots(args) {
+  const { cities, occupied, project, width, height } = args;
+  const cityDots = [];
+  const placed = occupied.map((p) => ({
+    x: p.x,
+    y: p.y
+  }));
+  const sorted = [...cities].sort((a, b) => b[3] - a[3]);
+  for (const c of sorted) {
+    if (cityDots.length >= CITY_DOT_CAP) break;
+    const lat = c[0];
+    const lon = c[1];
+    const p = project(lon, lat);
+    if (!p) continue;
+    const [px, py] = p;
+    if (px < 0 || px > width || py < 0 || py > height) continue;
+    let tooClose = false;
+    for (const q of placed) {
+      const dx = q.x - px;
+      const dy = q.y - py;
+      if (dx * dx + dy * dy < SPACING_SQ) {
+        tooClose = true;
+        break;
       }
-      t.stream.point(x, y);
-      t._ex = x;
-      t._ey = y;
-      t._has = true;
-      t._pending = false;
-    },
-    lineEnd() {
-      const t = this;
-      if (t._pending) t.stream.point(t._lx, t._ly);
-      t._pending = false;
-      t.stream.lineEnd();
     }
+    if (tooClose) continue;
+    placed.push({ x: px, y: py });
+    cityDots.push({ cx: px, cy: py, r: cityDotRadius(c[3]) });
+  }
+  return cityDots;
+}
+
+// src/map/edge-labels.ts
+var T_LIST = [0.5, 0.42, 0.58, 0.34, 0.66, 0.28, 0.72];
+var LEG_PATH_RE = /^M(-?[\d.]+),(-?[\d.]+)(?:L(-?[\d.]+),(-?[\d.]+)|Q(-?[\d.]+),(-?[\d.]+) (-?[\d.]+),(-?[\d.]+))$/;
+function layoutEdgeLabels(args) {
+  const {
+    legs,
+    committed,
+    poiScreen,
+    markers,
+    labelW,
+    labelH,
+    minStroke,
+    fillAt,
+    labelOnFill,
+    width,
+    height
+  } = args;
+  const chosen = [];
+  if (!legs.some((lg) => lg.label !== void 0)) return chosen;
+  const committedBoxes = committed.filter((l) => !l.hidden).map((l) => {
+    const w = labelW(l.text);
+    const x = l.anchor === "start" ? l.x : l.anchor === "end" ? l.x - w : l.x - w / 2;
+    return { x, y: l.y - labelH / 2, w, h: labelH };
   });
+  const placedEdge = [];
+  for (let i = 0; i < legs.length; i++) {
+    const lg = legs[i];
+    if (lg.label === void 0) continue;
+    const a = poiScreen.get(lg.fromId);
+    const b = poiScreen.get(lg.toId);
+    if (!a || !b) continue;
+    const w = labelW(lg.label);
+    const dx = b.cx - a.cx;
+    const dy = b.cy - a.cy;
+    const len = Math.hypot(dx, dy) || 1;
+    const nx = -dy / len;
+    const ny = dx / len;
+    const perp = labelH + 2;
+    const stroke = lg.width ?? minStroke;
+    const clearW = stroke / 2 + labelH / 2 + 3;
+    const offList = stroke >= 4 ? [clearW, -clearW, clearW + perp, -(clearW + perp), 0] : [0, perp, -perp, 2 * perp, -2 * perp];
+    const pm = LEG_PATH_RE.exec(lg.d);
+    const pointAt = (t) => {
+      if (pm?.[5] !== void 0) {
+        const u = 1 - t;
+        return [
+          u * u * +pm[1] + 2 * u * t * +pm[5] + t * t * +pm[7],
+          u * u * +pm[2] + 2 * u * t * +pm[6] + t * t * +pm[8]
+        ];
+      }
+      if (pm?.[3] !== void 0)
+        return [
+          +pm[1] + (+pm[3] - +pm[1]) * t,
+          +pm[2] + (+pm[4] - +pm[2]) * t
+        ];
+      return [a.cx + dx * t, a.cy + dy * t];
+    };
+    const candidates = [];
+    for (const off of offList)
+      for (const t of T_LIST) {
+        const [bx, by] = pointAt(t);
+        candidates.push([bx + nx * off, by + ny * off - 4]);
+      }
+    const clean = ([cx2, cy2]) => {
+      const rect2 = { x: cx2 - w / 2, y: cy2 - labelH / 2, w, h: labelH };
+      if (rect2.x < 0 || rect2.x + w > width || rect2.y < 0 || rect2.y + rect2.h > height)
+        return false;
+      if (markers.some((m) => rectCircleOverlap(rect2, m))) return false;
+      if (committedBoxes.some((o) => rectsOverlap(o, rect2))) return false;
+      if (placedEdge.some((o) => rectsOverlap(o, rect2))) return false;
+      return true;
+    };
+    const mid = pointAt(0.5);
+    const [cx, cy] = candidates.find(clean) ?? [mid[0], mid[1] - 4];
+    const style = labelOnFill(fillAt(cx, cy));
+    legs[i] = {
+      ...lg,
+      labelX: cx,
+      labelY: cy,
+      labelColor: style.color,
+      labelHalo: style.halo,
+      labelHaloColor: style.haloColor
+    };
+    const rect = { x: cx - w / 2, y: cy - labelH / 2, w, h: labelH };
+    placedEdge.push(rect);
+    chosen.push(rect);
+  }
+  return chosen;
 }
-var RAMP_FLOOR = 15;
-var R_DEFAULT = 6;
-var R_MIN = 4;
-var R_MAX = 22;
-var POI_FILL_OPACITY_MAX = 0.92;
-var POI_FILL_OPACITY_MIN = 0.55;
+
+// src/map/connectors.ts
 var W_MIN = 1.25;
 var W_MAX = 8;
-var FONT2 = 11;
-var WORLD_LABEL_ANCHORS = {
-  US: [-98.5, 39.5],
-  // CONUS geographic centre (near Lebanon, Kansas)
-  // Russia crosses the antimeridian (Chukotka at ~170°W), so on a non-global
-  // (e.g. Europe) projection its geometry smears across the whole frame and the
-  // area-weighted centroid lands mid-map (over Europe) — useless as a label
-  // anchor. Pin it to European Russia (~Volga) so a Europe view labels visible
-  // western Russia on its eastern margin; on a world view this still sits over
-  // Russian land. (See the curated-anchor smear-gate bypass in context-labels.)
-  RU: [45, 58]
-};
-var MAX_CLUSTER_EXTENT_FACTOR = 0.18;
-var MAX_COLUMN_ROWS = 7;
-var REGION_LABEL_HALO_RATIO = 4.5;
-var LAND_TINT_LIGHT = 12;
-var LAND_TINT_DARK = 24;
-var TAG_TINT_LIGHT = 60;
-var TAG_TINT_DARK = 68;
-var WATER_TINT_LIGHT = 24;
-var WATER_TINT_DARK = 24;
-var RIVER_WIDTH = 1.3;
-var COMPACT_WIDTH_PX = 480;
-var RELIEF_MIN_AREA = 12;
-var RELIEF_MIN_DIM = 2;
-var RELIEF_HATCH_SPACING = 1.5;
-var RELIEF_HATCH_WIDTH = 0.2;
-var RELIEF_HATCH_STRENGTH = 26;
-var COASTLINE_RING_COUNT = 5;
-var COASTLINE_D0 = 16e-4;
-var COASTLINE_STEP = 28e-4;
-var COASTLINE_THICKNESS = 14e-4;
-var COASTLINE_OPACITY_NEAR = 0.5;
-var COASTLINE_OPACITY_FAR = 0.1;
-var COASTLINE_MIN_EXTENT = 6e-4;
-var COASTLINE_MIN_EXTENT_GLOBAL = 6e-4;
-var COASTLINE_STROKE_MIX = 32;
-var FOREIGN_TINT_LIGHT = 30;
-var FOREIGN_TINT_DARK = 62;
-var MUTED_FOREIGN_LIGHT = 28;
-var MUTED_FOREIGN_DARK = 16;
-var COLO_R = 9;
-var GOLDEN_ANGLE = 2.399963229728653;
-var STACK_OVERLAP = 1;
-var STACK_RING_MAX = 8;
-var STACK_RING_GAP = 4;
 var FAN_STEP = 16;
 var ARC_CURVE_FRAC = 0.18;
-function geomObject(topo) {
-  const key = Object.keys(topo.objects)[0];
-  return topo.objects[key];
-}
-var decodeCache = /* @__PURE__ */ new WeakMap();
-function mergeFeatures(a, b) {
-  const polysOf = (f) => {
-    const g = f.geometry;
-    if (!g) return null;
-    if (g.type === "Polygon") return [g.coordinates];
-    if (g.type === "MultiPolygon") return g.coordinates;
-    return null;
-  };
-  const pa = polysOf(a);
-  const pb = polysOf(b);
-  if (!pa || !pb) return a;
-  return {
-    ...a,
-    geometry: { type: "MultiPolygon", coordinates: [...pa, ...pb] }
-  };
+var RIM_GAP = 1.5;
+var LEG_SAMPLES = 25;
+var POI_CLEARANCE = 10;
+var LEG_CLEARANCE = 7;
+var SHARED_END_RADIUS = 36;
+function bowMagnitude(mx, my, nx, ny, offset, len, away) {
+  if (offset !== 0) return offset;
+  const base = len * ARC_CURVE_FRAC;
+  if (!away) return base;
+  const dot = nx * (mx - away.x) + ny * (my - away.y);
+  return dot < 0 ? -base : base;
 }
-function decodeLayer(topo) {
-  const cached = decodeCache.get(topo);
-  if (cached) return cached;
-  const out = /* @__PURE__ */ new Map();
-  for (const g of geomObject(topo).geometries) {
-    const f = feature(topo, g);
-    if (!f.geometry) continue;
-    const tagged = { ...f, id: g.id };
-    const existing = out.get(g.id);
-    out.set(g.id, existing ? mergeFeatures(existing, tagged) : tagged);
+function legPath(a, b, curved, offset, away) {
+  const mx = (a.cx + b.cx) / 2;
+  const my = (a.cy + b.cy) / 2;
+  const dx = b.cx - a.cx;
+  const dy = b.cy - a.cy;
+  const len = Math.hypot(dx, dy) || 1;
+  const trimA = Math.min(a.r + RIM_GAP, len * 0.45);
+  const trimB = Math.min(b.r + RIM_GAP, len * 0.45);
+  if (!curved && offset === 0) {
+    const ux = dx / len;
+    const uy = dy / len;
+    const ax2 = a.cx + ux * trimA;
+    const ay2 = a.cy + uy * trimA;
+    const bx2 = b.cx - ux * trimB;
+    const by2 = b.cy - uy * trimB;
+    return `M${ax2},${ay2}L${bx2},${by2}`;
   }
-  decodeCache.set(topo, out);
-  return out;
+  const nx = -dy / len;
+  const ny = dx / len;
+  const bow = bowMagnitude(mx, my, nx, ny, offset, len, away);
+  const px = mx + nx * bow;
+  const py = my + ny * bow;
+  const ta = Math.hypot(px - a.cx, py - a.cy) || 1;
+  const tb = Math.hypot(b.cx - px, b.cy - py) || 1;
+  const ax = a.cx + (px - a.cx) / ta * trimA;
+  const ay = a.cy + (py - a.cy) / ta * trimA;
+  const bx = b.cx - (b.cx - px) / tb * trimB;
+  const by = b.cy - (b.cy - py) / tb * trimB;
+  return `M${ax},${ay}Q${px},${py} ${bx},${by}`;
 }
-function countryLabelPositions(args) {
-  const { geometry, bounds, project, width, height, curated } = args;
-  const w0 = bounds[0][0];
-  const s0 = bounds[0][1];
-  const e0 = bounds[1][0];
-  const n0 = bounds[1][1];
-  if (![w0, s0, e0, n0].every(Number.isFinite) || e0 <= w0 || n0 <= s0) {
-    return mkCurated(curated, project);
-  }
-  const N = COUNTRY_POS_GRID;
-  const onLand = [];
-  const kept = [];
-  for (let i = 0; i < N; i++) {
-    onLand[i] = [];
-    const lon = w0 + (i + 0.5) / N * (e0 - w0);
-    for (let j = 0; j < N; j++) {
-      const lat = s0 + (j + 0.5) / N * (n0 - s0);
-      const land = pointInGeometry(geometry, lon, lat);
-      onLand[i][j] = land;
-      if (!land) continue;
-      const p = project(lon, lat);
-      if (!p || !Number.isFinite(p[0]) || !Number.isFinite(p[1])) continue;
-      if (p[0] < 0 || p[0] > width || p[1] < 0 || p[1] > height) continue;
-      kept.push({ i, j, lon, lat, sx: p[0], sy: p[1] });
+function legLabelPoint(a, b, curved, offset, away) {
+  const mx = (a.cx + b.cx) / 2;
+  const my = (a.cy + b.cy) / 2;
+  if (!curved && offset === 0) return { x: mx, y: my - 4 };
+  const dx = b.cx - a.cx;
+  const dy = b.cy - a.cy;
+  const len = Math.hypot(dx, dy) || 1;
+  const nx = -dy / len;
+  const ny = dx / len;
+  const bow = bowMagnitude(mx, my, nx, ny, offset, len, away);
+  const off = bow * 0.5 + Math.sign(bow || 1) * 8;
+  return { x: mx + nx * off, y: my + ny * off };
+}
+function buildConnectorLegs(args) {
+  const { resolved, poiScreen, palette, width, height, fillAt, labelOnFill } = args;
+  const legs = [];
+  const lineColor = (tags) => {
+    for (const group of resolved.tagGroups) {
+      const val = tags[tagAttrKey(group.name)];
+      if (!val) continue;
+      const entry = group.entries.find(
+        (e) => e.value.toLowerCase() === val.toLowerCase()
+      );
+      if (entry?.color) return entry.color;
     }
-  }
-  if (!kept.length) return mkCurated(curated, project);
-  const cx = kept.reduce((s, c) => s + c.sx, 0) / kept.length;
-  const cy = kept.reduce((s, c) => s + c.sy, 0) / kept.length;
-  const interiorness = (c) => {
-    let n = 0;
-    for (let di = -1; di <= 1; di++)
-      for (let dj = -1; dj <= 1; dj++) {
-        if (di === 0 && dj === 0) continue;
-        const ni = c.i + di;
-        const nj = c.j + dj;
-        if (ni >= 0 && ni < N && nj >= 0 && nj < N && onLand[ni][nj]) n++;
+    return null;
+  };
+  const placedLegSamples = [];
+  const sampleLeg = (a, b, curved, bow) => {
+    const pts = [];
+    const dx = b.cx - a.cx;
+    const dy = b.cy - a.cy;
+    const len = Math.hypot(dx, dy) || 1;
+    const px = (a.cx + b.cx) / 2 + -dy / len * bow;
+    const py = (a.cy + b.cy) / 2 + dx / len * bow;
+    for (let i = 0; i < LEG_SAMPLES; i++) {
+      const t = i / (LEG_SAMPLES - 1);
+      if (!curved && bow === 0) {
+        pts.push({ x: a.cx + dx * t, y: a.cy + dy * t });
+      } else {
+        const u = 1 - t;
+        pts.push({
+          x: u * u * a.cx + 2 * u * t * px + t * t * b.cx,
+          y: u * u * a.cy + 2 * u * t * py + t * t * b.cy
+        });
       }
-    return n;
+    }
+    return pts;
   };
-  const dist2ToCentre = (c) => (c.sx - cx) ** 2 + (c.sy - cy) ** 2;
-  const centreLon = kept.reduce((s, c) => s + c.lon, 0) / kept.length;
-  const centreLat = kept.reduce((s, c) => s + c.lat, 0) / kept.length;
-  const centreScreen = project(centreLon, centreLat);
-  const lead = pointInGeometry(geometry, centreLon, centreLat) && centreScreen && Number.isFinite(centreScreen[0]) && Number.isFinite(centreScreen[1]) && centreScreen[0] >= 0 && centreScreen[0] <= width && centreScreen[1] >= 0 && centreScreen[1] <= height ? [
-    {
-      lonLat: [centreLon, centreLat],
-      screen: [centreScreen[0], centreScreen[1]]
+  const legPenalty = (pts, fromId, toId) => {
+    let pen = 0;
+    for (const [id, p] of poiScreen) {
+      if (id === fromId || id === toId) continue;
+      let dmin = Infinity;
+      for (const s of pts) {
+        const d = Math.hypot(s.x - p.cx, s.y - p.cy);
+        if (d < dmin) dmin = d;
+      }
+      const clear = p.r + POI_CLEARANCE;
+      if (dmin < clear) pen += (clear - dmin) * 12;
     }
-  ] : [];
-  const grid = [...kept].sort(
-    (a, b) => interiorness(b) - interiorness(a) || dist2ToCentre(a) - dist2ToCentre(b)
-  ).map((c) => ({
-    lonLat: [c.lon, c.lat],
-    screen: [c.sx, c.sy]
-  }));
-  const curatedPos = curated ? mkCurated(curated, project) : [];
-  return [...curatedPos, ...lead, ...grid].slice(0, MAX_COUNTRY_POSITIONS);
-}
-function mkCurated(curated, project) {
-  if (!curated) return [];
-  const p = project(curated[0], curated[1]);
-  if (!p || !Number.isFinite(p[0]) || !Number.isFinite(p[1])) return [];
-  return [{ lonLat: [curated[0], curated[1]], screen: [p[0], p[1]] }];
-}
-var usConusProjection = () => geoConicEqualArea().parallels([29.5, 45.5]).rotate([96, 0]);
-var alaskaProjection = () => geoConicEqualArea().rotate([154, 0]).center([-2, 58.5]).parallels([55, 65]);
-var hawaiiProjection = () => geoMercator();
-function projectionFor(family, extent) {
-  switch (family) {
-    case "albers-usa":
-      return usConusProjection();
-    case "conic-equal-area": {
-      const s = extent[0][1];
-      const n = extent[1][1];
-      return geoConicEqualArea().parallels([s + (n - s) / 6, s + (n - s) * 5 / 6]).center([0, (s + n) / 2]);
-    }
-    case "mercator":
-      return geoMercator();
-    case "equal-earth":
-      return geoEqualEarth();
-    case "equirectangular":
-      return geoEquirectangular();
-    case "natural-earth":
-      return geoNaturalEarth1();
-    default:
-      return geoEquirectangular();
-  }
-}
-var INSET_STATES = /* @__PURE__ */ new Set(["US-AK", "US-HI"]);
-var inAlaska = (lon, lat) => lat >= 51 && (lon <= -129 || lon >= 172);
-var inHawaii = (lon, lat) => lat >= 18 && lat <= 23 && lon >= -161 && lon <= -154;
-var FOREIGN_BORDER = {
-  CA: [
-    "US-AK",
-    "US-WA",
-    "US-ID",
-    "US-MT",
-    "US-ND",
-    "US-MN",
-    "US-MI",
-    "US-NY",
-    "US-VT",
-    "US-NH",
-    "US-ME"
-  ],
-  MX: ["US-CA", "US-AZ", "US-NM", "US-TX"]
-};
-var US_NON_CONUS = /* @__PURE__ */ new Set([
-  "US-AK",
-  "US-HI",
-  "US-AS",
-  "US-GU",
-  "US-MP",
-  "US-PR",
-  "US-VI"
-]);
-function mapBackgroundColor(palette, isDark = false, _dataActive = false) {
-  return mix(
-    palette.colors.blue,
-    palette.bg,
-    isDark ? WATER_TINT_DARK : WATER_TINT_LIGHT
-  );
-}
-function mapNeutralLandColor(palette, isDark, _dataActive = false) {
-  return mix(
-    palette.colors.green,
-    palette.bg,
-    isDark ? LAND_TINT_DARK : LAND_TINT_LIGHT
-  );
-}
-function buildMapProjection(resolved, data) {
-  const wantsUsStates = resolved.basemaps.subdivisions.includes("us-states");
-  const usCrisp = (resolved.projection === "albers-usa" || resolved.projection === "mercator") && wantsUsStates && !!data.naLand;
-  const worldTopo = usCrisp ? data.worldDetail : resolved.basemaps.world === "detail" ? data.worldDetail : data.worldCoarse;
-  const worldLayer = new Map(decodeLayer(worldTopo));
-  if (usCrisp && data.naLand) {
-    const [nbW, nbS, nbE, nbN] = [-140, 10, -52, 66];
-    const crisp = decodeLayer(data.naLand);
-    for (const [iso, cf] of crisp) {
-      const base = worldLayer.get(iso);
-      if (!base) continue;
-      const [[bw, bs], [be, bn]] = geoBounds(base);
-      if (bw >= nbW && be <= nbE && bs >= nbS && bn <= nbN)
-        worldLayer.set(iso, { ...cf, properties: base.properties });
+    for (const other of placedLegSamples) {
+      const shared = [fromId, toId].filter((id) => id === other.fromId || id === other.toId).map((id) => poiScreen.get(id)).filter((p) => !!p);
+      for (const s of pts) {
+        if (shared.some(
+          (sp) => Math.hypot(s.x - sp.cx, s.y - sp.cy) < SHARED_END_RADIUS
+        )) {
+          continue;
+        }
+        let dmin = Infinity;
+        for (const o of other.pts) {
+          const d = Math.hypot(s.x - o.x, s.y - o.y);
+          if (d < dmin) dmin = d;
+        }
+        if (dmin < LEG_CLEARANCE) pen += 6;
+      }
     }
-  }
-  const usLayer = wantsUsStates ? decodeLayer(data.usStates) : null;
-  const extentOutline = () => {
-    const [[w, s], [e, n]] = resolved.extent;
-    const N = 16;
-    const coords = [];
-    for (let i = 0; i <= N; i++) {
-      const t = i / N;
-      const lon = w + (e - w) * t;
-      const lat = s + (n - s) * t;
-      coords.push([lon, s], [lon, n], [w, lat], [e, lat]);
+    for (const s of pts) {
+      if (s.x < 0 || s.x > width || s.y < 0 || s.y > height) pen += 20;
     }
-    return {
-      type: "Feature",
-      properties: {},
-      geometry: { type: "MultiPoint", coordinates: coords }
-    };
+    return pen;
   };
-  let fitFeatures;
-  if (resolved.projection === "albers-usa" && usLayer) {
-    fitFeatures = [...usLayer.entries()].filter(([iso]) => !US_NON_CONUS.has(iso)).map(([, f]) => f);
-    const neighborPoints = resolved.pois.filter((p) => !inAlaska(p.lon, p.lat) && !inHawaii(p.lon, p.lat)).map((p) => [p.lon, p.lat]);
-    if (neighborPoints.length > 0) {
-      fitFeatures.push({
-        type: "Feature",
-        properties: {},
-        geometry: { type: "MultiPoint", coordinates: neighborPoints }
-      });
-    }
-    for (const r of resolved.regions) {
-      if (r.layer === "country" && (r.iso === "CA" || r.iso === "MX")) {
-        const cf = worldLayer.get(r.iso);
-        if (cf) fitFeatures.push(cf);
+  const chooseArcBow = (a, b, fromId, toId, away) => {
+    const mx = (a.cx + b.cx) / 2;
+    const my = (a.cy + b.cy) / 2;
+    const dx = b.cx - a.cx;
+    const dy = b.cy - a.cy;
+    const len = Math.hypot(dx, dy) || 1;
+    const nx = -dy / len;
+    const ny = dx / len;
+    const def = bowMagnitude(mx, my, nx, ny, 0, len, away);
+    const candidates = [
+      def,
+      -def,
+      def * 1.6,
+      -def * 1.6,
+      def * 2.2,
+      -def * 2.2
+    ];
+    let best = def;
+    let bestPen = Infinity;
+    for (const c of candidates) {
+      const pen = legPenalty(sampleLeg(a, b, true, c), fromId, toId);
+      if (pen < bestPen - 1e-6) {
+        best = c;
+        bestPen = pen;
       }
+      if (bestPen === 0) break;
     }
-  } else {
-    fitFeatures = [extentOutline()];
-  }
-  const fitTarget = { type: "FeatureCollection", features: fitFeatures };
-  const projection = projectionFor(resolved.projection, resolved.extent);
-  if (resolved.projection !== "albers-usa") {
-    let centerLon = (resolved.extent[0][0] + resolved.extent[1][0]) / 2;
-    if (centerLon > 180) centerLon -= 360;
-    projection.rotate([-centerLon, 0]);
-  }
-  const fitGB = geoBounds(fitTarget);
-  const fitIsGlobal = fitGB[1][0] - fitGB[0][0] >= 270 || fitGB[1][1] - fitGB[0][1] >= 130;
-  return {
-    projection,
-    fitTarget,
-    fitIsGlobal,
-    worldLayer,
-    usLayer,
-    usCrisp,
-    wantsUsStates,
-    worldTopo
+    return best;
   };
-}
-function parsePathRings(d) {
-  const rings = [];
-  let cur = [];
-  const re = /([MLZ])([^MLZ]*)/g;
-  let m;
-  while (m = re.exec(d)) {
-    if (m[1] === "Z") {
-      if (cur.length) rings.push(cur);
-      cur = [];
-      continue;
-    }
-    if (m[1] === "M" && cur.length) {
-      rings.push(cur);
-      cur = [];
-    }
-    const nums = m[2].split(/[ ,]+/).map(Number);
-    for (let i = 0; i + 1 < nums.length; i += 2) {
-      const x = nums[i];
-      const y = nums[i + 1];
-      if (Number.isFinite(x) && Number.isFinite(y)) cur.push([x, y]);
+  const routeLegVals = resolved.routes.flatMap((rt) => rt.legs).map((l) => Number(l.value)).filter((n) => Number.isFinite(n) && n > 0);
+  const rlMin = routeLegVals.length ? Math.min(...routeLegVals) : 0;
+  const rlMax = routeLegVals.length ? Math.max(...routeLegVals) : 0;
+  const routeWidthFor = (v) => {
+    if (!Number.isFinite(v) || v <= 0 || rlMax <= 0) return W_MIN;
+    const t = rlMax > rlMin ? (v - rlMin) / (rlMax - rlMin) : 1;
+    return W_MIN + t * (W_MAX - W_MIN);
+  };
+  for (const rt of resolved.routes) {
+    const stopPts = rt.stopIds.map((id) => poiScreen.get(id)).filter((p) => !!p);
+    const center = stopPts.length >= 3 ? {
+      x: stopPts.reduce((s, p) => s + p.cx, 0) / stopPts.length,
+      y: stopPts.reduce((s, p) => s + p.cy, 0) / stopPts.length
+    } : void 0;
+    for (const leg of rt.legs) {
+      const a = poiScreen.get(leg.fromId);
+      const b = poiScreen.get(leg.toId);
+      if (!a || !b) continue;
+      const curvedLeg = leg.style === "arc";
+      const chosenBow = curvedLeg ? chooseArcBow(a, b, leg.fromId, leg.toId, center) : 0;
+      const lp = legLabelPoint(a, b, curvedLeg, chosenBow, center);
+      const bow = {
+        curved: curvedLeg,
+        offset: chosenBow,
+        center,
+        labelX: lp.x,
+        labelY: lp.y
+      };
+      placedLegSamples.push({
+        fromId: leg.fromId,
+        toId: leg.toId,
+        pts: sampleLeg(a, b, curvedLeg, chosenBow)
+      });
+      const routeLabelStyle = leg.label !== void 0 ? labelOnFill(fillAt(bow.labelX, bow.labelY)) : void 0;
+      const routeVal = Number(leg.value);
+      legs.push({
+        d: legPath(a, b, bow.curved, bow.offset, bow.center),
+        width: routeWidthFor(routeVal),
+        color: lineColor(leg.tags) ?? mix(palette.text, palette.bg, 72),
+        arrow: true,
+        fromId: leg.fromId,
+        toId: leg.toId,
+        ...Number.isFinite(routeVal) && routeVal > 0 && { value: routeVal },
+        ...Object.keys(leg.tags).length > 0 && { tags: leg.tags },
+        lineNumber: leg.lineNumber,
+        ...leg.label !== void 0 && {
+          label: leg.label,
+          labelX: bow.labelX,
+          labelY: bow.labelY,
+          labelColor: routeLabelStyle.color,
+          labelHalo: routeLabelStyle.halo,
+          labelHaloColor: routeLabelStyle.haloColor
+        }
+      });
     }
   }
-  if (cur.length) rings.push(cur);
-  return rings;
-}
-function dropAntimeridianWrapSlivers(d, width, height) {
-  const rings = parsePathRings(d);
-  if (rings.length <= 1) return d;
-  const eps = 0.75;
-  const minArea = 3e-3 * width * height;
-  const ringArea = (r) => {
-    let s = 0;
-    for (let i = 0; i < r.length; i++) {
-      const a = r[i];
-      const b = r[(i + 1) % r.length];
-      s += a[0] * b[1] - b[0] * a[1];
-    }
-    return Math.abs(s) / 2;
+  const weightVals = resolved.edges.map((e) => Number(e.meta["width"])).filter((n) => Number.isFinite(n) && n > 0);
+  const wMin = weightVals.length ? Math.min(...weightVals) : 0;
+  const wMax = weightVals.length ? Math.max(...weightVals) : 0;
+  const widthFor = (e) => {
+    const v = Number(e.meta["width"]);
+    if (!Number.isFinite(v) || v <= 0 || wMax <= 0) return W_MIN;
+    const t = wMax > wMin ? (v - wMin) / (wMax - wMin) : 1;
+    return W_MIN + t * (W_MAX - W_MIN);
   };
-  const areas = rings.map(ringArea);
-  const maxArea = Math.max(...areas);
-  const onVEdge = (a, b) => Math.abs(a[0]) <= eps && Math.abs(b[0]) <= eps || Math.abs(a[0] - width) <= eps && Math.abs(b[0] - width) <= eps;
-  let dropped = false;
-  const kept = rings.filter((r, idx) => {
-    if (areas[idx] >= maxArea || areas[idx] >= minArea) return true;
-    const touches = r.some((p, i) => onVEdge(p, r[(i + 1) % r.length]));
-    if (touches) {
-      dropped = true;
-      return false;
-    }
-    return true;
-  });
-  if (!dropped) return d;
-  return kept.map(
-    (r) => r.map((p, i) => (i ? "L" : "M") + p[0] + "," + p[1]).join("") + "Z"
-  ).join("");
-}
-function albersSkewFallback(resolved, data, width, height) {
-  if (resolved.projection !== "albers-usa") return false;
-  if (!resolved.basemaps.subdivisions.includes("us-states")) return false;
-  if (!(width > 0) || !(height > 0)) return false;
-  const akRef = resolved.regions.some((r) => r.iso === "US-AK") || resolved.pois.some((p) => inAlaska(p.lon, p.lat));
-  const hiRef = resolved.regions.some((r) => r.iso === "US-HI") || resolved.pois.some((p) => inHawaii(p.lon, p.lat));
-  if (akRef || hiRef) return false;
-  const { projection, fitTarget, usLayer } = buildMapProjection(resolved, data);
-  if (!usLayer || ![...usLayer.keys()].some((iso) => !US_NON_CONUS.has(iso)))
-    return false;
-  projection.fitSize([1e3, 1e3], fitTarget);
-  const b = geoPath(projection).bounds(fitTarget);
-  const conusAspect = (b[1][0] - b[0][0]) / (b[1][1] - b[0][1]);
-  if (!(conusAspect > 0)) return false;
-  const canvasAspect = width / height;
-  const skew = Math.max(canvasAspect / conusAspect, conusAspect / canvasAspect);
-  return skew > ALBERS_SKEW_MAX;
-}
-var REGION_GEO_MEMO = /* @__PURE__ */ new WeakMap();
-var REGION_GEO_MAX_FITS = 8;
-function regionGeoBucket(resolved, projKey) {
-  let byFit = REGION_GEO_MEMO.get(resolved);
-  if (!byFit) {
-    byFit = /* @__PURE__ */ new Map();
-    REGION_GEO_MEMO.set(resolved, byFit);
+  const pairGroups = /* @__PURE__ */ new Map();
+  for (const e of resolved.edges) {
+    const key = [e.fromId, e.toId].sort().join(" ");
+    const arr = pairGroups.get(key);
+    if (arr) arr.push(e);
+    else pairGroups.set(key, [e]);
   }
-  let bucket = byFit.get(projKey);
-  if (!bucket) {
-    bucket = /* @__PURE__ */ new Map();
-    byFit.set(projKey, bucket);
-    if (byFit.size > REGION_GEO_MAX_FITS) {
-      const oldest = byFit.keys().next().value;
-      if (oldest !== void 0) byFit.delete(oldest);
-    }
+  for (const groupEdges of pairGroups.values()) {
+    const ordered = [...groupEdges].sort((a, b) => a.lineNumber - b.lineNumber);
+    const n = ordered.length;
+    ordered.forEach((e, i) => {
+      const a = poiScreen.get(e.fromId);
+      const b = poiScreen.get(e.toId);
+      if (!a || !b) return;
+      const fanOffset = n > 1 ? (i - (n - 1) / 2) * FAN_STEP : 0;
+      const curved = e.style === "arc" || n > 1;
+      const edgeBow = curved && n === 1 ? chooseArcBow(a, b, e.fromId, e.toId) : fanOffset;
+      const lp = legLabelPoint(a, b, curved, edgeBow);
+      const bow = {
+        curved,
+        offset: edgeBow,
+        labelX: lp.x,
+        labelY: lp.y
+      };
+      placedLegSamples.push({
+        fromId: e.fromId,
+        toId: e.toId,
+        pts: sampleLeg(a, b, curved, edgeBow)
+      });
+      const edgeLabelStyle = e.label !== void 0 ? labelOnFill(fillAt(bow.labelX, bow.labelY)) : void 0;
+      const edgeVal = Number(e.meta["width"]);
+      legs.push({
+        d: legPath(a, b, bow.curved, bow.offset),
+        width: widthFor(e),
+        color: lineColor(e.tags) ?? mix(palette.text, palette.bg, 66),
+        arrow: e.directed,
+        fromId: e.fromId,
+        toId: e.toId,
+        ...Number.isFinite(edgeVal) && edgeVal > 0 && { value: edgeVal },
+        ...Object.keys(e.tags).length > 0 && { tags: e.tags },
+        lineNumber: e.lineNumber,
+        ...e.label !== void 0 && {
+          label: e.label,
+          labelX: bow.labelX,
+          labelY: bow.labelY,
+          labelColor: edgeLabelStyle.color,
+          labelHalo: edgeLabelStyle.halo,
+          labelHaloColor: edgeLabelStyle.haloColor
+        }
+      });
+    });
   }
-  return bucket;
+  return legs;
 }
-function layoutMap(resolvedIn, data, size, opts) {
-  const { palette, isDark } = opts;
-  const { width, height } = size;
-  let resolved = resolvedIn;
-  if (albersSkewFallback(resolved, data, width, height)) {
-    resolved = { ...resolved, projection: "conic-equal-area" };
-  }
+
+// src/map/insets.ts
+import { geoPath } from "d3-geo";
+var PAD = 8;
+var GAP = 12;
+var BW = 8;
+function layoutInsets(args) {
   const {
     projection,
-    fitTarget,
-    fitIsGlobal,
-    worldLayer,
     usLayer,
-    usCrisp,
-    worldTopo
-  } = buildMapProjection(resolved, data);
-  const usContext = usLayer !== null;
-  const regionStroke = isDark ? mix(palette.border, palette.text, 65) : mix(palette.text, palette.bg, 78);
-  const values = resolved.regions.filter((r) => r.value !== void 0).map((r) => r.value);
-  const rampMin = values.length > 0 ? Math.min(...values) : 0;
-  const rampMax = Math.max(...values);
-  const rampHue = resolveColor(resolved.directives.regionMetricColor ?? "", palette) ?? palette.colors.red;
-  const rampLow = resolved.directives.regionMetricLowColor ? resolveColor(resolved.directives.regionMetricLowColor, palette) ?? void 0 : void 0;
-  const hasRamp = values.length > 0;
-  const VALUE_NAME = hasRamp ? resolved.directives.regionMetric?.trim() || "Value" : null;
-  const matchColorGroup = (v) => {
-    const lv = v.trim().toLowerCase();
-    if (lv === "none") return null;
-    if (lv === VALUE_NAME?.toLowerCase()) return VALUE_NAME;
-    const tg = resolved.tagGroups.find((g) => g.name.toLowerCase() === lv);
-    return tg ? tg.name : v;
+    worldLayer,
+    regionById,
+    width,
+    height,
+    fitPad,
+    pathDigits,
+    nonConus,
+    colorizeActive,
+    colorByIso,
+    neutralFill,
+    foreignFill,
+    regionStroke,
+    colorizeStroke,
+    regionFill,
+    alaskaProjection: alaskaProjection2,
+    hawaiiProjection: hawaiiProjection2,
+    akRef,
+    hiRef
+  } = args;
+  const insets = [];
+  const insetRegions = [];
+  const insetLabelSeeds = [];
+  const yB = height - fitPad;
+  const coast = /* @__PURE__ */ new Map();
+  const addPt = (lon, lat) => {
+    const p = projection([lon, lat]);
+    if (!p) return;
+    const bi = Math.floor(p[0] / BW);
+    const cur = coast.get(bi);
+    if (cur === void 0 || p[1] > cur) coast.set(bi, p[1]);
   };
-  const fillGroupNames = /* @__PURE__ */ new Set();
-  for (const g of resolved.tagGroups) {
-    const k = g.name.toLowerCase();
-    if (resolved.regions.some((r) => r.tags[k]) || resolved.pois.some((p) => p.tags[k]))
-      fillGroupNames.add(g.name);
-  }
-  const firstFillGroup = resolved.tagGroups.find((g) => fillGroupNames.has(g.name))?.name ?? null;
-  const override = opts.activeGroup;
-  let activeGroup;
-  if (override !== void 0) {
-    activeGroup = override === null ? null : matchColorGroup(override);
-  } else if (resolved.directives.activeTag !== void 0) {
-    activeGroup = matchColorGroup(resolved.directives.activeTag);
-  } else {
-    activeGroup = VALUE_NAME ?? firstFillGroup ?? resolved.tagGroups[0]?.name ?? null;
+  const walk = (co) => {
+    if (Array.isArray(co) && typeof co[0] === "number")
+      addPt(co[0], co[1]);
+    else if (Array.isArray(co)) for (const c of co) walk(c);
+  };
+  for (const [iso, f] of usLayer) {
+    if (nonConus.has(iso)) continue;
+    walk(f.geometry.coordinates);
   }
-  const activeIsScore = VALUE_NAME !== null && activeGroup === VALUE_NAME;
-  const mutedBasemap = activeIsScore || activeGroup !== null && fillGroupNames.has(activeGroup);
-  const neutralFill = mapNeutralLandColor(palette, isDark, mutedBasemap);
-  const water = mapBackgroundColor(palette, isDark, mutedBasemap);
-  const lakeStroke = mix(regionStroke, water, 45);
-  const foreignFill = mix(
-    palette.colors.gray,
-    palette.bg,
-    mutedBasemap ? isDark ? MUTED_FOREIGN_DARK : MUTED_FOREIGN_LIGHT : isDark ? FOREIGN_TINT_DARK : FOREIGN_TINT_LIGHT
-  );
-  const contrastFloorTone = (tone, ...substrates) => {
-    const clears = (t) => substrates.every((s) => contrastRatio(t, s) >= REGION_LABEL_HALO_RATIO);
-    if (clears(tone)) return tone;
-    for (let s = 10; s <= 100; s += 10) {
-      const t = mix(palette.text, tone, s);
-      if (clears(t)) return t;
+  const at = (x) => {
+    const bi = Math.floor(x / BW);
+    let y = -Infinity;
+    for (let k = bi - 1; k <= bi + 1; k++) {
+      const v = coast.get(k);
+      if (v !== void 0 && v > y) y = v;
+    }
+    return y;
+  };
+  const coastFloor = (x0, xr) => {
+    const n = 24;
+    let maxY = -Infinity;
+    for (let i = 0; i <= n; i++) {
+      const y = at(x0 + (xr - x0) * i / n);
+      if (y > maxY) maxY = y;
+    }
+    return maxY;
+  };
+  const placeInset = (iso, proj, boxX, iwReq) => {
+    const f = usLayer.get(iso);
+    if (!f) return boxX;
+    const x0 = boxX;
+    const iw = Math.min(iwReq, width - fitPad - x0 - 2 * PAD);
+    if (iw < 24) return boxX;
+    const xr = x0 + iw + 2 * PAD;
+    const floor = coastFloor(x0, xr);
+    const topGuess = floor > -Infinity ? floor + GAP : yB - height * 0.42;
+    proj.fitWidth(iw, f);
+    const bb = geoPath(proj).bounds(f);
+    const sh = Number.isFinite(bb[0][0]) ? bb[1][1] - bb[0][1] : iw;
+    const needH = sh + 2 * PAD;
+    let topFit = topGuess;
+    const bottom = Math.min(topFit + needH, yB);
+    if (bottom - topFit < needH) topFit = bottom - needH;
+    proj.fitExtent(
+      [
+        [x0 + PAD, topFit + PAD],
+        [xr - PAD, bottom - PAD]
+      ],
+      f
+    );
+    const insetPath = geoPath(proj).digits(pathDigits);
+    const d = insetPath(f) ?? "";
+    if (!d) return xr;
+    let contextLand;
+    if (iso === "US-AK") {
+      const can = worldLayer.get("CA");
+      const cd = can ? insetPath(can) ?? "" : "";
+      if (cd)
+        contextLand = {
+          d: cd,
+          fill: colorizeActive ? colorByIso.get("CA") ?? foreignFill : foreignFill
+        };
     }
-    return palette.text;
+    const r = regionById.get(iso);
+    let fill = colorizeActive ? colorByIso.get(iso) ?? neutralFill : neutralFill;
+    let lineNumber = -1;
+    if (r?.layer === "us-state") {
+      fill = regionFill(r);
+      lineNumber = r.lineNumber;
+    }
+    insets.push({
+      x: x0,
+      y: topFit,
+      w: xr - x0,
+      h: bottom - topFit,
+      points: [
+        [x0, topFit],
+        [xr, topFit],
+        [xr, bottom],
+        [x0, bottom]
+      ],
+      // The FITTED inset projection (just fit to this box) — captured so the
+      // geo-query can invert pixels inside the frame back to AK/HI coords.
+      projection: proj,
+      ...contextLand && { contextLand }
+    });
+    insetRegions.push({
+      id: iso,
+      d,
+      fill,
+      stroke: colorizeActive ? colorizeStroke(fill) : regionStroke,
+      lineNumber,
+      layer: "us-state",
+      ...r?.value !== void 0 && { value: r.value },
+      ...r && Object.keys(r.tags).length > 0 && { tags: r.tags }
+    });
+    const ctr = geoPath(proj).centroid(f);
+    if (Number.isFinite(ctr[0])) {
+      const name = f.properties?.name ?? iso;
+      insetLabelSeeds.push({ x: ctr[0], y: ctr[1], iso, name, lineNumber });
+    }
+    return xr;
   };
-  const backdropLandTone = contrastFloorTone(
-    palette.textMuted,
+  let akRight = fitPad;
+  if (akRef)
+    akRight = placeInset("US-AK", alaskaProjection2(), fitPad, width * 0.18);
+  if (hiRef)
+    placeInset(
+      "US-HI",
+      hawaiiProjection2(),
+      akRef ? akRight + 24 : fitPad,
+      width * 0.12
+    );
+  return { insets, insetRegions, insetLabelSeeds };
+}
+
+// src/map/label-metrics.ts
+var FONT2 = 11;
+var LABEL_PADX = 6;
+var LABEL_PADY = 3;
+var VALUE_GAP = 1;
+var VALUE_FONT_FRAC = 0.82;
+var REGION_FONT_MAX_ORIENT = 22;
+var REGION_SIZE_FRAC_MIN = 0.06;
+var REGION_SIZE_FRAC_MAX = 0.32;
+var SUBJECT_FONT_MAX = 18;
+var SUBJECT_MIN_PROMINENCE = 13;
+var SUBJECT_LEADER_FONT = 15;
+function createLabelMetrics(size) {
+  const canvasLinear = Math.sqrt(Math.max(1, size.width * size.height));
+  const labelW = (text, font = FONT2) => measureLegendText(text, font) + 2 * LABEL_PADX;
+  return {
+    labelW,
+    labelH: FONT2 + 2 * LABEL_PADY,
+    // `font` defaults to the base size (every existing call is byte-identical);
+    // the post-placement growth pass passes a larger size to test an upscaled fit.
+    stackW: (text, valueText, font = FONT2) => Math.max(
+      labelW(text, font),
+      valueText ? measureLegendText(valueText, Math.round(font * VALUE_FONT_FRAC)) + 2 * LABEL_PADX : 0
+    ),
+    stackH: (hasValue, font = FONT2) => {
+      const lh = font + 2 * LABEL_PADY;
+      return hasValue ? lh + VALUE_GAP + Math.round(font * VALUE_FONT_FRAC) : lh;
+    },
+    sizeT: (boxW, boxH) => {
+      const frac = Math.sqrt(Math.max(0, boxW * boxH)) / canvasLinear;
+      return Math.min(
+        1,
+        Math.max(
+          0,
+          (frac - REGION_SIZE_FRAC_MIN) / (REGION_SIZE_FRAC_MAX - REGION_SIZE_FRAC_MIN)
+        )
+      );
+    }
+  };
+}
+
+// src/map/region-labels.ts
+function placeRegionLabels(args) {
+  const {
+    resolved,
+    palette,
+    width,
+    height,
+    path,
+    project,
+    worldLayer,
+    usLayer,
+    regionById,
+    regions,
+    pois,
+    insetLabelSeeds,
+    topReserved,
+    topPad,
+    markers,
+    collides,
     neutralFill,
-    water
-  );
-  const backdropWaterTone = contrastFloorTone(
-    mix(palette.colors.blue, palette.textMuted, 50),
     water,
-    neutralFill
-  );
-  const hasDirectColor = resolved.regions.some((r) => r.color !== void 0);
-  const colorizeActive = resolved.directives.noColorize !== true && !hasRamp && !hasDirectColor && fillGroupNames.size === 0;
-  const colorByIso = /* @__PURE__ */ new Map();
-  if (colorizeActive) {
-    const adjacency = /* @__PURE__ */ new Map();
-    const addEdges = (src) => {
-      for (const [iso, ns] of src) {
-        const cur = adjacency.get(iso);
-        if (cur) cur.push(...ns);
-        else adjacency.set(iso, [...ns]);
-      }
-    };
-    addEdges(buildAdjacency(worldTopo));
-    if (usLayer) {
-      addEdges(buildAdjacency(data.usStates));
-      for (const [country, states] of Object.entries(FOREIGN_BORDER)) {
-        const cn = adjacency.get(country);
-        if (!cn) continue;
-        for (const st of states) {
-          const sn = adjacency.get(st);
-          if (!sn) continue;
-          cn.push(st);
-          sn.push(country);
-        }
+    foreignFill,
+    backdropLandTone,
+    regionFill,
+    fillAt,
+    regionValueStr,
+    isCompact,
+    usChoroplethZoom,
+    metrics,
+    pushRegionLabel,
+    regionLabelRect,
+    labels,
+    labeledRegionIds,
+    regionLabelGuards
+  } = args;
+  const { labelW, labelH, stackW, stackH, sizeT } = metrics;
+  const frameContainers = new Set(resolved.poiFrameContainers);
+  const entries = regions.map((r) => {
+    const isContainer = frameContainers.has(r.id);
+    if (r.layer === "base" && !isContainer || r.label === void 0)
+      return null;
+    const isUsState = r.layer === "us-state" || r.id.startsWith("US-");
+    const f = isUsState ? usLayer?.get(r.id) : worldLayer.get(r.id);
+    if (!f) return null;
+    const [[x0, y0], [x1, y1]] = path.bounds(f);
+    const boxW = x1 - x0;
+    const boxH = y1 - y0;
+    const abbrev = isUsState && !usChoroplethZoom ? r.id.replace(/^US-/, "") : void 0;
+    const candidates = abbrev !== void 0 ? isCompact ? [abbrev, r.label] : isContainer ? [r.label] : [r.label, abbrev] : [r.label];
+    const anchor = !isUsState ? WORLD_LABEL_ANCHORS[r.id] : void 0;
+    const c = anchor ? project(anchor[0], anchor[1]) : path.centroid(f);
+    if (!c || !Number.isFinite(c[0])) return null;
+    return { r, c, boxW, boxH, area: boxW * boxH, candidates };
+  }).filter((e) => e !== null).sort((a, b) => b.area - a.area || a.r.lineNumber - b.r.lineNumber);
+  const isEmptyFill = (f) => f === water || f === neutralFill || f === foreignFill;
+  const POI_LABEL_PAD = 14;
+  const poiObstacles = pois.map((p) => ({
+    x: p.cx - p.r - POI_LABEL_PAD,
+    y: p.cy - p.r - POI_LABEL_PAD,
+    w: 2 * (p.r + POI_LABEL_PAD),
+    h: 2 * (p.r + POI_LABEL_PAD)
+  }));
+  const placement = createLabelPlacement({
+    reserved: topReserved,
+    obstacles: poiObstacles,
+    markers
+  });
+  const SHORT_HOP_MAX = Math.max(46, Math.min(width, height) * 0.11);
+  const STEP = 4;
+  const HOP_GAP = 9;
+  const CLEAR_STEP = 6;
+  const CLEAR_MAX = SHORT_HOP_MAX * 3;
+  const CLEAR_TOL = CLEAR_STEP;
+  const clearanceAt = (px, py, ox, oy) => {
+    const baseAng = Math.atan2(oy, ox);
+    let minClear = CLEAR_MAX;
+    for (let k = -2; k <= 2; k++) {
+      const a = baseAng + k * Math.PI / 4;
+      const rx = Math.cos(a);
+      const ry = Math.sin(a);
+      let d = CLEAR_STEP;
+      for (; d <= CLEAR_MAX; d += CLEAR_STEP) {
+        const qx = px + rx * d;
+        const qy = py + ry * d;
+        if (qx < FIT_PAD || qy < topPad || qx > width - FIT_PAD || qy > height - FIT_PAD)
+          break;
+        if (fillAt(qx, qy) !== water) break;
       }
+      if (d < minClear) minClear = d;
     }
-    const { byIso, huesNeeded } = assignColors(
-      [...adjacency.keys()],
-      adjacency
-    );
-    const tints = politicalTints(palette, huesNeeded, isDark);
-    for (const [iso, idx] of byIso) colorByIso.set(iso, tints[idx]);
-  }
-  const colorizeStroke = (fill) => mix(fill, palette.text, 35);
-  const rampBase = isDark ? mix(palette.surface, palette.text, 28) : palette.bg;
-  const rampLowFloor = mix(rampHue, rampBase, RAMP_FLOOR);
-  const fillForValue = (s) => {
-    const t = rampMax > rampMin ? (s - rampMin) / (rampMax - rampMin) : 1;
-    if (rampLow !== void 0)
-      return valueRampColor(rampLow, rampHue, t, { isDark });
-    const pct = RAMP_FLOOR + Math.max(0, Math.min(1, t)) * (100 - RAMP_FLOOR);
-    return mix(rampHue, rampBase, pct);
-  };
-  const tagFill = (tags, groupName) => {
-    if (!groupName) return null;
-    const group = resolved.tagGroups.find(
-      (g) => g.name.toLowerCase() === groupName.toLowerCase()
-    );
-    if (!group) return null;
-    const val = tags[tagAttrKey(group.name)] ?? group.defaultValue;
-    if (!val) return null;
-    const entry = group.entries.find(
-      (e) => e.value.toLowerCase() === val.toLowerCase()
-    );
-    if (!entry?.color) return null;
-    return mix(
-      entry.color,
-      palette.bg,
-      isDark ? TAG_TINT_DARK : TAG_TINT_LIGHT
-    );
-  };
-  const directFill = (name) => {
-    const hex = name ? resolveColor(name, palette) : null;
-    if (!hex) return null;
-    return mix(hex, palette.bg, isDark ? TAG_TINT_DARK : TAG_TINT_LIGHT);
+    return minClear;
   };
-  const regionFill = (r) => {
-    const direct = directFill(r.color);
-    if (direct) return direct;
-    if (activeIsScore) {
-      return r.value !== void 0 ? fillForValue(r.value) : neutralFill;
+  const tryShortHopCallout = (cx, cy, fill, name, value, font = FONT2, gap = HOP_GAP, maxLen = SHORT_HOP_MAX) => {
+    const chipW = stackW(name, value, font);
+    const chipH = stackH(value !== void 0, font);
+    const D = Math.SQRT1_2;
+    const dirs = [
+      [0, -1],
+      // north
+      [0, 1],
+      // south
+      [1, 0],
+      // east
+      [-1, 0],
+      // west
+      [D, -D],
+      // NE
+      [D, D],
+      // SE
+      [-D, -D],
+      // NW
+      [-D, D]
+      // SW
+    ];
+    let best = null;
+    for (const [dx, dy] of dirs) {
+      let ex = cx;
+      let ey = cy;
+      let steps = 0;
+      const maxSteps = Math.ceil(maxLen / STEP) + 1;
+      while (steps < maxSteps && fillAt(ex, ey) === fill) {
+        ex += dx * STEP;
+        ey += dy * STEP;
+        steps++;
+      }
+      if (fillAt(ex, ey) === fill) continue;
+      const halfAlong = (Math.abs(dx) * chipW + Math.abs(dy) * chipH) / 2;
+      const ccx = ex + dx * (gap + halfAlong);
+      const ccy = ey + dy * (gap + halfAlong);
+      const rect = {
+        x: ccx - chipW / 2,
+        y: ccy - chipH / 2,
+        w: chipW,
+        h: chipH
+      };
+      if (rect.x < FIT_PAD || rect.y < topPad || rect.x + rect.w > width - FIT_PAD || rect.y + rect.h > height - FIT_PAD)
+        continue;
+      const sx = [rect.x + 2, ccx, rect.x + rect.w - 2];
+      const sy = [rect.y + 2, ccy, rect.y + rect.h - 2];
+      let onEmpty = true;
+      for (const px of sx)
+        for (const py of sy)
+          if (!isEmptyFill(fillAt(px, py))) {
+            onEmpty = false;
+            break;
+          }
+      if (!onEmpty) continue;
+      if (placement.hitsPlaced(rect)) continue;
+      if (placement.hitsObstacle(rect)) continue;
+      if (placement.hitsMarker(rect)) continue;
+      const innerX = ccx - dx * (chipW / 2);
+      const innerY = ccy - dy * (chipH / 2);
+      const len = Math.hypot(innerX - cx, innerY - cy);
+      if (len > maxLen) continue;
+      const leader = [cx, cy, innerX, innerY];
+      if (placement.leaderCrosses(leader)) continue;
+      if (placement.leaderHitsPlaced(leader)) continue;
+      const clear = clearanceAt(ccx, ccy, dx, dy);
+      const better = best === null || clear > best.clear + CLEAR_TOL || clear >= best.clear - CLEAR_TOL && len < best.len;
+      if (better)
+        best = {
+          x: ccx,
+          y: ccy,
+          rect,
+          leader,
+          len,
+          clear
+        };
     }
-    if (colorizeActive) return (r.iso && colorByIso.get(r.iso)) ?? neutralFill;
-    return tagFill(r.tags, activeGroup) ?? neutralFill;
+    return best ? { x: best.x, y: best.y, rect: best.rect, leader: best.leader } : null;
   };
-  const regionById = new Map(resolved.regions.map((r) => [r.iso, r]));
-  let legend = null;
-  if (!resolved.directives.noLegend) {
-    const legendTagGroups = resolved.tagGroups.map((g) => ({
-      name: g.name,
-      entries: g.entries.map((e) => ({ value: e.value, color: e.color }))
-    }));
-    if (legendTagGroups.length > 0 || hasRamp) {
-      legend = {
-        tagGroups: legendTagGroups,
-        activeGroup,
-        ...hasRamp && {
-          ramp: {
-            ...resolved.directives.regionMetric !== void 0 && {
-              metric: resolved.directives.regionMetric
+  for (const { r, c, boxW, boxH, candidates } of entries) {
+    const valStr = regionValueStr(r.value);
+    const fitsRegions = (rect) => !placement.hitsPlaced(rect);
+    const fitsPois = (rect) => !placement.hitsObstacle(rect);
+    const isSubject = regionById.has(r.id);
+    const extremesOnFill = (ax, ay, text) => {
+      const halfW = measureLegendText(text, FONT2) / 2;
+      return fillAt(ax - halfW, ay) === r.fill && fillAt(ax + halfW, ay) === r.fill;
+    };
+    if (isSubject && valStr === void 0 && r.label !== void 0) {
+      const name = candidates[0];
+      let best = -1;
+      for (let f = SUBJECT_FONT_MAX; f >= FONT2; f--) {
+        if (measureLegendText(name, f) > boxW || f + 2 * LABEL_PADY > boxH)
+          continue;
+        const rect = regionLabelRect(c[0], c[1], name, void 0, f);
+        if (!fitsRegions(rect) || !fitsPois(rect) || collides(rect)) continue;
+        const halfW = measureLegendText(name, f) / 2;
+        if (fillAt(c[0] - halfW, c[1]) !== r.fill || fillAt(c[0] + halfW, c[1]) !== r.fill)
+          continue;
+        best = f;
+        break;
+      }
+      if (best >= SUBJECT_MIN_PROMINENCE) {
+        const rect = regionLabelRect(c[0], c[1], name, void 0, best);
+        placement.commit(rect);
+        pushRegionLabel(
+          c[0],
+          c[1],
+          name,
+          r.fill,
+          r.lineNumber,
+          void 0,
+          best
+        );
+        labeledRegionIds.add(r.id);
+        regionLabelGuards.push({ label: labels[labels.length - 1], rect });
+      } else {
+        const hop = tryShortHopCallout(
+          c[0],
+          c[1],
+          r.fill,
+          r.label,
+          void 0,
+          SUBJECT_LEADER_FONT,
+          HOP_GAP + SUBJECT_LEADER_FONT,
+          SHORT_HOP_MAX * 2.2
+        );
+        if (hop) {
+          placement.commit(hop.rect, hop.leader);
+          const dark = mix(r.fill, palette.text, 60);
+          labels.push({
+            x: hop.x,
+            y: hop.y,
+            text: r.label,
+            anchor: "middle",
+            color: palette.text,
+            halo: false,
+            haloColor: palette.bg,
+            fontSize: SUBJECT_LEADER_FONT,
+            leader: {
+              x1: hop.leader[0],
+              y1: hop.leader[1],
+              x2: hop.leader[2],
+              y2: hop.leader[3]
             },
-            min: rampMin,
-            max: rampMax,
-            low: rampLow ?? rampLowFloor,
-            high: rampHue
-          }
+            leaderColor: dark,
+            calloutDot: { x: c[0], y: c[1], color: dark },
+            lineNumber: r.lineNumber
+          });
+          labeledRegionIds.add(r.id);
         }
-      };
+      }
+      continue;
     }
-  }
-  const shownTitle = resolved.directives.noTitle ? null : resolved.title;
-  const TITLE_GAP = 16;
-  let topPad = FIT_PAD;
-  if (shownTitle && resolved.pois.length > 0) {
-    const bannerBottom = (resolved.subtitle ? TITLE_Y + TITLE_FONT_SIZE : TITLE_Y) + TITLE_FONT_SIZE / 2;
-    topPad = Math.max(FIT_PAD, bannerBottom + TITLE_GAP);
-  }
-  const legendBand = mapLegendBand(legend, {
-    width,
-    mode: opts.legendMode ?? "preview",
-    hasTitle: Boolean(shownTitle),
-    hasSubtitle: Boolean(resolved.subtitle)
-  });
-  if (legendBand > topPad) topPad = legendBand;
-  const topReserved = [];
-  if (shownTitle) {
-    const lines = resolved.subtitle ? 2 : 1;
-    const tw = Math.max(
-      measureLegendText(shownTitle, TITLE_FONT_SIZE),
-      resolved.subtitle ? measureLegendText(resolved.subtitle, TITLE_FONT_SIZE) : 0
-    ) + 2 * TITLE_FONT_SIZE;
-    topReserved.push({
-      x: width / 2 - tw / 2,
-      y: TITLE_Y - TITLE_FONT_SIZE,
-      w: tw,
-      h: TITLE_FONT_SIZE * (lines + 0.5)
-    });
-  }
-  const legendBox = mapLegendBox(legend, {
-    width,
-    mode: opts.legendMode ?? "preview",
-    hasTitle: Boolean(shownTitle),
-    hasSubtitle: Boolean(resolved.subtitle)
-  });
-  if (legendBox)
-    topReserved.push({
-      x: legendBox.x,
-      y: legendBox.y,
-      w: legendBox.width,
-      h: legendBox.height
-    });
-  const reserve = opts._calloutReserve;
-  const fitLeft = FIT_PAD + (reserve?.left ?? 0);
-  const fitRight = width - FIT_PAD - (reserve?.right ?? 0);
-  const fitTop = topPad + (reserve?.top ?? 0);
-  const fitBottom = height - FIT_PAD - (reserve?.bottom ?? 0);
-  const fitBox = [
-    [fitLeft, fitTop],
-    [Math.max(fitLeft + 1, fitRight), Math.max(fitTop + 1, fitBottom)]
-  ];
-  projection.fitExtent(fitBox, fitTarget);
-  if (!fitIsGlobal && resolved.projection !== "albers-usa" && resolved.regions.length > 0) {
-    let yMin = Infinity;
-    let yMax = -Infinity;
-    for (const r of resolved.regions) {
-      const bb = r.iso ? featureBboxPrimary(data.worldCoarse, r.iso) : null;
-      if (!bb) continue;
-      for (const lon of [bb[0][0], bb[1][0]]) {
-        for (const lat of [bb[0][1], bb[1][1]]) {
-          const p = projection([lon, lat]);
-          if (p && Number.isFinite(p[1])) {
-            if (p[1] < yMin) yMin = p[1];
-            if (p[1] > yMax) yMax = p[1];
+    const seekAnchors = [
+      { x: c[0], y: c[1], guard: false }
+    ];
+    if (valStr) {
+      seekAnchors.push(
+        { x: c[0], y: c[1] + boxH * 0.26, guard: true },
+        { x: c[0], y: c[1] - boxH * 0.26, guard: true },
+        { x: c[0] + boxW * 0.26, y: c[1], guard: true },
+        { x: c[0] - boxW * 0.26, y: c[1], guard: true },
+        { x: c[0] + boxW * 0.22, y: c[1] + boxH * 0.22, guard: true },
+        { x: c[0] - boxW * 0.22, y: c[1] + boxH * 0.22, guard: true },
+        { x: c[0] + boxW * 0.22, y: c[1] - boxH * 0.22, guard: true },
+        { x: c[0] - boxW * 0.22, y: c[1] - boxH * 0.22, guard: true }
+      );
+    }
+    let chosen;
+    for (const a of seekAnchors) {
+      if (a.guard && fillAt(a.x, a.y) !== r.fill) continue;
+      for (const t of candidates) {
+        const nameRect = regionLabelRect(a.x, a.y, t);
+        if (valStr && stackW(t, valStr) <= boxW && stackH(true) <= boxH) {
+          const stackRect = regionLabelRect(a.x, a.y, t, valStr);
+          if (fitsRegions(stackRect) && fitsPois(nameRect) && extremesOnFill(a.x, a.y, t)) {
+            chosen = { text: t, valueLine: valStr, ax: a.x, ay: a.y };
+            break;
+          }
+        }
+        if (labelW(t) <= boxW && labelH <= boxH) {
+          if (fitsRegions(nameRect) && fitsPois(nameRect) && (valStr === void 0 || extremesOnFill(a.x, a.y, t))) {
+            chosen = { text: t, ax: a.x, ay: a.y };
+            break;
           }
         }
       }
+      if (chosen) break;
     }
-    if (yMin < yMax) {
-      const boxTop = fitTop;
-      const boxBottom = fitBottom;
-      let dy = (boxTop + boxBottom) / 2 - (yMin + yMax) / 2;
-      const minDy = boxTop - yMin;
-      const maxDy = boxBottom - yMax;
-      if (minDy <= maxDy) dy = Math.max(minDy, Math.min(maxDy, dy));
-      const [tx, ty] = projection.translate();
-      projection.translate([tx, ty + dy]);
+    if (chosen === void 0 && r.label !== void 0 && isSubject) {
+      const hop = tryShortHopCallout(c[0], c[1], r.fill, r.label, valStr);
+      if (hop) {
+        placement.commit(hop.rect, hop.leader);
+        const dark = mix(r.fill, palette.text, 60);
+        labels.push({
+          x: hop.x,
+          y: hop.y,
+          text: r.label,
+          anchor: "middle",
+          color: palette.text,
+          halo: false,
+          haloColor: palette.bg,
+          ...valStr !== void 0 && { valueLine: valStr },
+          leader: {
+            x1: hop.leader[0],
+            y1: hop.leader[1],
+            x2: hop.leader[2],
+            y2: hop.leader[3]
+          },
+          leaderColor: dark,
+          calloutDot: { x: c[0], y: c[1], color: dark },
+          lineNumber: r.lineNumber
+        });
+        labeledRegionIds.add(r.id);
+      }
+      continue;
     }
-  }
-  if (!fitIsGlobal && resolved.projection === "albers-usa") {
-    const cb = geoPath(projection).bounds(fitTarget);
-    if (Number.isFinite(cb[0][1])) {
-      const slack = fitBottom - fitTop - (cb[1][1] - cb[0][1]);
-      if (slack > 0) {
-        const currentTopGap = cb[0][1] - fitTop;
-        const dy = slack * 0.3 - currentTopGap;
-        const [tx, ty] = projection.translate();
-        projection.translate([tx, ty + dy]);
+    if (chosen === void 0) continue;
+    const isOrient = r.value === void 0 && r.layer === "base";
+    let font = FONT2;
+    if (isOrient) {
+      const growT = sizeT(boxW, boxH);
+      const desiredFont = Math.round(
+        FONT2 + growT * (REGION_FONT_MAX_ORIENT - FONT2)
+      );
+      const hasVal = chosen.valueLine !== void 0;
+      const extremesClean = (f) => {
+        const halfW = measureLegendText(chosen.text, f) / 2;
+        return [chosen.ax - halfW, chosen.ax + halfW].every((sx) => {
+          const fAt = fillAt(sx, chosen.ay);
+          return fAt === r.fill || isEmptyFill(fAt);
+        });
+      };
+      let fit = -1;
+      for (let f = desiredFont; f >= FONT2; f--) {
+        if (stackW(chosen.text, chosen.valueLine, f) > boxW || stackH(hasVal, f) > boxH)
+          continue;
+        const gRect = regionLabelRect(
+          chosen.ax,
+          chosen.ay,
+          chosen.text,
+          chosen.valueLine,
+          f
+        );
+        const gName = regionLabelRect(
+          chosen.ax,
+          chosen.ay,
+          chosen.text,
+          void 0,
+          f
+        );
+        if (!fitsRegions(gRect) || !fitsPois(gName) || collides(gName))
+          continue;
+        if (!extremesClean(f)) continue;
+        fit = f;
+        break;
+      }
+      if (fit < 0) {
+        if (!frameContainers.has(r.id)) continue;
+        font = FONT2;
+      } else {
+        font = fit;
       }
     }
+    const rRect = regionLabelRect(
+      chosen.ax,
+      chosen.ay,
+      chosen.text,
+      chosen.valueLine,
+      font
+    );
+    placement.commit(rRect);
+    pushRegionLabel(
+      chosen.ax,
+      chosen.ay,
+      chosen.text,
+      r.fill,
+      r.lineNumber,
+      chosen.valueLine,
+      font,
+      isOrient ? backdropLandTone : void 0
+    );
+    labeledRegionIds.add(r.id);
+    regionLabelGuards.push({
+      label: labels[labels.length - 1],
+      rect: rRect
+    });
   }
-  let path;
-  let project;
-  let stretchParams = null;
-  if (fitIsGlobal && !opts.preferContain) {
-    const cb = geoPath(projection).bounds(fitTarget);
-    const bx0 = cb[0][0];
-    const by0 = cb[0][1];
-    const cw = cb[1][0] - bx0;
-    const ch = cb[1][1] - by0;
-    const topReserve = resolved.title && resolved.pois.length > 0 || legendBand > 0 ? topPad : 0;
-    const ox = 0;
-    const oy = topReserve;
-    const sx = cw > 0 ? width / cw : 1;
-    const sy = ch > 0 ? (height - topReserve) / ch : 1;
-    stretchParams = { sx, sy, ox, oy, bx0, by0 };
-    const stretch = (x, y) => [
-      ox + (x - bx0) * sx,
-      oy + (y - by0) * sy
-    ];
-    const baseProjection = projection;
-    const tx = geoTransform({
-      point(x, y) {
-        const [px, py] = stretch(x, y);
-        this.stream.point(px, py);
-      }
+  for (const seed of insetLabelSeeds) {
+    const text = isCompact ? seed.iso.replace(/^US-/, "") : seed.name;
+    const src = regionById.get(seed.iso);
+    const valStr = regionValueStr(src?.value);
+    pushRegionLabel(
+      seed.x,
+      seed.y,
+      text,
+      src ? regionFill(src) : neutralFill,
+      seed.lineNumber,
+      valStr
+    );
+    labeledRegionIds.add(seed.iso);
+    regionLabelGuards.push({
+      label: labels[labels.length - 1],
+      rect: regionLabelRect(seed.x, seed.y, text, valStr)
     });
-    const thin = geoThin();
-    path = geoPath({
-      stream: (s) => baseProjection.stream(
-        tx.stream(
-          thin.stream(s)
-        )
-      )
-    }).digits(PATH_DIGITS);
-    project = (lon, lat) => {
-      const p = baseProjection([lon, lat]);
-      return p ? stretch(p[0], p[1]) : null;
-    };
-  } else {
-    projection.clipExtent([
-      [0, 0],
-      [width, height]
-    ]);
-    const thin = geoThin();
-    path = geoPath({
-      stream: (s) => projection.stream(
-        thin.stream(s)
-      )
-    }).digits(PATH_DIGITS);
-    project = (lon, lat) => projection([lon, lat]) ?? null;
   }
-  const regionGeo = regionGeoBucket(
-    resolvedIn,
-    JSON.stringify([
-      width,
-      height,
-      [
-        [-100, 40],
-        [-120, 37],
-        [-80, 40],
-        [0, 0],
-        [60, 30],
-        [-60, -30],
-        [150, 60],
-        [-150, -60],
-        [100, -40],
-        [-30, 50]
-      ].map(([lo, la]) => project(lo, la))
-    ])
-  );
-  const insets = [];
-  const insetRegions = [];
-  const insetLabelSeeds = [];
-  const akRef = resolved.regions.some((r) => r.iso === "US-AK") || resolved.pois.some((p) => inAlaska(p.lon, p.lat));
-  const hiRef = resolved.regions.some((r) => r.iso === "US-HI") || resolved.pois.some((p) => inHawaii(p.lon, p.lat));
-  if (resolved.projection === "albers-usa" && usLayer && (akRef || hiRef)) {
-    const PAD = 8;
-    const GAP = 12;
-    const yB = height - FIT_PAD;
-    const BW = 8;
-    const coast = /* @__PURE__ */ new Map();
-    const addPt = (lon, lat) => {
-      const p = projection([lon, lat]);
-      if (!p) return;
-      const bi = Math.floor(p[0] / BW);
-      const cur = coast.get(bi);
-      if (cur === void 0 || p[1] > cur) coast.set(bi, p[1]);
-    };
-    const walk = (co) => {
-      if (Array.isArray(co) && typeof co[0] === "number")
-        addPt(co[0], co[1]);
-      else if (Array.isArray(co)) for (const c of co) walk(c);
-    };
-    for (const [iso, f] of usLayer) {
-      if (US_NON_CONUS.has(iso)) continue;
-      walk(f.geometry.coordinates);
-    }
-    const at = (x) => {
-      const bi = Math.floor(x / BW);
-      let y = -Infinity;
-      for (let k = bi - 1; k <= bi + 1; k++) {
-        const v = coast.get(k);
-        if (v !== void 0 && v > y) y = v;
-      }
-      return y;
-    };
-    const coastFloor = (x0, xr) => {
-      const n = 24;
-      let maxY = -Infinity;
-      for (let i = 0; i <= n; i++) {
-        const y = at(x0 + (xr - x0) * i / n);
-        if (y > maxY) maxY = y;
-      }
-      return maxY;
-    };
-    const placeInset = (iso, proj, boxX, iwReq) => {
-      const f = usLayer.get(iso);
-      if (!f) return boxX;
-      const x0 = boxX;
-      const iw = Math.min(iwReq, width - FIT_PAD - x0 - 2 * PAD);
-      if (iw < 24) return boxX;
-      const xr = x0 + iw + 2 * PAD;
-      const floor = coastFloor(x0, xr);
-      const topGuess = floor > -Infinity ? floor + GAP : yB - height * 0.42;
-      proj.fitWidth(iw, f);
-      const bb = geoPath(proj).bounds(f);
-      const sh = Number.isFinite(bb[0][0]) ? bb[1][1] - bb[0][1] : iw;
-      const needH = sh + 2 * PAD;
-      let topFit = topGuess;
-      const bottom = Math.min(topFit + needH, yB);
-      if (bottom - topFit < needH) topFit = bottom - needH;
-      proj.fitExtent(
-        [
-          [x0 + PAD, topFit + PAD],
-          [xr - PAD, bottom - PAD]
-        ],
-        f
-      );
-      const insetPath = geoPath(proj).digits(PATH_DIGITS);
-      const d = insetPath(f) ?? "";
-      if (!d) return xr;
-      let contextLand;
-      if (iso === "US-AK") {
-        const can = worldLayer.get("CA");
-        const cd = can ? insetPath(can) ?? "" : "";
-        if (cd)
-          contextLand = {
-            d: cd,
-            fill: colorizeActive ? colorByIso.get("CA") ?? foreignFill : foreignFill
-          };
-      }
-      const r = regionById.get(iso);
-      let fill = colorizeActive ? colorByIso.get(iso) ?? neutralFill : neutralFill;
-      let lineNumber = -1;
-      if (r?.layer === "us-state") {
-        fill = regionFill(r);
-        lineNumber = r.lineNumber;
-      }
-      insets.push({
-        x: x0,
-        y: topFit,
-        w: xr - x0,
-        h: bottom - topFit,
-        points: [
-          [x0, topFit],
-          [xr, topFit],
-          [xr, bottom],
-          [x0, bottom]
-        ],
-        // The FITTED inset projection (just fit to this box) — captured so the
-        // geo-query can invert pixels inside the frame back to AK/HI coords.
-        projection: proj,
-        ...contextLand && { contextLand }
-      });
-      insetRegions.push({
-        id: iso,
-        d,
-        fill,
-        stroke: colorizeActive ? colorizeStroke(fill) : regionStroke,
-        lineNumber,
-        layer: "us-state",
-        ...r?.value !== void 0 && { value: r.value },
-        ...r && Object.keys(r.tags).length > 0 && { tags: r.tags }
-      });
-      const ctr = geoPath(proj).centroid(f);
-      if (Number.isFinite(ctr[0])) {
-        const name = f.properties?.name ?? iso;
-        insetLabelSeeds.push({ x: ctr[0], y: ctr[1], iso, name, lineNumber });
+}
+
+// src/map/layout.ts
+var FIT_PAD = 24;
+var PATH_DIGITS = 1;
+var THIN_TOL = 0.6;
+var ALBERS_SKEW_MAX = 1.25;
+function geoThin() {
+  const tol2 = THIN_TOL * THIN_TOL;
+  return geoTransform({
+    lineStart() {
+      const t = this;
+      t._has = false;
+      t._pending = false;
+      t.stream.lineStart();
+    },
+    point(x, y) {
+      const t = this;
+      t._lx = x;
+      t._ly = y;
+      if (t._has) {
+        const dx = x - t._ex;
+        const dy = y - t._ey;
+        if (dx * dx + dy * dy < tol2) {
+          t._pending = true;
+          return;
+        }
       }
-      return xr;
-    };
-    let akRight = FIT_PAD;
-    if (akRef)
-      akRight = placeInset("US-AK", alaskaProjection(), FIT_PAD, width * 0.18);
-    if (hiRef)
-      placeInset(
-        "US-HI",
-        hawaiiProjection(),
-        akRef ? akRight + 24 : FIT_PAD,
-        width * 0.12
-      );
-  }
-  const conusFit = resolved.projection === "albers-usa" && !!usLayer;
-  const classifyExtent = conusFit ? geoBounds(fitTarget) : resolved.extent;
-  const dLonSpan = classifyExtent[1][0] - classifyExtent[0][0];
-  const dLatSpan = classifyExtent[1][1] - classifyExtent[0][1];
-  const isGlobalView = dLonSpan >= 270 || dLatSpan >= 130;
-  const vLonCenter = (classifyExtent[0][0] + classifyExtent[1][0]) / 2;
-  const normLon = (lon) => {
-    let L = lon;
-    while (L < vLonCenter - 180) L += 360;
-    while (L > vLonCenter + 180) L -= 360;
-    return L;
-  };
-  const ringOverlapsView = (ring) => {
-    let loMin = Infinity, loMax = -Infinity, rawMin = Infinity, rawMax = -Infinity;
-    const lons = [];
-    for (const [rawLon] of ring) {
-      const lon = normLon(rawLon);
-      lons.push(lon);
-      if (lon < loMin) loMin = lon;
-      if (lon > loMax) loMax = lon;
-      if (rawLon < rawMin) rawMin = rawLon;
-      if (rawLon > rawMax) rawMax = rawLon;
+      t.stream.point(x, y);
+      t._ex = x;
+      t._ey = y;
+      t._has = true;
+      t._pending = false;
+    },
+    lineEnd() {
+      const t = this;
+      if (t._pending) t.stream.point(t._lx, t._ly);
+      t._pending = false;
+      t.stream.lineEnd();
     }
-    lons.sort((a, b) => a - b);
-    let maxGap = 0;
-    for (let i = 1; i < lons.length; i++)
-      maxGap = Math.max(maxGap, lons[i] - lons[i - 1]);
-    if (lons.length > 1)
-      maxGap = Math.max(maxGap, lons[0] + 360 - lons[lons.length - 1]);
-    const occupiedArc = 360 - maxGap;
-    if (occupiedArc > 270) return false;
-    if (rawMax - rawMin > 180 && occupiedArc < 90) return false;
-    let px0 = Infinity, py0 = Infinity, px1 = -Infinity, py1 = -Infinity, anyFinite = false;
-    for (const [lon, lat] of ring) {
+  });
+}
+var RAMP_FLOOR = 15;
+var R_DEFAULT = 6;
+var R_MIN = 4;
+var R_MAX = 22;
+var POI_FILL_OPACITY_MAX = 0.92;
+var POI_FILL_OPACITY_MIN = 0.55;
+var WORLD_LABEL_ANCHORS = {
+  US: [-98.5, 39.5],
+  // CONUS geographic centre (near Lebanon, Kansas)
+  // Russia crosses the antimeridian (Chukotka at ~170°W), so on a non-global
+  // (e.g. Europe) projection its geometry smears across the whole frame and the
+  // area-weighted centroid lands mid-map (over Europe) — useless as a label
+  // anchor. Pin it to European Russia (~Volga) so a Europe view labels visible
+  // western Russia on its eastern margin; on a world view this still sits over
+  // Russian land. (See the curated-anchor smear-gate bypass in context-labels.)
+  RU: [45, 58]
+};
+var MAX_CLUSTER_EXTENT_FACTOR = 0.18;
+var MAX_COLUMN_ROWS = 7;
+var REGION_LABEL_HALO_RATIO = 4.5;
+var LAND_TINT_LIGHT = 12;
+var LAND_TINT_DARK = 24;
+var TAG_TINT_LIGHT = 60;
+var TAG_TINT_DARK = 68;
+var WATER_TINT_LIGHT = 24;
+var WATER_TINT_DARK = 24;
+var RIVER_WIDTH = 1.3;
+var COMPACT_WIDTH_PX = 480;
+var RELIEF_MIN_AREA = 12;
+var RELIEF_MIN_DIM = 2;
+var RELIEF_HATCH_SPACING = 1.5;
+var RELIEF_HATCH_WIDTH = 0.2;
+var RELIEF_HATCH_STRENGTH = 26;
+var COASTLINE_RING_COUNT = 5;
+var COASTLINE_D0 = 16e-4;
+var COASTLINE_STEP = 28e-4;
+var COASTLINE_THICKNESS = 14e-4;
+var COASTLINE_OPACITY_NEAR = 0.5;
+var COASTLINE_OPACITY_FAR = 0.1;
+var COASTLINE_MIN_EXTENT = 6e-4;
+var COASTLINE_MIN_EXTENT_GLOBAL = 6e-4;
+var COASTLINE_STROKE_MIX = 32;
+var FOREIGN_TINT_LIGHT = 30;
+var FOREIGN_TINT_DARK = 62;
+var MUTED_FOREIGN_LIGHT = 28;
+var MUTED_FOREIGN_DARK = 16;
+var COLO_R = 9;
+var GOLDEN_ANGLE = 2.399963229728653;
+var STACK_OVERLAP = 1;
+var STACK_RING_MAX = 8;
+var STACK_RING_GAP = 4;
+function geomObject(topo) {
+  const key = Object.keys(topo.objects)[0];
+  return topo.objects[key];
+}
+var decodeCache = /* @__PURE__ */ new WeakMap();
+function mergeFeatures(a, b) {
+  const polysOf = (f) => {
+    const g = f.geometry;
+    if (!g) return null;
+    if (g.type === "Polygon") return [g.coordinates];
+    if (g.type === "MultiPolygon") return g.coordinates;
+    return null;
+  };
+  const pa = polysOf(a);
+  const pb = polysOf(b);
+  if (!pa || !pb) return a;
+  return {
+    ...a,
+    geometry: { type: "MultiPolygon", coordinates: [...pa, ...pb] }
+  };
+}
+function decodeLayer(topo) {
+  const cached = decodeCache.get(topo);
+  if (cached) return cached;
+  const out = /* @__PURE__ */ new Map();
+  for (const g of geomObject(topo).geometries) {
+    const f = feature(topo, g);
+    if (!f.geometry) continue;
+    const tagged = { ...f, id: g.id };
+    const existing = out.get(g.id);
+    out.set(g.id, existing ? mergeFeatures(existing, tagged) : tagged);
+  }
+  decodeCache.set(topo, out);
+  return out;
+}
+function countryLabelPositions(args) {
+  const { geometry, bounds, project, width, height, curated } = args;
+  const w0 = bounds[0][0];
+  const s0 = bounds[0][1];
+  const e0 = bounds[1][0];
+  const n0 = bounds[1][1];
+  if (![w0, s0, e0, n0].every(Number.isFinite) || e0 <= w0 || n0 <= s0) {
+    return mkCurated(curated, project);
+  }
+  const N = COUNTRY_POS_GRID;
+  const onLand = [];
+  const kept = [];
+  for (let i = 0; i < N; i++) {
+    onLand[i] = [];
+    const lon = w0 + (i + 0.5) / N * (e0 - w0);
+    for (let j = 0; j < N; j++) {
+      const lat = s0 + (j + 0.5) / N * (n0 - s0);
+      const land = pointInGeometry(geometry, lon, lat);
+      onLand[i][j] = land;
+      if (!land) continue;
       const p = project(lon, lat);
       if (!p || !Number.isFinite(p[0]) || !Number.isFinite(p[1])) continue;
-      anyFinite = true;
-      if (p[0] < px0) px0 = p[0];
-      if (p[0] > px1) px1 = p[0];
-      if (p[1] < py0) py0 = p[1];
-      if (p[1] > py1) py1 = p[1];
+      if (p[0] < 0 || p[0] > width || p[1] < 0 || p[1] > height) continue;
+      kept.push({ i, j, lon, lat, sx: p[0], sy: p[1] });
     }
-    if (!anyFinite) return false;
-    return !(px1 < 0 || px0 > width || py1 < 0 || py0 > height);
+  }
+  if (!kept.length) return mkCurated(curated, project);
+  const cx = kept.reduce((s, c) => s + c.sx, 0) / kept.length;
+  const cy = kept.reduce((s, c) => s + c.sy, 0) / kept.length;
+  const interiorness = (c) => {
+    let n = 0;
+    for (let di = -1; di <= 1; di++)
+      for (let dj = -1; dj <= 1; dj++) {
+        if (di === 0 && dj === 0) continue;
+        const ni = c.i + di;
+        const nj = c.j + dj;
+        if (ni >= 0 && ni < N && nj >= 0 && nj < N && onLand[ni][nj]) n++;
+      }
+    return n;
   };
-  const cullFeatureToView = (f) => {
-    if (isGlobalView) return f;
-    const g = f.geometry;
-    if (!g) return f;
-    if (g.type === "Polygon") {
-      const ring = g.coordinates[0];
-      return ringOverlapsView(ring) ? f : null;
+  const dist2ToCentre = (c) => (c.sx - cx) ** 2 + (c.sy - cy) ** 2;
+  const centreLon = kept.reduce((s, c) => s + c.lon, 0) / kept.length;
+  const centreLat = kept.reduce((s, c) => s + c.lat, 0) / kept.length;
+  const centreScreen = project(centreLon, centreLat);
+  const lead = pointInGeometry(geometry, centreLon, centreLat) && centreScreen && Number.isFinite(centreScreen[0]) && Number.isFinite(centreScreen[1]) && centreScreen[0] >= 0 && centreScreen[0] <= width && centreScreen[1] >= 0 && centreScreen[1] <= height ? [
+    {
+      lonLat: [centreLon, centreLat],
+      screen: [centreScreen[0], centreScreen[1]]
     }
-    if (g.type === "MultiPolygon") {
-      const polys = g.coordinates;
-      const keep = polys.filter(
-        (p) => ringOverlapsView(p[0])
-      );
-      if (!keep.length) return null;
-      if (keep.length === polys.length) return f;
-      return { ...f, geometry: { ...g, coordinates: keep } };
+  ] : [];
+  const grid = [...kept].sort(
+    (a, b) => interiorness(b) - interiorness(a) || dist2ToCentre(a) - dist2ToCentre(b)
+  ).map((c) => ({
+    lonLat: [c.lon, c.lat],
+    screen: [c.sx, c.sy]
+  }));
+  const curatedPos = curated ? mkCurated(curated, project) : [];
+  return [...curatedPos, ...lead, ...grid].slice(0, MAX_COUNTRY_POSITIONS);
+}
+function mkCurated(curated, project) {
+  if (!curated) return [];
+  const p = project(curated[0], curated[1]);
+  if (!p || !Number.isFinite(p[0]) || !Number.isFinite(p[1])) return [];
+  return [{ lonLat: [curated[0], curated[1]], screen: [p[0], p[1]] }];
+}
+var usConusProjection = () => geoConicEqualArea().parallels([29.5, 45.5]).rotate([96, 0]);
+var alaskaProjection = () => geoConicEqualArea().rotate([154, 0]).center([-2, 58.5]).parallels([55, 65]);
+var hawaiiProjection = () => geoMercator();
+function projectionFor(family, extent) {
+  switch (family) {
+    case "albers-usa":
+      return usConusProjection();
+    case "conic-equal-area": {
+      const s = extent[0][1];
+      const n = extent[1][1];
+      return geoConicEqualArea().parallels([s + (n - s) / 6, s + (n - s) * 5 / 6]).center([0, (s + n) / 2]);
+    }
+    case "mercator":
+      return geoMercator();
+    case "equal-earth":
+      return geoEqualEarth();
+    case "equirectangular":
+      return geoEquirectangular();
+    case "natural-earth":
+      return geoNaturalEarth1();
+    default:
+      return geoEquirectangular();
+  }
+}
+var INSET_STATES = /* @__PURE__ */ new Set(["US-AK", "US-HI"]);
+var inAlaska = (lon, lat) => lat >= 51 && (lon <= -129 || lon >= 172);
+var inHawaii = (lon, lat) => lat >= 18 && lat <= 23 && lon >= -161 && lon <= -154;
+var FOREIGN_BORDER = {
+  CA: [
+    "US-AK",
+    "US-WA",
+    "US-ID",
+    "US-MT",
+    "US-ND",
+    "US-MN",
+    "US-MI",
+    "US-NY",
+    "US-VT",
+    "US-NH",
+    "US-ME"
+  ],
+  MX: ["US-CA", "US-AZ", "US-NM", "US-TX"]
+};
+var US_NON_CONUS = /* @__PURE__ */ new Set([
+  "US-AK",
+  "US-HI",
+  "US-AS",
+  "US-GU",
+  "US-MP",
+  "US-PR",
+  "US-VI"
+]);
+function mapBackgroundColor(palette, isDark = false, _dataActive = false) {
+  return mix(
+    palette.colors.blue,
+    palette.bg,
+    isDark ? WATER_TINT_DARK : WATER_TINT_LIGHT
+  );
+}
+function mapNeutralLandColor(palette, isDark, _dataActive = false) {
+  return mix(
+    palette.colors.green,
+    palette.bg,
+    isDark ? LAND_TINT_DARK : LAND_TINT_LIGHT
+  );
+}
+function buildMapProjection(resolved, data) {
+  const wantsUsStates = resolved.basemaps.subdivisions.includes("us-states");
+  const usCrisp = (resolved.projection === "albers-usa" || resolved.projection === "mercator") && wantsUsStates && !!data.naLand;
+  const worldTopo = usCrisp ? data.worldDetail : resolved.basemaps.world === "detail" ? data.worldDetail : data.worldCoarse;
+  const worldLayer = new Map(decodeLayer(worldTopo));
+  if (usCrisp && data.naLand) {
+    const [nbW, nbS, nbE, nbN] = [-140, 10, -52, 66];
+    const crisp = decodeLayer(data.naLand);
+    for (const [iso, cf] of crisp) {
+      const base = worldLayer.get(iso);
+      if (!base) continue;
+      const [[bw, bs], [be, bn]] = geoBounds(base);
+      if (bw >= nbW && be <= nbE && bs >= nbS && bn <= nbN)
+        worldLayer.set(iso, { ...cf, properties: base.properties });
+    }
+  }
+  const usLayer = wantsUsStates ? decodeLayer(data.usStates) : null;
+  const extentOutline = () => {
+    const [[w, s], [e, n]] = resolved.extent;
+    const N = 16;
+    const coords = [];
+    for (let i = 0; i <= N; i++) {
+      const t = i / N;
+      const lon = w + (e - w) * t;
+      const lat = s + (n - s) * t;
+      coords.push([lon, s], [lon, n], [w, lat], [e, lat]);
     }
-    return f;
+    return {
+      type: "Feature",
+      properties: {},
+      geometry: { type: "MultiPoint", coordinates: coords }
+    };
   };
-  const SEAM_SLIVER_MAX_SPAN = 100;
-  const ringIsFrameFiller = (ring) => {
-    const lons = ring.map(([lon]) => lon).sort((a, b) => a - b);
-    if (lons.length < 2) return false;
-    let maxGap = -1;
-    let gapIdx = 0;
-    for (let i = 1; i < lons.length; i++) {
-      const g = lons[i] - lons[i - 1];
-      if (g > maxGap) {
-        maxGap = g;
-        gapIdx = i;
+  let fitFeatures;
+  if (resolved.projection === "albers-usa" && usLayer) {
+    fitFeatures = [...usLayer.entries()].filter(([iso]) => !US_NON_CONUS.has(iso)).map(([, f]) => f);
+    const neighborPoints = resolved.pois.filter((p) => !inAlaska(p.lon, p.lat) && !inHawaii(p.lon, p.lat)).map((p) => [p.lon, p.lat]);
+    if (neighborPoints.length > 0) {
+      fitFeatures.push({
+        type: "Feature",
+        properties: {},
+        geometry: { type: "MultiPoint", coordinates: neighborPoints }
+      });
+    }
+    for (const r of resolved.regions) {
+      if (r.layer === "country" && (r.iso === "CA" || r.iso === "MX")) {
+        const cf = worldLayer.get(r.iso);
+        if (cf) fitFeatures.push(cf);
       }
     }
-    const wrapGap = lons[0] + 360 - lons[lons.length - 1];
-    if (wrapGap >= maxGap) return false;
-    const span = 360 - maxGap;
-    const east = lons[gapIdx - 1] + 360;
-    return east > 180 && span < SEAM_SLIVER_MAX_SPAN;
+  } else {
+    fitFeatures = [extentOutline()];
+  }
+  const fitTarget = { type: "FeatureCollection", features: fitFeatures };
+  const projection = projectionFor(resolved.projection, resolved.extent);
+  if (resolved.projection !== "albers-usa") {
+    let centerLon = (resolved.extent[0][0] + resolved.extent[1][0]) / 2;
+    if (centerLon > 180) centerLon -= 360;
+    projection.rotate([-centerLon, 0]);
+  }
+  const fitGB = geoBounds(fitTarget);
+  const fitIsGlobal = fitGB[1][0] - fitGB[0][0] >= 270 || fitGB[1][1] - fitGB[0][1] >= 130;
+  return {
+    projection,
+    fitTarget,
+    fitIsGlobal,
+    worldLayer,
+    usLayer,
+    usCrisp,
+    wantsUsStates,
+    worldTopo
   };
-  const dropFrameFillers = (f) => {
-    const g = f.geometry;
-    if (!g) return f;
-    if (g.type === "Polygon") {
-      const ring = g.coordinates[0];
-      return ringIsFrameFiller(ring) ? null : f;
+}
+function parsePathRings(d) {
+  const rings = [];
+  let cur = [];
+  const re = /([MLZ])([^MLZ]*)/g;
+  let m;
+  while (m = re.exec(d)) {
+    if (m[1] === "Z") {
+      if (cur.length) rings.push(cur);
+      cur = [];
+      continue;
     }
-    if (g.type === "MultiPolygon") {
-      const polys = g.coordinates;
-      const keep = polys.filter(
-        (p) => !ringIsFrameFiller(p[0])
-      );
-      if (!keep.length) return null;
-      if (keep.length === polys.length) return f;
-      return { ...f, geometry: { ...g, coordinates: keep } };
+    if (m[1] === "M" && cur.length) {
+      rings.push(cur);
+      cur = [];
     }
-    return f;
+    const nums = m[2].split(/[ ,]+/).map(Number);
+    for (let i = 0; i + 1 < nums.length; i += 2) {
+      const x = nums[i];
+      const y = nums[i + 1];
+      if (Number.isFinite(x) && Number.isFinite(y)) cur.push([x, y]);
+    }
+  }
+  if (cur.length) rings.push(cur);
+  return rings;
+}
+function dropAntimeridianWrapSlivers(d, width, height) {
+  const rings = parsePathRings(d);
+  if (rings.length <= 1) return d;
+  const eps = 0.75;
+  const minArea = 3e-3 * width * height;
+  const ringArea = (r) => {
+    let s = 0;
+    for (let i = 0; i < r.length; i++) {
+      const a = r[i];
+      const b = r[(i + 1) % r.length];
+      s += a[0] * b[1] - b[0] * a[1];
+    }
+    return Math.abs(s) / 2;
   };
-  const regions = [];
-  const pushRegionLayer = (layerFeatures, layerKind, shouldCull) => {
-    for (const [iso, f] of layerFeatures) {
-      if (layerKind === "us-state" && usContext && resolved.projection === "albers-usa" && INSET_STATES.has(iso))
-        continue;
-      if (layerKind === "country" && usContext && iso === "US") continue;
-      if (layerKind === "country" && iso === "AQ" && !regionById.has("AQ"))
-        continue;
-      const r = regionById.get(iso);
-      const geoK = layerKind + ":" + iso;
-      let geo = regionGeo.get(geoK);
-      if (geo === void 0) {
-        const viewF = shouldCull ? cullFeatureToView(f) : dropFrameFillers(f);
-        if (!viewF) {
-          regionGeo.set(geoK, null);
-          continue;
-        }
-        const raw = path(viewF) ?? "";
-        const d0 = fitIsGlobal ? dropAntimeridianWrapSlivers(raw, width, height) : raw;
-        if (!d0) {
-          regionGeo.set(geoK, null);
-          continue;
-        }
-        const anchor = WORLD_LABEL_ANCHORS[iso];
-        const cc = anchor ? project(anchor[0], anchor[1]) : path.centroid(viewF);
-        const ok = cc != null && Number.isFinite(cc[0]) && Number.isFinite(cc[1]);
-        geo = { d: d0, cx: ok ? cc[0] : void 0, cy: ok ? cc[1] : void 0 };
-        regionGeo.set(geoK, geo);
-      } else if (geo === null) {
-        continue;
-      }
-      const d = geo.d;
-      const hasCentroid = geo.cx !== void 0 && geo.cy !== void 0;
-      const isThisLayer = r?.layer === layerKind;
-      const isForeign = layerKind === "country" && usContext && iso !== "US";
-      const baseFill = isForeign ? foreignFill : neutralFill;
-      let fill = colorizeActive ? colorByIso.get(iso) ?? baseFill : baseFill;
-      let label;
-      let lineNumber = -1;
-      let layer = "base";
-      if (isThisLayer) {
-        fill = regionFill(r);
-        lineNumber = r.lineNumber;
-        layer = layerKind;
-        label = r.name;
-      } else {
-        label = f.properties?.name;
-      }
-      regions.push({
-        id: iso,
-        d,
-        fill,
-        stroke: colorizeActive ? colorizeStroke(fill) : regionStroke,
-        lineNumber,
-        layer,
-        ...label !== void 0 && { label },
-        ...hasCentroid && { labelX: geo.cx, labelY: geo.cy },
-        ...isThisLayer && r.value !== void 0 && { value: r.value },
-        ...isThisLayer && Object.keys(r.tags).length > 0 && { tags: r.tags }
-      });
+  const areas = rings.map(ringArea);
+  const maxArea = Math.max(...areas);
+  const onVEdge = (a, b) => Math.abs(a[0]) <= eps && Math.abs(b[0]) <= eps || Math.abs(a[0] - width) <= eps && Math.abs(b[0] - width) <= eps;
+  let dropped = false;
+  const kept = rings.filter((r, idx) => {
+    if (areas[idx] >= maxArea || areas[idx] >= minArea) return true;
+    const touches = r.some((p, i) => onVEdge(p, r[(i + 1) % r.length]));
+    if (touches) {
+      dropped = true;
+      return false;
+    }
+    return true;
+  });
+  if (!dropped) return d;
+  return kept.map(
+    (r) => r.map((p, i) => (i ? "L" : "M") + p[0] + "," + p[1]).join("") + "Z"
+  ).join("");
+}
+function albersSkewFallback(resolved, data, width, height) {
+  if (resolved.projection !== "albers-usa") return false;
+  if (!resolved.basemaps.subdivisions.includes("us-states")) return false;
+  if (!(width > 0) || !(height > 0)) return false;
+  const akRef = resolved.regions.some((r) => r.iso === "US-AK") || resolved.pois.some((p) => inAlaska(p.lon, p.lat));
+  const hiRef = resolved.regions.some((r) => r.iso === "US-HI") || resolved.pois.some((p) => inHawaii(p.lon, p.lat));
+  if (akRef || hiRef) return false;
+  const { projection, fitTarget, usLayer } = buildMapProjection(resolved, data);
+  if (!usLayer || ![...usLayer.keys()].some((iso) => !US_NON_CONUS.has(iso)))
+    return false;
+  projection.fitSize([1e3, 1e3], fitTarget);
+  const b = geoPath2(projection).bounds(fitTarget);
+  const conusAspect = (b[1][0] - b[0][0]) / (b[1][1] - b[0][1]);
+  if (!(conusAspect > 0)) return false;
+  const canvasAspect = width / height;
+  const skew = Math.max(canvasAspect / conusAspect, conusAspect / canvasAspect);
+  return skew > ALBERS_SKEW_MAX;
+}
+var REGION_GEO_MEMO = /* @__PURE__ */ new WeakMap();
+var REGION_GEO_MAX_FITS = 8;
+function regionGeoBucket(resolved, projKey) {
+  let byFit = REGION_GEO_MEMO.get(resolved);
+  if (!byFit) {
+    byFit = /* @__PURE__ */ new Map();
+    REGION_GEO_MEMO.set(resolved, byFit);
+  }
+  let bucket = byFit.get(projKey);
+  if (!bucket) {
+    bucket = /* @__PURE__ */ new Map();
+    byFit.set(projKey, bucket);
+    if (byFit.size > REGION_GEO_MAX_FITS) {
+      const oldest = byFit.keys().next().value;
+      if (oldest !== void 0) byFit.delete(oldest);
     }
+  }
+  return bucket;
+}
+function layoutMap(resolvedIn, data, size, opts) {
+  const { palette, isDark } = opts;
+  const { width, height } = size;
+  let resolved = resolvedIn;
+  if (albersSkewFallback(resolved, data, width, height)) {
+    resolved = { ...resolved, projection: "conic-equal-area" };
+  }
+  const {
+    projection,
+    fitTarget,
+    fitIsGlobal,
+    worldLayer,
+    usLayer,
+    usCrisp,
+    worldTopo
+  } = buildMapProjection(resolved, data);
+  const usContext = usLayer !== null;
+  const regionStroke = isDark ? mix(palette.border, palette.text, 65) : mix(palette.text, palette.bg, 78);
+  const values = resolved.regions.filter((r) => r.value !== void 0).map((r) => r.value);
+  const rampMin = values.length > 0 ? Math.min(...values) : 0;
+  const rampMax = Math.max(...values);
+  const rampHue = resolveColor(resolved.directives.regionMetricColor ?? "", palette) ?? palette.colors.red;
+  const rampLow = resolved.directives.regionMetricLowColor ? resolveColor(resolved.directives.regionMetricLowColor, palette) ?? void 0 : void 0;
+  const hasRamp = values.length > 0;
+  const VALUE_NAME = hasRamp ? resolved.directives.regionMetric?.trim() || "Value" : null;
+  const matchColorGroup = (v) => {
+    const lv = v.trim().toLowerCase();
+    if (lv === "none") return null;
+    if (lv === VALUE_NAME?.toLowerCase()) return VALUE_NAME;
+    const tg = resolved.tagGroups.find((g) => g.name.toLowerCase() === lv);
+    return tg ? tg.name : v;
   };
-  pushRegionLayer(worldLayer, "country", !isGlobalView);
-  if (usLayer) pushRegionLayer(usLayer, "us-state", !conusFit && !isGlobalView);
-  const lakesTopo = usCrisp && data.naLakes ? data.naLakes : data.lakes;
-  if (lakesTopo) {
-    for (const [, f] of decodeLayer(lakesTopo)) {
-      const viewF = isGlobalView ? dropFrameFillers(f) : cullFeatureToView(f);
-      if (!viewF) continue;
-      const d = path(viewF) ?? "";
-      if (!d) continue;
-      regions.push({
-        id: "lake",
-        d,
-        fill: water,
-        stroke: lakeStroke,
-        lineNumber: -1,
-        layer: "base"
-      });
-    }
+  const fillGroupNames = /* @__PURE__ */ new Set();
+  for (const g of resolved.tagGroups) {
+    const k = g.name.toLowerCase();
+    if (resolved.regions.some((r) => r.tags[k]) || resolved.pois.some((p) => p.tags[k]))
+      fillGroupNames.add(g.name);
   }
-  const pointInRings = (px, py, rings) => {
-    let inside = false;
-    for (const ring of rings) {
-      for (let i = 0, j = ring.length - 1; i < ring.length; j = i++) {
-        const [xi, yi] = ring[i];
-        const [xj, yj] = ring[j];
-        if (yi > py !== yj > py && px < (xj - xi) * (py - yi) / (yj - yi) + xi)
-          inside = !inside;
-      }
+  const firstFillGroup = resolved.tagGroups.find((g) => fillGroupNames.has(g.name))?.name ?? null;
+  const override = opts.activeGroup;
+  let activeGroup;
+  if (override !== void 0) {
+    activeGroup = override === null ? null : matchColorGroup(override);
+  } else if (resolved.directives.activeTag !== void 0) {
+    activeGroup = matchColorGroup(resolved.directives.activeTag);
+  } else {
+    activeGroup = VALUE_NAME ?? firstFillGroup ?? resolved.tagGroups[0]?.name ?? null;
+  }
+  const activeIsScore = VALUE_NAME !== null && activeGroup === VALUE_NAME;
+  const mutedBasemap = activeIsScore || activeGroup !== null && fillGroupNames.has(activeGroup);
+  const neutralFill = mapNeutralLandColor(palette, isDark, mutedBasemap);
+  const water = mapBackgroundColor(palette, isDark, mutedBasemap);
+  const lakeStroke = mix(regionStroke, water, 45);
+  const foreignFill = mix(
+    palette.colors.gray,
+    palette.bg,
+    mutedBasemap ? isDark ? MUTED_FOREIGN_DARK : MUTED_FOREIGN_LIGHT : isDark ? FOREIGN_TINT_DARK : FOREIGN_TINT_LIGHT
+  );
+  const contrastFloorTone = (tone, ...substrates) => {
+    const clears = (t) => substrates.every((s) => contrastRatio(t, s) >= REGION_LABEL_HALO_RATIO);
+    if (clears(tone)) return tone;
+    for (let s = 10; s <= 100; s += 10) {
+      const t = mix(palette.text, tone, s);
+      if (clears(t)) return t;
     }
-    return inside;
+    return palette.text;
   };
-  const fillHitTargets = [...regions, ...insetRegions].map((r) => {
-    const rings = parsePathRings(r.d);
-    let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
-    for (const ring of rings)
-      for (const p of ring) {
-        if (p[0] < minX) minX = p[0];
-        if (p[0] > maxX) maxX = p[0];
-        if (p[1] < minY) minY = p[1];
-        if (p[1] > maxY) maxY = p[1];
+  const backdropLandTone = contrastFloorTone(
+    palette.textMuted,
+    neutralFill,
+    water
+  );
+  const backdropWaterTone = contrastFloorTone(
+    mix(palette.colors.blue, palette.textMuted, 50),
+    water,
+    neutralFill
+  );
+  const hasDirectColor = resolved.regions.some((r) => r.color !== void 0);
+  const colorizeActive = resolved.directives.noColorize !== true && !hasRamp && !hasDirectColor && fillGroupNames.size === 0;
+  const colorByIso = /* @__PURE__ */ new Map();
+  if (colorizeActive) {
+    const adjacency = /* @__PURE__ */ new Map();
+    const addEdges = (src) => {
+      for (const [iso, ns] of src) {
+        const cur = adjacency.get(iso);
+        if (cur) cur.push(...ns);
+        else adjacency.set(iso, [...ns]);
       }
-    r.bbox = [minX, minY, maxX, maxY];
-    r.rings = rings;
-    return { fill: r.fill, rings, minX, minY, maxX, maxY };
-  });
-  const fillAt = (x, y) => {
-    let hit = water;
-    for (const t of fillHitTargets) {
-      if (x < t.minX || x > t.maxX || y < t.minY || y > t.maxY) continue;
-      if (pointInRings(x, y, t.rings)) hit = t.fill;
-    }
-    return hit;
-  };
-  const labelOnFill = (fill) => {
-    const color = contrastRatio(fill, palette.textOnFillDark) >= contrastRatio(fill, palette.textOnFillLight) ? palette.textOnFillDark : palette.textOnFillLight;
-    const haloColor = color === palette.textOnFillLight ? palette.textOnFillDark : palette.textOnFillLight;
-    return {
-      color,
-      halo: contrastRatio(fill, color) < REGION_LABEL_HALO_RATIO,
-      haloColor
-    };
-  };
-  const reliefAllowed = resolved.directives.noRelief !== true;
-  const relief = [];
-  let reliefHatch = null;
-  if (reliefAllowed && data.mountainRanges) {
-    for (const [, f] of decodeLayer(data.mountainRanges)) {
-      const viewF = isGlobalView ? dropFrameFillers(f) : cullFeatureToView(f);
-      if (!viewF) continue;
-      const area = path.area(viewF);
-      if (!Number.isFinite(area) || area < RELIEF_MIN_AREA) continue;
-      const box = path.bounds(viewF);
-      if (box[1][0] - box[0][0] < RELIEF_MIN_DIM || box[1][1] - box[0][1] < RELIEF_MIN_DIM)
-        continue;
-      const d = path(viewF) ?? "";
-      if (!d) continue;
-      relief.push({ d });
-    }
-    if (relief.length) {
-      const darkTone = isDark ? palette.bg : palette.text;
-      const lightTone = isDark ? palette.text : palette.bg;
-      const reliefLandRef = colorizeActive ? isDark ? palette.surface : palette.bg : neutralFill;
-      const landLum = relativeLuminance(reliefLandRef);
-      const tone = Math.abs(landLum - relativeLuminance(darkTone)) > 0.04 ? darkTone : lightTone;
-      reliefHatch = {
-        color: mix(tone, reliefLandRef, RELIEF_HATCH_STRENGTH),
-        spacing: RELIEF_HATCH_SPACING,
-        width: RELIEF_HATCH_WIDTH
-      };
-    }
-  }
-  let coastlineStyle = null;
-  if (resolved.directives.noCoastline !== true) {
-    const minDim = Math.min(width, height);
-    coastlineStyle = {
-      color: mix(regionStroke, water, COASTLINE_STROKE_MIX),
-      // N equal-width rings: distance steps outward by COASTLINE_STEP; opacity
-      // fades linearly from NEAR (innermost) to FAR (outermost).
-      lines: Array.from({ length: COASTLINE_RING_COUNT }, (_, k) => ({
-        d: (COASTLINE_D0 + k * COASTLINE_STEP) * minDim,
-        thickness: COASTLINE_THICKNESS * minDim,
-        opacity: COASTLINE_OPACITY_NEAR + (COASTLINE_OPACITY_FAR - COASTLINE_OPACITY_NEAR) * k / (COASTLINE_RING_COUNT - 1)
-      })),
-      minExtent: (isGlobalView ? COASTLINE_MIN_EXTENT_GLOBAL : COASTLINE_MIN_EXTENT) * minDim
     };
-  }
-  const riverColor = mix(palette.colors.blue, water, 32);
-  const rivers = [];
-  if (data.rivers) {
-    for (const [, f] of decodeLayer(data.rivers)) {
-      const viewF = isGlobalView ? dropFrameFillers(f) : cullFeatureToView(f);
-      if (!viewF) continue;
-      const d = path(viewF) ?? "";
-      if (!d) continue;
-      rivers.push({ d, color: riverColor, width: RIVER_WIDTH });
+    addEdges(buildAdjacency(worldTopo));
+    if (usLayer) {
+      addEdges(buildAdjacency(data.usStates));
+      for (const [country, states] of Object.entries(FOREIGN_BORDER)) {
+        const cn = adjacency.get(country);
+        if (!cn) continue;
+        for (const st of states) {
+          const sn = adjacency.get(st);
+          if (!sn) continue;
+          cn.push(st);
+          sn.push(country);
+        }
+      }
     }
+    const { byIso, huesNeeded } = assignColors(
+      [...adjacency.keys()],
+      adjacency
+    );
+    const tints = politicalTints(palette, huesNeeded, isDark);
+    for (const [iso, idx] of byIso) colorByIso.set(iso, tints[idx]);
   }
-  const sizeVals = resolved.pois.map((p) => Number(p.meta["size"])).filter((n) => Number.isFinite(n) && n > 0);
-  const sizeMin = sizeVals.length ? Math.min(...sizeVals) : 0;
-  const sizeMax = sizeVals.length ? Math.max(...sizeVals) : 0;
-  const radiusFor = (p) => {
-    const v = Number(p.meta["size"]);
-    if (!Number.isFinite(v) || v <= 0 || sizeMax <= 0) return R_DEFAULT;
-    const t = sizeMax > sizeMin ? (Math.sqrt(v) - Math.sqrt(sizeMin)) / (Math.sqrt(sizeMax) - Math.sqrt(sizeMin)) : 1;
-    return R_MIN + Math.max(0, Math.min(1, t)) * (R_MAX - R_MIN);
+  const colorizeStroke = (fill) => mix(fill, palette.text, 35);
+  const rampBase = isDark ? mix(palette.surface, palette.text, 28) : palette.bg;
+  const rampLowFloor = mix(rampHue, rampBase, RAMP_FLOOR);
+  const fillForValue = (s) => {
+    const t = rampMax > rampMin ? (s - rampMin) / (rampMax - rampMin) : 1;
+    if (rampLow !== void 0)
+      return valueRampColor(rampLow, rampHue, t, { isDark });
+    const pct = RAMP_FLOOR + Math.max(0, Math.min(1, t)) * (100 - RAMP_FLOOR);
+    return mix(rampHue, rampBase, pct);
   };
-  const fillOpacityFor = (r) => {
-    const t = Math.max(0, Math.min(1, (r - R_MIN) / (R_MAX - R_MIN)));
-    return POI_FILL_OPACITY_MAX - t * (POI_FILL_OPACITY_MAX - POI_FILL_OPACITY_MIN);
+  const tagFill = (tags, groupName) => {
+    if (!groupName) return null;
+    const group = resolved.tagGroups.find(
+      (g) => g.name.toLowerCase() === groupName.toLowerCase()
+    );
+    if (!group) return null;
+    const val = tags[tagAttrKey(group.name)] ?? group.defaultValue;
+    if (!val) return null;
+    const entry = group.entries.find(
+      (e) => e.value.toLowerCase() === val.toLowerCase()
+    );
+    if (!entry?.color) return null;
+    return mix(
+      entry.color,
+      palette.bg,
+      isDark ? TAG_TINT_DARK : TAG_TINT_LIGHT
+    );
   };
-  const poiFill = (p) => {
-    const directHex = p.color ? resolveColor(p.color, palette) : null;
-    if (directHex)
-      return { fill: directHex, stroke: mix(directHex, palette.text, 18) };
-    for (const group of resolved.tagGroups) {
-      const val = p.tags[tagAttrKey(group.name)];
-      if (!val) continue;
-      const entry = group.entries.find(
-        (e) => e.value.toLowerCase() === val.toLowerCase()
-      );
-      const hex = entry?.color;
-      if (hex) return { fill: hex, stroke: mix(hex, palette.text, 18) };
-    }
-    return {
-      fill: palette.colors.orange,
-      stroke: mix(palette.colors.orange, palette.text, 18)
-    };
+  const directFill = (name) => {
+    const hex = name ? resolveColor(name, palette) : null;
+    if (!hex) return null;
+    return mix(hex, palette.bg, isDark ? TAG_TINT_DARK : TAG_TINT_LIGHT);
   };
-  const lineColor = (tags) => {
-    for (const group of resolved.tagGroups) {
-      const val = tags[tagAttrKey(group.name)];
-      if (!val) continue;
-      const entry = group.entries.find(
-        (e) => e.value.toLowerCase() === val.toLowerCase()
-      );
-      if (entry?.color) return entry.color;
+  const regionFill = (r) => {
+    const direct = directFill(r.color);
+    if (direct) return direct;
+    if (activeIsScore) {
+      return r.value !== void 0 ? fillForValue(r.value) : neutralFill;
     }
-    return null;
+    if (colorizeActive) return (r.iso && colorByIso.get(r.iso)) ?? neutralFill;
+    return tagFill(r.tags, activeGroup) ?? neutralFill;
   };
-  const routeNumberById = /* @__PURE__ */ new Map();
-  const originIds = /* @__PURE__ */ new Set();
-  for (const rt of resolved.routes) {
-    rt.stopIds.forEach((id, i) => {
-      if (i === 0) originIds.add(id);
-      if (!routeNumberById.has(id)) routeNumberById.set(id, i + 1);
-    });
+  const regionById = new Map(resolved.regions.map((r) => [r.iso, r]));
+  let legend = null;
+  if (!resolved.directives.noLegend) {
+    const legendTagGroups = resolved.tagGroups.map((g) => ({
+      name: g.name,
+      entries: g.entries.map((e) => ({ value: e.value, color: e.color }))
+    }));
+    if (legendTagGroups.length > 0 || hasRamp) {
+      legend = {
+        tagGroups: legendTagGroups,
+        activeGroup,
+        ...hasRamp && {
+          ramp: {
+            ...resolved.directives.regionMetric !== void 0 && {
+              metric: resolved.directives.regionMetric
+            },
+            min: rampMin,
+            max: rampMax,
+            low: rampLow ?? rampLowFloor,
+            high: rampHue
+          }
+        }
+      };
+    }
   }
-  const poiScreen = /* @__PURE__ */ new Map();
-  const pois = [];
-  const orderedPois = [...resolved.pois].sort(
-    (a, b) => a.lineNumber - b.lineNumber || (a.id < b.id ? -1 : 1)
-  );
-  const projected = [];
-  for (const p of orderedPois) {
-    const xy = project(p.lon, p.lat);
-    if (xy) projected.push({ p, xy });
+  const shownTitle = resolved.directives.noTitle ? null : resolved.title;
+  const TITLE_GAP = 16;
+  let topPad = FIT_PAD;
+  if (shownTitle && resolved.pois.length > 0) {
+    const bannerBottom = (resolved.subtitle ? TITLE_Y + TITLE_FONT_SIZE : TITLE_Y) + TITLE_FONT_SIZE / 2;
+    topPad = Math.max(FIT_PAD, bannerBottom + TITLE_GAP);
   }
-  const placePoi = (e, cx, cy, clusterId) => {
-    const { fill, stroke } = poiFill(e.p);
-    const r = radiusFor(e.p);
-    poiScreen.set(e.p.id, { cx, cy, r });
-    const num = routeNumberById.get(e.p.id);
-    pois.push({
-      id: e.p.id,
-      cx,
-      cy,
-      r,
-      fill,
-      fillOpacity: fillOpacityFor(r),
-      stroke,
-      lineNumber: e.p.lineNumber,
-      implicit: !!e.p.implicit,
-      isOrigin: originIds.has(e.p.id),
-      ...num !== void 0 && { routeNumber: num },
-      ...Object.keys(e.p.tags).length > 0 && { tags: e.p.tags },
-      ...clusterId !== void 0 && { clusterId }
+  const legendBand = mapLegendBand(legend, {
+    width,
+    mode: opts.legendMode ?? "preview",
+    hasTitle: Boolean(shownTitle),
+    hasSubtitle: Boolean(resolved.subtitle)
+  });
+  if (legendBand > topPad) topPad = legendBand;
+  const topReserved = [];
+  if (shownTitle) {
+    const lines = resolved.subtitle ? 2 : 1;
+    const tw = Math.max(
+      measureLegendText(shownTitle, TITLE_FONT_SIZE),
+      resolved.subtitle ? measureLegendText(resolved.subtitle, TITLE_FONT_SIZE) : 0
+    ) + 2 * TITLE_FONT_SIZE;
+    topReserved.push({
+      x: width / 2 - tw / 2,
+      y: TITLE_Y - TITLE_FONT_SIZE,
+      w: tw,
+      h: TITLE_FONT_SIZE * (lines + 0.5)
     });
-  };
-  const clusters = [];
-  const connected = /* @__PURE__ */ new Set();
-  for (const e of resolved.edges) {
-    connected.add(e.fromId);
-    connected.add(e.toId);
   }
-  for (const rt of resolved.routes) {
-    rt.stopIds.forEach((id) => connected.add(id));
+  const legendBox = mapLegendBox(legend, {
+    width,
+    mode: opts.legendMode ?? "preview",
+    hasTitle: Boolean(shownTitle),
+    hasSubtitle: Boolean(resolved.subtitle)
+  });
+  if (legendBox)
+    topReserved.push({
+      x: legendBox.x,
+      y: legendBox.y,
+      w: legendBox.width,
+      h: legendBox.height
+    });
+  const reserve = opts._calloutReserve;
+  const fitLeft = FIT_PAD + (reserve?.left ?? 0);
+  const fitRight = width - FIT_PAD - (reserve?.right ?? 0);
+  const fitTop = topPad + (reserve?.top ?? 0);
+  const fitBottom = height - FIT_PAD - (reserve?.bottom ?? 0);
+  const fitBox = [
+    [fitLeft, fitTop],
+    [Math.max(fitLeft + 1, fitRight), Math.max(fitTop + 1, fitBottom)]
+  ];
+  projection.fitExtent(fitBox, fitTarget);
+  if (!fitIsGlobal && resolved.projection !== "albers-usa" && resolved.regions.length > 0) {
+    let yMin = Infinity;
+    let yMax = -Infinity;
+    for (const r of resolved.regions) {
+      const bb = r.iso ? featureBboxPrimary(data.worldCoarse, r.iso) : null;
+      if (!bb) continue;
+      for (const lon of [bb[0][0], bb[1][0]]) {
+        for (const lat of [bb[0][1], bb[1][1]]) {
+          const p = projection([lon, lat]);
+          if (p && Number.isFinite(p[1])) {
+            if (p[1] < yMin) yMin = p[1];
+            if (p[1] > yMax) yMax = p[1];
+          }
+        }
+      }
+    }
+    if (yMin < yMax) {
+      const boxTop = fitTop;
+      const boxBottom = fitBottom;
+      let dy = (boxTop + boxBottom) / 2 - (yMin + yMax) / 2;
+      const minDy = boxTop - yMin;
+      const maxDy = boxBottom - yMax;
+      if (minDy <= maxDy) dy = Math.max(minDy, Math.min(maxDy, dy));
+      const [tx, ty] = projection.translate();
+      projection.translate([tx, ty + dy]);
+    }
   }
-  const radiusOf = (e) => radiusFor(e.p);
-  for (const e of projected) {
-    if (connected.has(e.p.id)) placePoi(e, e.xy[0], e.xy[1]);
+  if (!fitIsGlobal && resolved.projection === "albers-usa") {
+    const cb = geoPath2(projection).bounds(fitTarget);
+    if (Number.isFinite(cb[0][1])) {
+      const slack = fitBottom - fitTop - (cb[1][1] - cb[0][1]);
+      if (slack > 0) {
+        const currentTopGap = cb[0][1] - fitTop;
+        const dy = slack * 0.3 - currentTopGap;
+        const [tx, ty] = projection.translate();
+        projection.translate([tx, ty + dy]);
+      }
+    }
   }
-  const groups = [];
-  for (const e of projected) {
-    if (connected.has(e.p.id)) continue;
-    const r = radiusOf(e);
-    const near = groups.find(
-      (g) => g.some(
-        (q) => Math.hypot(q.xy[0] - e.xy[0], q.xy[1] - e.xy[1]) < (r + radiusOf(q)) * STACK_OVERLAP
+  let path;
+  let project;
+  let stretchParams = null;
+  if (fitIsGlobal && !opts.preferContain) {
+    const cb = geoPath2(projection).bounds(fitTarget);
+    const bx0 = cb[0][0];
+    const by0 = cb[0][1];
+    const cw = cb[1][0] - bx0;
+    const ch = cb[1][1] - by0;
+    const topReserve = resolved.title && resolved.pois.length > 0 || legendBand > 0 ? topPad : 0;
+    const ox = 0;
+    const oy = topReserve;
+    const sx = cw > 0 ? width / cw : 1;
+    const sy = ch > 0 ? (height - topReserve) / ch : 1;
+    stretchParams = { sx, sy, ox, oy, bx0, by0 };
+    const stretch = (x, y) => [
+      ox + (x - bx0) * sx,
+      oy + (y - by0) * sy
+    ];
+    const baseProjection = projection;
+    const tx = geoTransform({
+      point(x, y) {
+        const [px, py] = stretch(x, y);
+        this.stream.point(px, py);
+      }
+    });
+    const thin = geoThin();
+    path = geoPath2({
+      stream: (s) => baseProjection.stream(
+        tx.stream(
+          thin.stream(s)
+        )
       )
-    );
-    if (near) near.push(e);
-    else groups.push([e]);
+    }).digits(PATH_DIGITS);
+    project = (lon, lat) => {
+      const p = baseProjection([lon, lat]);
+      return p ? stretch(p[0], p[1]) : null;
+    };
+  } else {
+    projection.clipExtent([
+      [0, 0],
+      [width, height]
+    ]);
+    const thin = geoThin();
+    path = geoPath2({
+      stream: (s) => projection.stream(
+        thin.stream(s)
+      )
+    }).digits(PATH_DIGITS);
+    project = (lon, lat) => projection([lon, lat]) ?? null;
   }
-  for (const g of groups) {
-    if (g.length === 1) {
-      placePoi(g[0], g[0].xy[0], g[0].xy[1]);
-      continue;
+  const regionGeo = regionGeoBucket(
+    resolvedIn,
+    JSON.stringify([
+      width,
+      height,
+      [
+        [-100, 40],
+        [-120, 37],
+        [-80, 40],
+        [0, 0],
+        [60, 30],
+        [-60, -30],
+        [150, 60],
+        [-150, -60],
+        [100, -40],
+        [-30, 50]
+      ].map(([lo, la]) => project(lo, la))
+    ])
+  );
+  const akRef = resolved.regions.some((r) => r.iso === "US-AK") || resolved.pois.some((p) => inAlaska(p.lon, p.lat));
+  const hiRef = resolved.regions.some((r) => r.iso === "US-HI") || resolved.pois.some((p) => inHawaii(p.lon, p.lat));
+  const { insets, insetRegions, insetLabelSeeds } = resolved.projection === "albers-usa" && usLayer && (akRef || hiRef) ? layoutInsets({
+    resolved,
+    projection,
+    usLayer,
+    worldLayer,
+    regionById,
+    width,
+    height,
+    fitPad: FIT_PAD,
+    pathDigits: PATH_DIGITS,
+    nonConus: US_NON_CONUS,
+    colorizeActive,
+    colorByIso,
+    neutralFill,
+    foreignFill,
+    regionStroke,
+    colorizeStroke,
+    regionFill,
+    alaskaProjection,
+    hawaiiProjection,
+    akRef,
+    hiRef
+  }) : { insets: [], insetRegions: [], insetLabelSeeds: [] };
+  const conusFit = resolved.projection === "albers-usa" && !!usLayer;
+  const classifyExtent = conusFit ? geoBounds(fitTarget) : resolved.extent;
+  const dLonSpan = classifyExtent[1][0] - classifyExtent[0][0];
+  const dLatSpan = classifyExtent[1][1] - classifyExtent[0][1];
+  const isGlobalView = dLonSpan >= 270 || dLatSpan >= 130;
+  const vLonCenter = (classifyExtent[0][0] + classifyExtent[1][0]) / 2;
+  const normLon = (lon) => {
+    let L = lon;
+    while (L < vLonCenter - 180) L += 360;
+    while (L > vLonCenter + 180) L -= 360;
+    return L;
+  };
+  const ringOverlapsView = (ring) => {
+    let loMin = Infinity, loMax = -Infinity, rawMin = Infinity, rawMax = -Infinity;
+    const lons = [];
+    for (const [rawLon] of ring) {
+      const lon = normLon(rawLon);
+      lons.push(lon);
+      if (lon < loMin) loMin = lon;
+      if (lon > loMax) loMax = lon;
+      if (rawLon < rawMin) rawMin = rawLon;
+      if (rawLon > rawMax) rawMax = rawLon;
     }
-    const clusterId = g[0].p.id;
-    const cx0 = g.reduce((s, e) => s + e.xy[0], 0) / g.length;
-    const cy0 = g.reduce((s, e) => s + e.xy[1], 0) / g.length;
-    const maxR = Math.max(...g.map(radiusOf));
-    const sep = 2 * maxR + STACK_RING_GAP;
-    const ringR = Math.max(
-      COLO_R,
-      sep / (2 * Math.sin(Math.PI / Math.max(g.length, 2)))
-    );
-    const positions = g.map((e, i) => {
-      if (g.length <= STACK_RING_MAX) {
-        const ang2 = -Math.PI / 2 + i * 2 * Math.PI / g.length;
-        return {
-          e,
-          mx: cx0 + Math.cos(ang2) * ringR,
-          my: cy0 + Math.sin(ang2) * ringR
-        };
-      }
-      const ang = i * GOLDEN_ANGLE;
-      const rr = ringR * Math.sqrt((i + 1) / g.length);
-      return { e, mx: cx0 + Math.cos(ang) * rr, my: cy0 + Math.sin(ang) * rr };
-    });
-    let minX = cx0 - maxR;
-    let maxX = cx0 + maxR;
-    let minY = cy0 - maxR;
-    let maxY = cy0 + maxR;
-    for (const { mx, my, e } of positions) {
-      const r = radiusOf(e);
-      minX = Math.min(minX, mx - r);
-      maxX = Math.max(maxX, mx + r);
-      minY = Math.min(minY, my - r);
-      maxY = Math.max(maxY, my + r);
+    lons.sort((a, b) => a - b);
+    let maxGap = 0;
+    for (let i = 1; i < lons.length; i++)
+      maxGap = Math.max(maxGap, lons[i] - lons[i - 1]);
+    if (lons.length > 1)
+      maxGap = Math.max(maxGap, lons[0] + 360 - lons[lons.length - 1]);
+    const occupiedArc = 360 - maxGap;
+    if (occupiedArc > 270) return false;
+    if (rawMax - rawMin > 180 && occupiedArc < 90) return false;
+    let px0 = Infinity, py0 = Infinity, px1 = -Infinity, py1 = -Infinity, anyFinite = false;
+    for (const [lon, lat] of ring) {
+      const p = project(lon, lat);
+      if (!p || !Number.isFinite(p[0]) || !Number.isFinite(p[1])) continue;
+      anyFinite = true;
+      if (p[0] < px0) px0 = p[0];
+      if (p[0] > px1) px1 = p[0];
+      if (p[1] < py0) py0 = p[1];
+      if (p[1] > py1) py1 = p[1];
     }
-    let dx = 0;
-    let dy = 0;
-    if (minX + dx < 2) dx = 2 - minX;
-    if (maxX + dx > width - 2) dx = width - 2 - maxX;
-    if (minY + dy < 2) dy = 2 - minY;
-    if (maxY + dy > height - 2) dy = height - 2 - maxY;
-    const legsOut = [];
-    for (const { e, mx, my } of positions) {
-      const fx = mx + dx;
-      const fy = my + dy;
-      placePoi(e, fx, fy, clusterId);
-      legsOut.push({ x2: fx, y2: fy, color: poiFill(e.p).fill });
+    if (!anyFinite) return false;
+    return !(px1 < 0 || px0 > width || py1 < 0 || py0 > height);
+  };
+  const cullFeatureToView = (f) => {
+    if (isGlobalView) return f;
+    const g = f.geometry;
+    if (!g) return f;
+    if (g.type === "Polygon") {
+      const ring = g.coordinates[0];
+      return ringOverlapsView(ring) ? f : null;
     }
-    clusters.push({
-      id: clusterId,
-      cx: cx0 + dx,
-      cy: cy0 + dy,
-      count: g.length,
-      hitR: ringR + maxR + 6,
-      legs: legsOut
-    });
-  }
-  const legs = [];
-  const RIM_GAP = 1.5;
-  const bowMagnitude = (mx, my, nx, ny, offset, len, away) => {
-    if (offset !== 0) return offset;
-    const base = len * ARC_CURVE_FRAC;
-    if (!away) return base;
-    const dot = nx * (mx - away.x) + ny * (my - away.y);
-    return dot < 0 ? -base : base;
+    if (g.type === "MultiPolygon") {
+      const polys = g.coordinates;
+      const keep = polys.filter(
+        (p) => ringOverlapsView(p[0])
+      );
+      if (!keep.length) return null;
+      if (keep.length === polys.length) return f;
+      return { ...f, geometry: { ...g, coordinates: keep } };
+    }
+    return f;
   };
-  const legPath = (a, b, curved, offset, away) => {
-    const mx = (a.cx + b.cx) / 2;
-    const my = (a.cy + b.cy) / 2;
-    const dx = b.cx - a.cx;
-    const dy = b.cy - a.cy;
-    const len = Math.hypot(dx, dy) || 1;
-    const trimA = Math.min(a.r + RIM_GAP, len * 0.45);
-    const trimB = Math.min(b.r + RIM_GAP, len * 0.45);
-    if (!curved && offset === 0) {
-      const ux = dx / len;
-      const uy = dy / len;
-      const ax2 = a.cx + ux * trimA;
-      const ay2 = a.cy + uy * trimA;
-      const bx2 = b.cx - ux * trimB;
-      const by2 = b.cy - uy * trimB;
-      return `M${ax2},${ay2}L${bx2},${by2}`;
+  const SEAM_SLIVER_MAX_SPAN = 100;
+  const ringIsFrameFiller = (ring) => {
+    const lons = ring.map(([lon]) => lon).sort((a, b) => a - b);
+    if (lons.length < 2) return false;
+    let maxGap = -1;
+    let gapIdx = 0;
+    for (let i = 1; i < lons.length; i++) {
+      const g = lons[i] - lons[i - 1];
+      if (g > maxGap) {
+        maxGap = g;
+        gapIdx = i;
+      }
     }
-    const nx = -dy / len;
-    const ny = dx / len;
-    const bow = bowMagnitude(mx, my, nx, ny, offset, len, away);
-    const px = mx + nx * bow;
-    const py = my + ny * bow;
-    const ta = Math.hypot(px - a.cx, py - a.cy) || 1;
-    const tb = Math.hypot(b.cx - px, b.cy - py) || 1;
-    const ax = a.cx + (px - a.cx) / ta * trimA;
-    const ay = a.cy + (py - a.cy) / ta * trimA;
-    const bx = b.cx - (b.cx - px) / tb * trimB;
-    const by = b.cy - (b.cy - py) / tb * trimB;
-    return `M${ax},${ay}Q${px},${py} ${bx},${by}`;
+    const wrapGap = lons[0] + 360 - lons[lons.length - 1];
+    if (wrapGap >= maxGap) return false;
+    const span = 360 - maxGap;
+    const east = lons[gapIdx - 1] + 360;
+    return east > 180 && span < SEAM_SLIVER_MAX_SPAN;
   };
-  const legLabelPoint = (a, b, curved, offset, away) => {
-    const mx = (a.cx + b.cx) / 2;
-    const my = (a.cy + b.cy) / 2;
-    if (!curved && offset === 0) return { x: mx, y: my - 4 };
-    const dx = b.cx - a.cx;
-    const dy = b.cy - a.cy;
-    const len = Math.hypot(dx, dy) || 1;
-    const nx = -dy / len;
-    const ny = dx / len;
-    const bow = bowMagnitude(mx, my, nx, ny, offset, len, away);
-    const off = bow * 0.5 + Math.sign(bow || 1) * 8;
-    return { x: mx + nx * off, y: my + ny * off };
+  const dropFrameFillers = (f) => {
+    const g = f.geometry;
+    if (!g) return f;
+    if (g.type === "Polygon") {
+      const ring = g.coordinates[0];
+      return ringIsFrameFiller(ring) ? null : f;
+    }
+    if (g.type === "MultiPolygon") {
+      const polys = g.coordinates;
+      const keep = polys.filter(
+        (p) => !ringIsFrameFiller(p[0])
+      );
+      if (!keep.length) return null;
+      if (keep.length === polys.length) return f;
+      return { ...f, geometry: { ...g, coordinates: keep } };
+    }
+    return f;
   };
-  const LEG_SAMPLES = 25;
-  const POI_CLEARANCE = 10;
-  const LEG_CLEARANCE = 7;
-  const SHARED_END_RADIUS = 36;
-  const placedLegSamples = [];
-  const sampleLeg = (a, b, curved, bow) => {
-    const pts = [];
-    const dx = b.cx - a.cx;
-    const dy = b.cy - a.cy;
-    const len = Math.hypot(dx, dy) || 1;
-    const px = (a.cx + b.cx) / 2 + -dy / len * bow;
-    const py = (a.cy + b.cy) / 2 + dx / len * bow;
-    for (let i = 0; i < LEG_SAMPLES; i++) {
-      const t = i / (LEG_SAMPLES - 1);
-      if (!curved && bow === 0) {
-        pts.push({ x: a.cx + dx * t, y: a.cy + dy * t });
+  const regions = [];
+  const pushRegionLayer = (layerFeatures, layerKind, shouldCull) => {
+    for (const [iso, f] of layerFeatures) {
+      if (layerKind === "us-state" && usContext && resolved.projection === "albers-usa" && INSET_STATES.has(iso))
+        continue;
+      if (layerKind === "country" && usContext && iso === "US") continue;
+      if (layerKind === "country" && iso === "AQ" && !regionById.has("AQ"))
+        continue;
+      const r = regionById.get(iso);
+      const geoK = layerKind + ":" + iso;
+      let geo = regionGeo.get(geoK);
+      if (geo === void 0) {
+        const viewF = shouldCull ? cullFeatureToView(f) : dropFrameFillers(f);
+        if (!viewF) {
+          regionGeo.set(geoK, null);
+          continue;
+        }
+        const raw = path(viewF) ?? "";
+        const d0 = fitIsGlobal ? dropAntimeridianWrapSlivers(raw, width, height) : raw;
+        if (!d0) {
+          regionGeo.set(geoK, null);
+          continue;
+        }
+        const anchor = WORLD_LABEL_ANCHORS[iso];
+        const cc = anchor ? project(anchor[0], anchor[1]) : path.centroid(viewF);
+        const ok = cc != null && Number.isFinite(cc[0]) && Number.isFinite(cc[1]);
+        geo = { d: d0, cx: ok ? cc[0] : void 0, cy: ok ? cc[1] : void 0 };
+        regionGeo.set(geoK, geo);
+      } else if (geo === null) {
+        continue;
+      }
+      const d = geo.d;
+      const hasCentroid = geo.cx !== void 0 && geo.cy !== void 0;
+      const isThisLayer = r?.layer === layerKind;
+      const isForeign = layerKind === "country" && usContext && iso !== "US";
+      const baseFill = isForeign ? foreignFill : neutralFill;
+      let fill = colorizeActive ? colorByIso.get(iso) ?? baseFill : baseFill;
+      let label;
+      let lineNumber = -1;
+      let layer = "base";
+      if (isThisLayer) {
+        fill = regionFill(r);
+        lineNumber = r.lineNumber;
+        layer = layerKind;
+        label = r.name;
       } else {
-        const u = 1 - t;
-        pts.push({
-          x: u * u * a.cx + 2 * u * t * px + t * t * b.cx,
-          y: u * u * a.cy + 2 * u * t * py + t * t * b.cy
-        });
+        label = f.properties?.name;
+      }
+      regions.push({
+        id: iso,
+        d,
+        fill,
+        stroke: colorizeActive ? colorizeStroke(fill) : regionStroke,
+        lineNumber,
+        layer,
+        ...label !== void 0 && { label },
+        ...hasCentroid && { labelX: geo.cx, labelY: geo.cy },
+        ...isThisLayer && r.value !== void 0 && { value: r.value },
+        ...isThisLayer && Object.keys(r.tags).length > 0 && { tags: r.tags }
+      });
+    }
+  };
+  pushRegionLayer(worldLayer, "country", !isGlobalView);
+  if (usLayer) pushRegionLayer(usLayer, "us-state", !conusFit && !isGlobalView);
+  const lakesTopo = usCrisp && data.naLakes ? data.naLakes : data.lakes;
+  if (lakesTopo) {
+    for (const [, f] of decodeLayer(lakesTopo)) {
+      const viewF = isGlobalView ? dropFrameFillers(f) : cullFeatureToView(f);
+      if (!viewF) continue;
+      const d = path(viewF) ?? "";
+      if (!d) continue;
+      regions.push({
+        id: "lake",
+        d,
+        fill: water,
+        stroke: lakeStroke,
+        lineNumber: -1,
+        layer: "base"
+      });
+    }
+  }
+  const pointInRings = (px, py, rings) => {
+    let inside = false;
+    for (const ring of rings) {
+      for (let i = 0, j = ring.length - 1; i < ring.length; j = i++) {
+        const [xi, yi] = ring[i];
+        const [xj, yj] = ring[j];
+        if (yi > py !== yj > py && px < (xj - xi) * (py - yi) / (yj - yi) + xi)
+          inside = !inside;
       }
     }
-    return pts;
+    return inside;
   };
-  const legPenalty = (pts, fromId, toId) => {
-    let pen = 0;
-    for (const [id, p] of poiScreen) {
-      if (id === fromId || id === toId) continue;
-      let dmin = Infinity;
-      for (const s of pts) {
-        const d = Math.hypot(s.x - p.cx, s.y - p.cy);
-        if (d < dmin) dmin = d;
+  const fillHitTargets = [...regions, ...insetRegions].map((r) => {
+    const rings = parsePathRings(r.d);
+    let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+    for (const ring of rings)
+      for (const p of ring) {
+        if (p[0] < minX) minX = p[0];
+        if (p[0] > maxX) maxX = p[0];
+        if (p[1] < minY) minY = p[1];
+        if (p[1] > maxY) maxY = p[1];
       }
-      const clear = p.r + POI_CLEARANCE;
-      if (dmin < clear) pen += (clear - dmin) * 12;
+    r.bbox = [minX, minY, maxX, maxY];
+    r.rings = rings;
+    return { fill: r.fill, rings, minX, minY, maxX, maxY };
+  });
+  const fillAt = (x, y) => {
+    let hit = water;
+    for (const t of fillHitTargets) {
+      if (x < t.minX || x > t.maxX || y < t.minY || y > t.maxY) continue;
+      if (pointInRings(x, y, t.rings)) hit = t.fill;
     }
-    for (const other of placedLegSamples) {
-      const shared = [fromId, toId].filter((id) => id === other.fromId || id === other.toId).map((id) => poiScreen.get(id)).filter((p) => !!p);
-      for (const s of pts) {
-        if (shared.some(
-          (sp) => Math.hypot(s.x - sp.cx, s.y - sp.cy) < SHARED_END_RADIUS
-        )) {
-          continue;
-        }
-        let dmin = Infinity;
-        for (const o of other.pts) {
-          const d = Math.hypot(s.x - o.x, s.y - o.y);
-          if (d < dmin) dmin = d;
-        }
-        if (dmin < LEG_CLEARANCE) pen += 6;
-      }
+    return hit;
+  };
+  const labelOnFill = (fill) => {
+    const color = contrastRatio(fill, palette.textOnFillDark) >= contrastRatio(fill, palette.textOnFillLight) ? palette.textOnFillDark : palette.textOnFillLight;
+    const haloColor = color === palette.textOnFillLight ? palette.textOnFillDark : palette.textOnFillLight;
+    return {
+      color,
+      halo: contrastRatio(fill, color) < REGION_LABEL_HALO_RATIO,
+      haloColor
+    };
+  };
+  const reliefAllowed = resolved.directives.noRelief !== true;
+  const relief = [];
+  let reliefHatch = null;
+  if (reliefAllowed && data.mountainRanges) {
+    for (const [, f] of decodeLayer(data.mountainRanges)) {
+      const viewF = isGlobalView ? dropFrameFillers(f) : cullFeatureToView(f);
+      if (!viewF) continue;
+      const area = path.area(viewF);
+      if (!Number.isFinite(area) || area < RELIEF_MIN_AREA) continue;
+      const box = path.bounds(viewF);
+      if (box[1][0] - box[0][0] < RELIEF_MIN_DIM || box[1][1] - box[0][1] < RELIEF_MIN_DIM)
+        continue;
+      const d = path(viewF) ?? "";
+      if (!d) continue;
+      relief.push({ d });
     }
-    for (const s of pts) {
-      if (s.x < 0 || s.x > width || s.y < 0 || s.y > height) pen += 20;
+    if (relief.length) {
+      const darkTone = isDark ? palette.bg : palette.text;
+      const lightTone = isDark ? palette.text : palette.bg;
+      const reliefLandRef = colorizeActive ? isDark ? palette.surface : palette.bg : neutralFill;
+      const landLum = relativeLuminance(reliefLandRef);
+      const tone = Math.abs(landLum - relativeLuminance(darkTone)) > 0.04 ? darkTone : lightTone;
+      reliefHatch = {
+        color: mix(tone, reliefLandRef, RELIEF_HATCH_STRENGTH),
+        spacing: RELIEF_HATCH_SPACING,
+        width: RELIEF_HATCH_WIDTH
+      };
     }
-    return pen;
-  };
-  const chooseArcBow = (a, b, fromId, toId, away) => {
-    const mx = (a.cx + b.cx) / 2;
-    const my = (a.cy + b.cy) / 2;
-    const dx = b.cx - a.cx;
-    const dy = b.cy - a.cy;
-    const len = Math.hypot(dx, dy) || 1;
-    const nx = -dy / len;
-    const ny = dx / len;
-    const def = bowMagnitude(mx, my, nx, ny, 0, len, away);
-    const candidates = [
-      def,
-      -def,
-      def * 1.6,
-      -def * 1.6,
-      def * 2.2,
-      -def * 2.2
-    ];
-    let best = def;
-    let bestPen = Infinity;
-    for (const c of candidates) {
-      const pen = legPenalty(sampleLeg(a, b, true, c), fromId, toId);
-      if (pen < bestPen - 1e-6) {
-        best = c;
-        bestPen = pen;
-      }
-      if (bestPen === 0) break;
+  }
+  let coastlineStyle = null;
+  if (resolved.directives.noCoastline !== true) {
+    const minDim = Math.min(width, height);
+    coastlineStyle = {
+      color: mix(regionStroke, water, COASTLINE_STROKE_MIX),
+      // N equal-width rings: distance steps outward by COASTLINE_STEP; opacity
+      // fades linearly from NEAR (innermost) to FAR (outermost).
+      lines: Array.from({ length: COASTLINE_RING_COUNT }, (_, k) => ({
+        d: (COASTLINE_D0 + k * COASTLINE_STEP) * minDim,
+        thickness: COASTLINE_THICKNESS * minDim,
+        opacity: COASTLINE_OPACITY_NEAR + (COASTLINE_OPACITY_FAR - COASTLINE_OPACITY_NEAR) * k / (COASTLINE_RING_COUNT - 1)
+      })),
+      minExtent: (isGlobalView ? COASTLINE_MIN_EXTENT_GLOBAL : COASTLINE_MIN_EXTENT) * minDim
+    };
+  }
+  const riverColor = mix(palette.colors.blue, water, 32);
+  const rivers = [];
+  if (data.rivers) {
+    for (const [, f] of decodeLayer(data.rivers)) {
+      const viewF = isGlobalView ? dropFrameFillers(f) : cullFeatureToView(f);
+      if (!viewF) continue;
+      const d = path(viewF) ?? "";
+      if (!d) continue;
+      rivers.push({ d, color: riverColor, width: RIVER_WIDTH });
     }
-    return best;
+  }
+  const sizeVals = resolved.pois.map((p) => Number(p.meta["size"])).filter((n) => Number.isFinite(n) && n > 0);
+  const sizeMin = sizeVals.length ? Math.min(...sizeVals) : 0;
+  const sizeMax = sizeVals.length ? Math.max(...sizeVals) : 0;
+  const radiusFor = (p) => {
+    const v = Number(p.meta["size"]);
+    if (!Number.isFinite(v) || v <= 0 || sizeMax <= 0) return R_DEFAULT;
+    const t = sizeMax > sizeMin ? (Math.sqrt(v) - Math.sqrt(sizeMin)) / (Math.sqrt(sizeMax) - Math.sqrt(sizeMin)) : 1;
+    return R_MIN + Math.max(0, Math.min(1, t)) * (R_MAX - R_MIN);
   };
-  const routeLegVals = resolved.routes.flatMap((rt) => rt.legs).map((l) => Number(l.value)).filter((n) => Number.isFinite(n) && n > 0);
-  const rlMin = routeLegVals.length ? Math.min(...routeLegVals) : 0;
-  const rlMax = routeLegVals.length ? Math.max(...routeLegVals) : 0;
-  const routeWidthFor = (v) => {
-    if (!Number.isFinite(v) || v <= 0 || rlMax <= 0) return W_MIN;
-    const t = rlMax > rlMin ? (v - rlMin) / (rlMax - rlMin) : 1;
-    return W_MIN + t * (W_MAX - W_MIN);
+  const fillOpacityFor = (r) => {
+    const t = Math.max(0, Math.min(1, (r - R_MIN) / (R_MAX - R_MIN)));
+    return POI_FILL_OPACITY_MAX - t * (POI_FILL_OPACITY_MAX - POI_FILL_OPACITY_MIN);
   };
-  for (const rt of resolved.routes) {
-    const stopPts = rt.stopIds.map((id) => poiScreen.get(id)).filter((p) => !!p);
-    const center = stopPts.length >= 3 ? {
-      x: stopPts.reduce((s, p) => s + p.cx, 0) / stopPts.length,
-      y: stopPts.reduce((s, p) => s + p.cy, 0) / stopPts.length
-    } : void 0;
-    for (const leg of rt.legs) {
-      const a = poiScreen.get(leg.fromId);
-      const b = poiScreen.get(leg.toId);
-      if (!a || !b) continue;
-      const curvedLeg = leg.style === "arc";
-      const chosenBow = curvedLeg ? chooseArcBow(a, b, leg.fromId, leg.toId, center) : 0;
-      const lp = legLabelPoint(a, b, curvedLeg, chosenBow, center);
-      const bow = {
-        curved: curvedLeg,
-        offset: chosenBow,
-        center,
-        labelX: lp.x,
-        labelY: lp.y
-      };
-      placedLegSamples.push({
-        fromId: leg.fromId,
-        toId: leg.toId,
-        pts: sampleLeg(a, b, curvedLeg, chosenBow)
-      });
-      const routeLabelStyle = leg.label !== void 0 ? labelOnFill(fillAt(bow.labelX, bow.labelY)) : void 0;
-      const routeVal = Number(leg.value);
-      legs.push({
-        d: legPath(a, b, bow.curved, bow.offset, bow.center),
-        width: routeWidthFor(routeVal),
-        color: lineColor(leg.tags) ?? mix(palette.text, palette.bg, 72),
-        arrow: true,
-        fromId: leg.fromId,
-        toId: leg.toId,
-        ...Number.isFinite(routeVal) && routeVal > 0 && { value: routeVal },
-        ...Object.keys(leg.tags).length > 0 && { tags: leg.tags },
-        lineNumber: leg.lineNumber,
-        ...leg.label !== void 0 && {
-          label: leg.label,
-          labelX: bow.labelX,
-          labelY: bow.labelY,
-          labelColor: routeLabelStyle.color,
-          labelHalo: routeLabelStyle.halo,
-          labelHaloColor: routeLabelStyle.haloColor
-        }
-      });
+  const poiFill = (p) => {
+    const directHex = p.color ? resolveColor(p.color, palette) : null;
+    if (directHex)
+      return { fill: directHex, stroke: mix(directHex, palette.text, 18) };
+    for (const group of resolved.tagGroups) {
+      const val = p.tags[tagAttrKey(group.name)];
+      if (!val) continue;
+      const entry = group.entries.find(
+        (e) => e.value.toLowerCase() === val.toLowerCase()
+      );
+      const hex = entry?.color;
+      if (hex) return { fill: hex, stroke: mix(hex, palette.text, 18) };
     }
+    return {
+      fill: palette.colors.orange,
+      stroke: mix(palette.colors.orange, palette.text, 18)
+    };
+  };
+  const routeNumberById = /* @__PURE__ */ new Map();
+  const originIds = /* @__PURE__ */ new Set();
+  for (const rt of resolved.routes) {
+    rt.stopIds.forEach((id, i) => {
+      if (i === 0) originIds.add(id);
+      if (!routeNumberById.has(id)) routeNumberById.set(id, i + 1);
+    });
   }
-  const weightVals = resolved.edges.map((e) => Number(e.meta["width"])).filter((n) => Number.isFinite(n) && n > 0);
-  const wMin = weightVals.length ? Math.min(...weightVals) : 0;
-  const wMax = weightVals.length ? Math.max(...weightVals) : 0;
-  const widthFor = (e) => {
-    const v = Number(e.meta["width"]);
-    if (!Number.isFinite(v) || v <= 0 || wMax <= 0) return W_MIN;
-    const t = wMax > wMin ? (v - wMin) / (wMax - wMin) : 1;
-    return W_MIN + t * (W_MAX - W_MIN);
+  const poiScreen = /* @__PURE__ */ new Map();
+  const pois = [];
+  const orderedPois = [...resolved.pois].sort(
+    (a, b) => a.lineNumber - b.lineNumber || (a.id < b.id ? -1 : 1)
+  );
+  const projected = [];
+  for (const p of orderedPois) {
+    const xy = project(p.lon, p.lat);
+    if (xy) projected.push({ p, xy });
+  }
+  const placePoi = (e, cx, cy, clusterId) => {
+    const { fill, stroke } = poiFill(e.p);
+    const r = radiusFor(e.p);
+    poiScreen.set(e.p.id, { cx, cy, r });
+    const num = routeNumberById.get(e.p.id);
+    pois.push({
+      id: e.p.id,
+      cx,
+      cy,
+      r,
+      fill,
+      fillOpacity: fillOpacityFor(r),
+      stroke,
+      lineNumber: e.p.lineNumber,
+      implicit: !!e.p.implicit,
+      isOrigin: originIds.has(e.p.id),
+      ...num !== void 0 && { routeNumber: num },
+      ...Object.keys(e.p.tags).length > 0 && { tags: e.p.tags },
+      ...clusterId !== void 0 && { clusterId }
+    });
   };
-  const pairGroups = /* @__PURE__ */ new Map();
+  const clusters = [];
+  const connected = /* @__PURE__ */ new Set();
   for (const e of resolved.edges) {
-    const key = [e.fromId, e.toId].sort().join(" ");
-    const arr = pairGroups.get(key);
-    if (arr) arr.push(e);
-    else pairGroups.set(key, [e]);
+    connected.add(e.fromId);
+    connected.add(e.toId);
   }
-  for (const groupEdges of pairGroups.values()) {
-    const ordered = [...groupEdges].sort((a, b) => a.lineNumber - b.lineNumber);
-    const n = ordered.length;
-    ordered.forEach((e, i) => {
-      const a = poiScreen.get(e.fromId);
-      const b = poiScreen.get(e.toId);
-      if (!a || !b) return;
-      const fanOffset = n > 1 ? (i - (n - 1) / 2) * FAN_STEP : 0;
-      const curved = e.style === "arc" || n > 1;
-      const edgeBow = curved && n === 1 ? chooseArcBow(a, b, e.fromId, e.toId) : fanOffset;
-      const lp = legLabelPoint(a, b, curved, edgeBow);
-      const bow = {
-        curved,
-        offset: edgeBow,
-        labelX: lp.x,
-        labelY: lp.y
-      };
-      placedLegSamples.push({
-        fromId: e.fromId,
-        toId: e.toId,
-        pts: sampleLeg(a, b, curved, edgeBow)
-      });
-      const edgeLabelStyle = e.label !== void 0 ? labelOnFill(fillAt(bow.labelX, bow.labelY)) : void 0;
-      const edgeVal = Number(e.meta["width"]);
-      legs.push({
-        d: legPath(a, b, bow.curved, bow.offset),
-        width: widthFor(e),
-        color: lineColor(e.tags) ?? mix(palette.text, palette.bg, 66),
-        arrow: e.directed,
-        fromId: e.fromId,
-        toId: e.toId,
-        ...Number.isFinite(edgeVal) && edgeVal > 0 && { value: edgeVal },
-        ...Object.keys(e.tags).length > 0 && { tags: e.tags },
-        lineNumber: e.lineNumber,
-        ...e.label !== void 0 && {
-          label: e.label,
-          labelX: bow.labelX,
-          labelY: bow.labelY,
-          labelColor: edgeLabelStyle.color,
-          labelHalo: edgeLabelStyle.halo,
-          labelHaloColor: edgeLabelStyle.haloColor
-        }
-      });
+  for (const rt of resolved.routes) {
+    rt.stopIds.forEach((id) => connected.add(id));
+  }
+  const radiusOf = (e) => radiusFor(e.p);
+  for (const e of projected) {
+    if (connected.has(e.p.id)) placePoi(e, e.xy[0], e.xy[1]);
+  }
+  const groups = [];
+  for (const e of projected) {
+    if (connected.has(e.p.id)) continue;
+    const r = radiusOf(e);
+    const near = groups.find(
+      (g) => g.some(
+        (q) => Math.hypot(q.xy[0] - e.xy[0], q.xy[1] - e.xy[1]) < (r + radiusOf(q)) * STACK_OVERLAP
+      )
+    );
+    if (near) near.push(e);
+    else groups.push([e]);
+  }
+  for (const g of groups) {
+    if (g.length === 1) {
+      placePoi(g[0], g[0].xy[0], g[0].xy[1]);
+      continue;
+    }
+    const clusterId = g[0].p.id;
+    const cx0 = g.reduce((s, e) => s + e.xy[0], 0) / g.length;
+    const cy0 = g.reduce((s, e) => s + e.xy[1], 0) / g.length;
+    const maxR = Math.max(...g.map(radiusOf));
+    const sep = 2 * maxR + STACK_RING_GAP;
+    const ringR = Math.max(
+      COLO_R,
+      sep / (2 * Math.sin(Math.PI / Math.max(g.length, 2)))
+    );
+    const positions = g.map((e, i) => {
+      if (g.length <= STACK_RING_MAX) {
+        const ang2 = -Math.PI / 2 + i * 2 * Math.PI / g.length;
+        return {
+          e,
+          mx: cx0 + Math.cos(ang2) * ringR,
+          my: cy0 + Math.sin(ang2) * ringR
+        };
+      }
+      const ang = i * GOLDEN_ANGLE;
+      const rr = ringR * Math.sqrt((i + 1) / g.length);
+      return { e, mx: cx0 + Math.cos(ang) * rr, my: cy0 + Math.sin(ang) * rr };
+    });
+    let minX = cx0 - maxR;
+    let maxX = cx0 + maxR;
+    let minY = cy0 - maxR;
+    let maxY = cy0 + maxR;
+    for (const { mx, my, e } of positions) {
+      const r = radiusOf(e);
+      minX = Math.min(minX, mx - r);
+      maxX = Math.max(maxX, mx + r);
+      minY = Math.min(minY, my - r);
+      maxY = Math.max(maxY, my + r);
+    }
+    let dx = 0;
+    let dy = 0;
+    if (minX + dx < 2) dx = 2 - minX;
+    if (maxX + dx > width - 2) dx = width - 2 - maxX;
+    if (minY + dy < 2) dy = 2 - minY;
+    if (maxY + dy > height - 2) dy = height - 2 - maxY;
+    const legsOut = [];
+    for (const { e, mx, my } of positions) {
+      const fx = mx + dx;
+      const fy = my + dy;
+      placePoi(e, fx, fy, clusterId);
+      legsOut.push({ x2: fx, y2: fy, color: poiFill(e.p).fill });
+    }
+    clusters.push({
+      id: clusterId,
+      cx: cx0 + dx,
+      cy: cy0 + dy,
+      count: g.length,
+      hitR: ringR + maxR + 6,
+      legs: legsOut
     });
   }
+  const legs = buildConnectorLegs({
+    resolved,
+    poiScreen,
+    palette,
+    width,
+    height,
+    fillAt,
+    labelOnFill
+  });
   const labels = [];
   const obstacles = [...topReserved];
   const regionLabelGuards = [];
@@ -2069,36 +2711,8 @@ function layoutMap(resolvedIn, data, size, opts) {
   const regionValueStr = (value) => showRegionValues && value !== void 0 ? compactNumber(value) : void 0;
   const isCompact = width < COMPACT_WIDTH_PX;
   const usChoroplethZoom = resolved.projection === "mercator" && resolved.basemaps.subdivisions.includes("us-states") && activeIsScore;
-  const LABEL_PADX = 6;
-  const LABEL_PADY = 3;
-  const VALUE_GAP = 1;
-  const labelW = (text, font = FONT2) => measureLegendText(text, font) + 2 * LABEL_PADX;
-  const labelH = FONT2 + 2 * LABEL_PADY;
-  const stackW = (text, valueText, font = FONT2) => Math.max(
-    labelW(text, font),
-    valueText ? measureLegendText(valueText, Math.round(font * 0.82)) + 2 * LABEL_PADX : 0
-  );
-  const stackH = (hasValue, font = FONT2) => {
-    const lh = font + 2 * LABEL_PADY;
-    return hasValue ? lh + VALUE_GAP + Math.round(font * 0.82) : lh;
-  };
-  const REGION_FONT_MAX_ORIENT = 22;
-  const REGION_SIZE_FRAC_MIN = 0.06;
-  const REGION_SIZE_FRAC_MAX = 0.32;
-  const SUBJECT_FONT_MAX = 18;
-  const SUBJECT_MIN_PROMINENCE = 13;
-  const SUBJECT_LEADER_FONT = 15;
-  const canvasLinear = Math.sqrt(Math.max(1, width * height));
-  const sizeT = (boxW, boxH) => {
-    const frac = Math.sqrt(Math.max(0, boxW * boxH)) / canvasLinear;
-    return Math.min(
-      1,
-      Math.max(
-        0,
-        (frac - REGION_SIZE_FRAC_MIN) / (REGION_SIZE_FRAC_MAX - REGION_SIZE_FRAC_MIN)
-      )
-    );
-  };
+  const labelMetrics = createLabelMetrics(size);
+  const { labelW, labelH } = labelMetrics;
   const pushRegionLabel = (x, y, text, fill, lineNumber, valueLine, fontSize = FONT2, colorOverride) => {
     const { color: baseColor, haloColor } = labelOnFill(fill);
     const color = colorOverride ?? baseColor;
@@ -2138,373 +2752,39 @@ function layoutMap(resolvedIn, data, size, opts) {
     return { x: cx - w / 2, y: cy - h / 2, w, h };
   };
   if (showRegionLabels) {
-    const frameContainers = new Set(resolved.poiFrameContainers);
-    const entries = regions.map((r) => {
-      const isContainer = frameContainers.has(r.id);
-      if (r.layer === "base" && !isContainer || r.label === void 0)
-        return null;
-      const isUsState = r.layer === "us-state" || r.id.startsWith("US-");
-      const f = isUsState ? usLayer?.get(r.id) : worldLayer.get(r.id);
-      if (!f) return null;
-      const [[x0, y0], [x1, y1]] = path.bounds(f);
-      const boxW = x1 - x0;
-      const boxH = y1 - y0;
-      const abbrev = isUsState && !usChoroplethZoom ? r.id.replace(/^US-/, "") : void 0;
-      const candidates = abbrev !== void 0 ? isCompact ? [abbrev, r.label] : isContainer ? [r.label] : [r.label, abbrev] : [r.label];
-      const anchor = !isUsState ? WORLD_LABEL_ANCHORS[r.id] : void 0;
-      const c = anchor ? project(anchor[0], anchor[1]) : path.centroid(f);
-      if (!c || !Number.isFinite(c[0])) return null;
-      return { r, c, boxW, boxH, area: boxW * boxH, candidates };
-    }).filter((e) => e !== null).sort((a, b) => b.area - a.area || a.r.lineNumber - b.r.lineNumber);
-    const placedRegionRects = [...topReserved];
-    const placedLeaders = [];
-    const isEmptyFill = (f) => f === water || f === neutralFill || f === foreignFill;
-    const POI_LABEL_PAD = 14;
-    const poiObstacles = pois.map((p) => ({
-      x: p.cx - p.r - POI_LABEL_PAD,
-      y: p.cy - p.r - POI_LABEL_PAD,
-      w: 2 * (p.r + POI_LABEL_PAD),
-      h: 2 * (p.r + POI_LABEL_PAD)
-    }));
-    const SHORT_HOP_MAX = Math.max(46, Math.min(width, height) * 0.11);
-    const STEP = 4;
-    const HOP_GAP = 9;
-    const CLEAR_STEP = 6;
-    const CLEAR_MAX = SHORT_HOP_MAX * 3;
-    const CLEAR_TOL = CLEAR_STEP;
-    const clearanceAt = (px, py, ox, oy) => {
-      const baseAng = Math.atan2(oy, ox);
-      let minClear = CLEAR_MAX;
-      for (let k = -2; k <= 2; k++) {
-        const a = baseAng + k * Math.PI / 4;
-        const rx = Math.cos(a);
-        const ry = Math.sin(a);
-        let d = CLEAR_STEP;
-        for (; d <= CLEAR_MAX; d += CLEAR_STEP) {
-          const qx = px + rx * d;
-          const qy = py + ry * d;
-          if (qx < FIT_PAD || qy < topPad || qx > width - FIT_PAD || qy > height - FIT_PAD)
-            break;
-          if (fillAt(qx, qy) !== water) break;
-        }
-        if (d < minClear) minClear = d;
-      }
-      return minClear;
-    };
-    const tryShortHopCallout = (cx, cy, fill, name, value, font = FONT2, gap = HOP_GAP, maxLen = SHORT_HOP_MAX) => {
-      const chipW = stackW(name, value, font);
-      const chipH = stackH(value !== void 0, font);
-      const D = Math.SQRT1_2;
-      const dirs = [
-        [0, -1],
-        // north
-        [0, 1],
-        // south
-        [1, 0],
-        // east
-        [-1, 0],
-        // west
-        [D, -D],
-        // NE
-        [D, D],
-        // SE
-        [-D, -D],
-        // NW
-        [-D, D]
-        // SW
-      ];
-      let best = null;
-      for (const [dx, dy] of dirs) {
-        let ex = cx;
-        let ey = cy;
-        let steps = 0;
-        const maxSteps = Math.ceil(maxLen / STEP) + 1;
-        while (steps < maxSteps && fillAt(ex, ey) === fill) {
-          ex += dx * STEP;
-          ey += dy * STEP;
-          steps++;
-        }
-        if (fillAt(ex, ey) === fill) continue;
-        const halfAlong = (Math.abs(dx) * chipW + Math.abs(dy) * chipH) / 2;
-        const ccx = ex + dx * (gap + halfAlong);
-        const ccy = ey + dy * (gap + halfAlong);
-        const rect = {
-          x: ccx - chipW / 2,
-          y: ccy - chipH / 2,
-          w: chipW,
-          h: chipH
-        };
-        if (rect.x < FIT_PAD || rect.y < topPad || rect.x + rect.w > width - FIT_PAD || rect.y + rect.h > height - FIT_PAD)
-          continue;
-        const sx = [rect.x + 2, ccx, rect.x + rect.w - 2];
-        const sy = [rect.y + 2, ccy, rect.y + rect.h - 2];
-        let onEmpty = true;
-        for (const px of sx)
-          for (const py of sy)
-            if (!isEmptyFill(fillAt(px, py))) {
-              onEmpty = false;
-              break;
-            }
-        if (!onEmpty) continue;
-        if (placedRegionRects.some((p) => rectsOverlap(rect, p))) continue;
-        if (poiObstacles.some((o) => rectsOverlap(rect, o))) continue;
-        if (markers.some((m) => rectCircleOverlap(rect, m))) continue;
-        const innerX = ccx - dx * (chipW / 2);
-        const innerY = ccy - dy * (chipH / 2);
-        const len = Math.hypot(innerX - cx, innerY - cy);
-        if (len > maxLen) continue;
-        if (placedLeaders.some(
-          (l) => segmentsCross(cx, cy, innerX, innerY, l[0], l[1], l[2], l[3])
-        ))
-          continue;
-        if (placedRegionRects.some(
-          (p) => segmentRectOverlap(cx, cy, innerX, innerY, p)
-        ))
-          continue;
-        const clear = clearanceAt(ccx, ccy, dx, dy);
-        const better = best === null || clear > best.clear + CLEAR_TOL || clear >= best.clear - CLEAR_TOL && len < best.len;
-        if (better)
-          best = {
-            x: ccx,
-            y: ccy,
-            rect,
-            leader: [cx, cy, innerX, innerY],
-            len,
-            clear
-          };
-      }
-      return best ? { x: best.x, y: best.y, rect: best.rect, leader: best.leader } : null;
-    };
-    for (const { r, c, boxW, boxH, candidates } of entries) {
-      const valStr = regionValueStr(r.value);
-      const fitsRegions = (rect) => !placedRegionRects.some((p) => rectsOverlap(rect, p));
-      const fitsPois = (rect) => !poiObstacles.some((o) => rectsOverlap(rect, o));
-      const isSubject = regionById.has(r.id);
-      const extremesOnFill = (ax, ay, text) => {
-        const halfW = measureLegendText(text, FONT2) / 2;
-        return fillAt(ax - halfW, ay) === r.fill && fillAt(ax + halfW, ay) === r.fill;
-      };
-      if (isSubject && valStr === void 0 && r.label !== void 0) {
-        const name = candidates[0];
-        let best = -1;
-        for (let f = SUBJECT_FONT_MAX; f >= FONT2; f--) {
-          if (measureLegendText(name, f) > boxW || f + 2 * LABEL_PADY > boxH)
-            continue;
-          const rect = regionLabelRect(c[0], c[1], name, void 0, f);
-          if (!fitsRegions(rect) || !fitsPois(rect) || collides(rect)) continue;
-          const halfW = measureLegendText(name, f) / 2;
-          if (fillAt(c[0] - halfW, c[1]) !== r.fill || fillAt(c[0] + halfW, c[1]) !== r.fill)
-            continue;
-          best = f;
-          break;
-        }
-        if (best >= SUBJECT_MIN_PROMINENCE) {
-          const rect = regionLabelRect(c[0], c[1], name, void 0, best);
-          placedRegionRects.push(rect);
-          pushRegionLabel(
-            c[0],
-            c[1],
-            name,
-            r.fill,
-            r.lineNumber,
-            void 0,
-            best
-          );
-          labeledRegionIds.add(r.id);
-          regionLabelGuards.push({ label: labels[labels.length - 1], rect });
-        } else {
-          const hop = tryShortHopCallout(
-            c[0],
-            c[1],
-            r.fill,
-            r.label,
-            void 0,
-            SUBJECT_LEADER_FONT,
-            HOP_GAP + SUBJECT_LEADER_FONT,
-            SHORT_HOP_MAX * 2.2
-          );
-          if (hop) {
-            placedRegionRects.push(hop.rect);
-            placedLeaders.push(hop.leader);
-            const dark = mix(r.fill, palette.text, 60);
-            labels.push({
-              x: hop.x,
-              y: hop.y,
-              text: r.label,
-              anchor: "middle",
-              color: palette.text,
-              halo: false,
-              haloColor: palette.bg,
-              fontSize: SUBJECT_LEADER_FONT,
-              leader: {
-                x1: hop.leader[0],
-                y1: hop.leader[1],
-                x2: hop.leader[2],
-                y2: hop.leader[3]
-              },
-              leaderColor: dark,
-              calloutDot: { x: c[0], y: c[1], color: dark },
-              lineNumber: r.lineNumber
-            });
-            labeledRegionIds.add(r.id);
-          }
-        }
-        continue;
-      }
-      const seekAnchors = [
-        { x: c[0], y: c[1], guard: false }
-      ];
-      if (valStr) {
-        seekAnchors.push(
-          { x: c[0], y: c[1] + boxH * 0.26, guard: true },
-          { x: c[0], y: c[1] - boxH * 0.26, guard: true },
-          { x: c[0] + boxW * 0.26, y: c[1], guard: true },
-          { x: c[0] - boxW * 0.26, y: c[1], guard: true },
-          { x: c[0] + boxW * 0.22, y: c[1] + boxH * 0.22, guard: true },
-          { x: c[0] - boxW * 0.22, y: c[1] + boxH * 0.22, guard: true },
-          { x: c[0] + boxW * 0.22, y: c[1] - boxH * 0.22, guard: true },
-          { x: c[0] - boxW * 0.22, y: c[1] - boxH * 0.22, guard: true }
-        );
-      }
-      let chosen;
-      for (const a of seekAnchors) {
-        if (a.guard && fillAt(a.x, a.y) !== r.fill) continue;
-        for (const t of candidates) {
-          const nameRect = regionLabelRect(a.x, a.y, t);
-          if (valStr && stackW(t, valStr) <= boxW && stackH(true) <= boxH) {
-            const stackRect = regionLabelRect(a.x, a.y, t, valStr);
-            if (fitsRegions(stackRect) && fitsPois(nameRect) && extremesOnFill(a.x, a.y, t)) {
-              chosen = { text: t, valueLine: valStr, ax: a.x, ay: a.y };
-              break;
-            }
-          }
-          if (labelW(t) <= boxW && labelH <= boxH) {
-            if (fitsRegions(nameRect) && fitsPois(nameRect) && (valStr === void 0 || extremesOnFill(a.x, a.y, t))) {
-              chosen = { text: t, ax: a.x, ay: a.y };
-              break;
-            }
-          }
-        }
-        if (chosen) break;
-      }
-      if (chosen === void 0 && r.label !== void 0 && isSubject) {
-        const hop = tryShortHopCallout(c[0], c[1], r.fill, r.label, valStr);
-        if (hop) {
-          placedRegionRects.push(hop.rect);
-          placedLeaders.push(hop.leader);
-          const dark = mix(r.fill, palette.text, 60);
-          labels.push({
-            x: hop.x,
-            y: hop.y,
-            text: r.label,
-            anchor: "middle",
-            color: palette.text,
-            halo: false,
-            haloColor: palette.bg,
-            ...valStr !== void 0 && { valueLine: valStr },
-            leader: {
-              x1: hop.leader[0],
-              y1: hop.leader[1],
-              x2: hop.leader[2],
-              y2: hop.leader[3]
-            },
-            leaderColor: dark,
-            calloutDot: { x: c[0], y: c[1], color: dark },
-            lineNumber: r.lineNumber
-          });
-          labeledRegionIds.add(r.id);
-        }
-        continue;
-      }
-      if (chosen === void 0) continue;
-      const isOrient = r.value === void 0 && r.layer === "base";
-      let font = FONT2;
-      if (isOrient) {
-        const growT = sizeT(boxW, boxH);
-        const desiredFont = Math.round(
-          FONT2 + growT * (REGION_FONT_MAX_ORIENT - FONT2)
-        );
-        const hasVal = chosen.valueLine !== void 0;
-        const extremesClean = (f) => {
-          const halfW = measureLegendText(chosen.text, f) / 2;
-          return [chosen.ax - halfW, chosen.ax + halfW].every((sx) => {
-            const fAt = fillAt(sx, chosen.ay);
-            return fAt === r.fill || isEmptyFill(fAt);
-          });
-        };
-        let fit = -1;
-        for (let f = desiredFont; f >= FONT2; f--) {
-          if (stackW(chosen.text, chosen.valueLine, f) > boxW || stackH(hasVal, f) > boxH)
-            continue;
-          const gRect = regionLabelRect(
-            chosen.ax,
-            chosen.ay,
-            chosen.text,
-            chosen.valueLine,
-            f
-          );
-          const gName = regionLabelRect(
-            chosen.ax,
-            chosen.ay,
-            chosen.text,
-            void 0,
-            f
-          );
-          if (!fitsRegions(gRect) || !fitsPois(gName) || collides(gName))
-            continue;
-          if (!extremesClean(f)) continue;
-          fit = f;
-          break;
-        }
-        if (fit < 0) {
-          if (!frameContainers.has(r.id)) continue;
-          font = FONT2;
-        } else {
-          font = fit;
-        }
-      }
-      const rRect = regionLabelRect(
-        chosen.ax,
-        chosen.ay,
-        chosen.text,
-        chosen.valueLine,
-        font
-      );
-      placedRegionRects.push(rRect);
-      pushRegionLabel(
-        chosen.ax,
-        chosen.ay,
-        chosen.text,
-        r.fill,
-        r.lineNumber,
-        chosen.valueLine,
-        font,
-        isOrient ? backdropLandTone : void 0
-      );
-      labeledRegionIds.add(r.id);
-      regionLabelGuards.push({
-        label: labels[labels.length - 1],
-        rect: rRect
-      });
-    }
-    for (const seed of insetLabelSeeds) {
-      const text = isCompact ? seed.iso.replace(/^US-/, "") : seed.name;
-      const src = regionById.get(seed.iso);
-      const valStr = regionValueStr(src?.value);
-      pushRegionLabel(
-        seed.x,
-        seed.y,
-        text,
-        src ? regionFill(src) : neutralFill,
-        seed.lineNumber,
-        valStr
-      );
-      labeledRegionIds.add(seed.iso);
-      regionLabelGuards.push({
-        label: labels[labels.length - 1],
-        rect: regionLabelRect(seed.x, seed.y, text, valStr)
-      });
-    }
+    placeRegionLabels({
+      resolved,
+      palette,
+      width,
+      height,
+      path,
+      project,
+      worldLayer,
+      usLayer,
+      regionById,
+      regions,
+      pois,
+      insetLabelSeeds,
+      topReserved,
+      topPad,
+      markers,
+      collides,
+      neutralFill,
+      water,
+      foreignFill,
+      backdropLandTone,
+      regionFill,
+      fillAt,
+      regionValueStr,
+      isCompact,
+      usChoroplethZoom,
+      metrics: labelMetrics,
+      pushRegionLabel,
+      regionLabelRect,
+      labels,
+      labeledRegionIds,
+      regionLabelGuards
+    });
   }
   if (resolved.directives.noPoiLabels !== true) {
     const ordered = [...pois].filter((p) => p.clusterId === void 0).sort((a, b) => a.lineNumber - b.lineNumber || (a.id < b.id ? -1 : 1));
@@ -2518,7 +2798,7 @@ function layoutMap(resolvedIn, data, size, opts) {
       const text = labelText(p);
       return { text, w: measureLegendText(text, FONT2) };
     };
-    const GAP = 3;
+    const GAP2 = 3;
     const POI_EDGE_CLEAR = Math.max(
       20,
       Math.round(Math.min(width, height) * 0.03)
@@ -2533,10 +2813,10 @@ function layoutMap(resolvedIn, data, size, opts) {
     const inlineRect = (p, w, side) => {
       switch (side) {
         case "right":
-          return { x: p.cx + p.r + GAP, y: p.cy - poiLabH / 2, w, h: poiLabH };
+          return { x: p.cx + p.r + GAP2, y: p.cy - poiLabH / 2, w, h: poiLabH };
         case "left":
           return {
-            x: p.cx - p.r - GAP - w,
+            x: p.cx - p.r - GAP2 - w,
             y: p.cy - poiLabH / 2,
             w,
             h: poiLabH
@@ -2544,28 +2824,28 @@ function layoutMap(resolvedIn, data, size, opts) {
         case "above":
           return {
             x: p.cx - w / 2,
-            y: p.cy - p.r - GAP - poiLabH,
+            y: p.cy - p.r - GAP2 - poiLabH,
             w,
             h: poiLabH
           };
         case "below":
-          return { x: p.cx - w / 2, y: p.cy + p.r + GAP, w, h: poiLabH };
+          return { x: p.cx - w / 2, y: p.cy + p.r + GAP2, w, h: poiLabH };
         // Diagonal corners: offset both axes by (r+GAP)/√2 so the box's near
         // corner clears the dot rim by the same gap as a cardinal side.
         case "below-right": {
-          const d = (p.r + GAP) * 0.7071;
+          const d = (p.r + GAP2) * 0.7071;
           return { x: p.cx + d, y: p.cy + d, w, h: poiLabH };
         }
         case "below-left": {
-          const d = (p.r + GAP) * 0.7071;
+          const d = (p.r + GAP2) * 0.7071;
           return { x: p.cx - d - w, y: p.cy + d, w, h: poiLabH };
         }
         case "above-right": {
-          const d = (p.r + GAP) * 0.7071;
+          const d = (p.r + GAP2) * 0.7071;
           return { x: p.cx + d, y: p.cy - d - poiLabH, w, h: poiLabH };
         }
         case "above-left": {
-          const d = (p.r + GAP) * 0.7071;
+          const d = (p.r + GAP2) * 0.7071;
           return { x: p.cx - d - w, y: p.cy - d - poiLabH, w, h: poiLabH };
         }
       }
@@ -2692,10 +2972,10 @@ function layoutMap(resolvedIn, data, size, opts) {
     };
     const pushHidden = (p) => {
       const { text, w } = labelInfo(p);
-      let x = p.cx + p.r + GAP;
+      let x = p.cx + p.r + GAP2;
       let anchor = "start";
       if (x + w > width) {
-        x = p.cx - p.r - GAP - w;
+        x = p.cx - p.r - GAP2 - w;
         anchor = "end";
       }
       const y = Math.max(0, Math.min(p.cy - poiLabH / 2, height - poiLabH));
@@ -2892,15 +3172,15 @@ function layoutMap(resolvedIn, data, size, opts) {
     }
   }
   if (regionLabelGuards.length > 0) {
-    const PAD = 2;
+    const PAD2 = 2;
     const poiRects = labels.filter((l) => l.poiId !== void 0 && l.hidden !== true).map((l) => {
       const w = measureLegendText(l.text, FONT2);
       const x = l.anchor === "start" ? l.x : l.anchor === "end" ? l.x - w : l.x - w / 2;
       return {
-        x: x - PAD,
+        x: x - PAD2,
         y: l.y - FONT2,
-        w: w + 2 * PAD,
-        h: FONT2 * 1.4 + 2 * PAD
+        w: w + 2 * PAD2,
+        h: FONT2 * 1.4 + 2 * PAD2
       };
     });
     for (const g of regionLabelGuards) {
@@ -2910,79 +3190,21 @@ function layoutMap(resolvedIn, data, size, opts) {
       }
     }
   }
-  if (legs.some((lg) => lg.label !== void 0)) {
-    const committedBoxes = labels.filter((l) => !l.hidden).map((l) => {
-      const w = labelW(l.text);
-      const x = l.anchor === "start" ? l.x : l.anchor === "end" ? l.x - w : l.x - w / 2;
-      return { x, y: l.y - labelH / 2, w, h: labelH };
-    });
-    const placedEdge = [];
-    const T_LIST = [0.5, 0.42, 0.58, 0.34, 0.66, 0.28, 0.72];
-    for (let i = 0; i < legs.length; i++) {
-      const lg = legs[i];
-      if (lg.label === void 0) continue;
-      const a = poiScreen.get(lg.fromId);
-      const b = poiScreen.get(lg.toId);
-      if (!a || !b) continue;
-      const w = labelW(lg.label);
-      const dx = b.cx - a.cx;
-      const dy = b.cy - a.cy;
-      const len = Math.hypot(dx, dy) || 1;
-      const nx = -dy / len;
-      const ny = dx / len;
-      const perp = labelH + 2;
-      const stroke = lg.width ?? W_MIN;
-      const clearW = stroke / 2 + labelH / 2 + 3;
-      const offList = stroke >= 4 ? [clearW, -clearW, clearW + perp, -(clearW + perp), 0] : [0, perp, -perp, 2 * perp, -2 * perp];
-      const pm = /^M(-?[\d.]+),(-?[\d.]+)(?:L(-?[\d.]+),(-?[\d.]+)|Q(-?[\d.]+),(-?[\d.]+) (-?[\d.]+),(-?[\d.]+))$/.exec(
-        lg.d
-      );
-      const pointAt = (t) => {
-        if (pm?.[5] !== void 0) {
-          const u = 1 - t;
-          return [
-            u * u * +pm[1] + 2 * u * t * +pm[5] + t * t * +pm[7],
-            u * u * +pm[2] + 2 * u * t * +pm[6] + t * t * +pm[8]
-          ];
-        }
-        if (pm?.[3] !== void 0)
-          return [
-            +pm[1] + (+pm[3] - +pm[1]) * t,
-            +pm[2] + (+pm[4] - +pm[2]) * t
-          ];
-        return [a.cx + dx * t, a.cy + dy * t];
-      };
-      const candidates = [];
-      for (const off of offList)
-        for (const t of T_LIST) {
-          const [bx, by] = pointAt(t);
-          candidates.push([bx + nx * off, by + ny * off - 4]);
-        }
-      const clean = ([cx2, cy2]) => {
-        const rect2 = { x: cx2 - w / 2, y: cy2 - labelH / 2, w, h: labelH };
-        if (rect2.x < 0 || rect2.x + w > width || rect2.y < 0 || rect2.y + rect2.h > height)
-          return false;
-        if (markers.some((m) => rectCircleOverlap(rect2, m))) return false;
-        if (committedBoxes.some((o) => rectsOverlap(o, rect2))) return false;
-        if (placedEdge.some((o) => rectsOverlap(o, rect2))) return false;
-        return true;
-      };
-      const mid = pointAt(0.5);
-      const [cx, cy] = candidates.find(clean) ?? [mid[0], mid[1] - 4];
-      const style = labelOnFill(fillAt(cx, cy));
-      legs[i] = {
-        ...lg,
-        labelX: cx,
-        labelY: cy,
-        labelColor: style.color,
-        labelHalo: style.halo,
-        labelHaloColor: style.haloColor
-      };
-      const rect = { x: cx - w / 2, y: cy - labelH / 2, w, h: labelH };
-      placedEdge.push(rect);
-      obstacles.push(rect);
-    }
-  }
+  obstacles.push(
+    ...layoutEdgeLabels({
+      legs,
+      committed: labels,
+      poiScreen,
+      markers,
+      labelW: (text) => labelW(text),
+      labelH,
+      minStroke: W_MIN,
+      fillAt,
+      labelOnFill,
+      width,
+      height
+    })
+  );
   if (resolved.directives.noContextLabels !== true) {
     for (const l of labels) {
       if (l.hidden) continue;
@@ -3098,49 +3320,13 @@ function layoutMap(resolvedIn, data, size, opts) {
     });
     labels.push(...contextLabels);
   }
-  const cityDots = [];
-  if (resolved.directives.noCities !== true) {
-    const CITY_DOT_SPACING = 12;
-    const CITY_DOT_CAP = 220;
-    const SPACING_SQ = CITY_DOT_SPACING * CITY_DOT_SPACING;
-    const CITY_DOT_R_MIN = 0.7;
-    const CITY_DOT_R_MAX = 2.6;
-    const CITY_POP_MIN = 5e4;
-    const CITY_POP_MAX = 15e6;
-    const LOG_MIN = Math.log10(CITY_POP_MIN);
-    const LOG_SPAN = Math.log10(CITY_POP_MAX) - LOG_MIN;
-    const cityDotRadius = (pop) => {
-      if (!(pop > CITY_POP_MIN)) return CITY_DOT_R_MIN;
-      const t = Math.min(1, (Math.log10(pop) - LOG_MIN) / LOG_SPAN);
-      return CITY_DOT_R_MIN + t * (CITY_DOT_R_MAX - CITY_DOT_R_MIN);
-    };
-    const placed = pois.map((p) => ({
-      x: p.cx,
-      y: p.cy
-    }));
-    const sorted = [...data.gazetteer.cities].sort((a, b) => b[3] - a[3]);
-    for (const c of sorted) {
-      if (cityDots.length >= CITY_DOT_CAP) break;
-      const lat = c[0];
-      const lon = c[1];
-      const p = project(lon, lat);
-      if (!p) continue;
-      const [px, py] = p;
-      if (px < 0 || px > width || py < 0 || py > height) continue;
-      let tooClose = false;
-      for (const q of placed) {
-        const dx = q.x - px;
-        const dy = q.y - py;
-        if (dx * dx + dy * dy < SPACING_SQ) {
-          tooClose = true;
-          break;
-        }
-      }
-      if (tooClose) continue;
-      placed.push({ x: px, y: py });
-      cityDots.push({ cx: px, cy: py, r: cityDotRadius(c[3]) });
-    }
-  }
+  const cityDots = resolved.directives.noCities !== true ? layoutCityDots({
+    cities: data.gazetteer.cities,
+    occupied: pois.map((p) => ({ x: p.cx, y: p.cy })),
+    project,
+    width,
+    height
+  }) : [];
   return {
     width,
     height,
@@ -3177,4 +3363,4 @@ export {
   albersSkewFallback,
   layoutMap
 };
-//# sourceMappingURL=chunk-DXSRQLD4.js.map
+//# sourceMappingURL=chunk-37EHGTQ2.js.map