@diagrammo/dgmo 0.46.0 → 0.48.0

package/dist/chunk-IPWPWM6R.js

@@ -0,0 +1,3079 @@
+import {
+  buildAdjacency,
+  featureBboxPrimary,
+  pointInGeometry
+} from "./chunk-I5IGB56C.js";
+import {
+  rectCircleOverlap,
+  rectsOverlap,
+  segmentRectOverlap,
+  segmentsCross
+} from "./chunk-PBAHEPLQ.js";
+import {
+  compactNumber,
+  computeLegendLayout
+} from "./chunk-YAA6IID3.js";
+import {
+  TITLE_FONT_SIZE,
+  TITLE_Y
+} from "./chunk-A4GOY3PE.js";
+import {
+  measureLegendText
+} from "./chunk-QOOUC2J5.js";
+import {
+  contrastRatio,
+  mix,
+  politicalTints,
+  relativeLuminance,
+  valueRampColor
+} from "./chunk-P6T66CCZ.js";
+import {
+  tagAttrKey
+} from "./chunk-QLCCJEJI.js";
+import {
+  resolveColor
+} from "./chunk-TLVIHFRO.js";
+
+// src/map/legend-band.ts
+var LEGEND_TOP_GAP = 8;
+var LEGEND_BOTTOM_GAP = 10;
+function mapLegendGroups(legend) {
+  const ramp = legend.ramp;
+  const scoreGroup = ramp ? {
+    name: ramp.metric?.trim() || "Value",
+    entries: [],
+    gradient: {
+      min: ramp.min,
+      max: ramp.max,
+      low: ramp.low,
+      high: ramp.high
+    }
+  } : null;
+  const tagGroups = legend.tagGroups.filter((g) => g.entries.length > 0).map((g) => ({ name: g.name, entries: [...g.entries] }));
+  return [...scoreGroup ? [scoreGroup] : [], ...tagGroups];
+}
+function mapLegendConfig(groups, mode) {
+  return {
+    groups,
+    position: { placement: "top-center", titleRelation: "below-title" },
+    mode,
+    showEmptyGroups: false,
+    showInactivePills: true
+  };
+}
+function mapLegendTop(hasTitle, hasSubtitle) {
+  return (hasTitle ? TITLE_Y + TITLE_FONT_SIZE : 0) + (hasSubtitle ? TITLE_FONT_SIZE : 0) + LEGEND_TOP_GAP;
+}
+function mapLegendBand(legend, opts) {
+  if (!legend) return 0;
+  const groups = mapLegendGroups(legend);
+  if (groups.length === 0) return 0;
+  const config = mapLegendConfig(groups, opts.mode);
+  const state = { activeGroup: legend.activeGroup };
+  const { height } = computeLegendLayout(config, state, opts.width);
+  if (height <= 0) return 0;
+  return mapLegendTop(opts.hasTitle, opts.hasSubtitle) + height + LEGEND_BOTTOM_GAP;
+}
+function mapLegendBox(legend, opts) {
+  if (!legend) return null;
+  const groups = mapLegendGroups(legend);
+  if (groups.length === 0) return null;
+  const config = mapLegendConfig(groups, opts.mode);
+  const state = { activeGroup: legend.activeGroup };
+  const { width, height } = computeLegendLayout(config, state, opts.width);
+  if (height <= 0 || width <= 0) return null;
+  return {
+    x: (opts.width - width) / 2,
+    y: mapLegendTop(opts.hasTitle, opts.hasSubtitle),
+    width,
+    height
+  };
+}
+
+// src/map/layout.ts
+import {
+  geoPath,
+  geoNaturalEarth1,
+  geoEqualEarth,
+  geoEquirectangular,
+  geoConicEqualArea,
+  geoMercator,
+  geoBounds,
+  geoTransform
+} from "d3-geo";
+import { feature } from "topojson-client";
+
+// src/map/colorize.ts
+function assignColors(isos, adjacency) {
+  const sorted = [...isos].sort();
+  const byIso = /* @__PURE__ */ new Map();
+  let maxIndex = -1;
+  for (const iso of sorted) {
+    const taken = /* @__PURE__ */ new Set();
+    for (const n of adjacency.get(iso) ?? []) {
+      const c = byIso.get(n);
+      if (c !== void 0) taken.add(c);
+    }
+    let h = 0;
+    while (taken.has(h)) h++;
+    byIso.set(iso, h);
+    if (h > maxIndex) maxIndex = h;
+  }
+  return { byIso, huesNeeded: maxIndex + 1 };
+}
+
+// src/map/context-labels.ts
+var FONT = 11;
+var LINE_HEIGHT = FONT + 2;
+var PADX = 4;
+var PADY = 3;
+var WATER_LETTER_SPACING = 1.5;
+var CONTEXT_PAD = 4;
+var EDGE_CLAMP_MARGIN = 8;
+var EDGE_CLAMP_OVERSHOOT = 0.35;
+var COUNTRY_FONT_MAX = 22;
+var COUNTRY_SIZE_FRAC_MIN = 0.06;
+var COUNTRY_SIZE_FRAC_MAX = 0.32;
+var MAX_COUNTRY_POSITIONS = 4;
+var COUNTRY_POS_GRID = 5;
+var COUNTRY_POS_TOPN_MARGIN = 3;
+var KIND_ORDER = {
+  ocean: 0,
+  sea: 1,
+  gulf: 2,
+  bay: 3,
+  strait: 4,
+  channel: 5,
+  sound: 6
+};
+function tierBand(maxSpanDeg) {
+  if (maxSpanDeg >= 90) return "world";
+  if (maxSpanDeg >= 20) return "continental";
+  if (maxSpanDeg >= 5) return "regional";
+  return "local";
+}
+function labelBudget(width, height, band) {
+  const bandCap = {
+    world: 10,
+    continental: 9,
+    regional: 7,
+    local: 6
+  };
+  const area = Math.floor(Math.sqrt(Math.max(0, width * height)) / 105);
+  return Math.max(0, Math.min(area, bandCap[band]));
+}
+function waterEligible(tier, kind, band) {
+  switch (band) {
+    case "world":
+      return tier <= 1 && (kind === "ocean" || kind === "sea");
+    case "continental":
+      return tier <= 2;
+    case "regional":
+      return tier <= 3;
+    case "local":
+      return tier <= 4;
+  }
+}
+function insideViewport(p, width, height) {
+  return !!p && Number.isFinite(p[0]) && Number.isFinite(p[1]) && p[0] >= 0 && p[0] <= width && p[1] >= 0 && p[1] <= height;
+}
+function labelWidth(text, letterSpacing, font = FONT) {
+  const spacing = letterSpacing > 0 ? Math.max(0, text.length - 1) * letterSpacing : 0;
+  return measureLegendText(text, font) + spacing + 2 * PADX;
+}
+function wrapLabel(text, letterSpacing) {
+  const words = text.split(/\s+/).filter(Boolean);
+  if (words.length <= 1) return [text];
+  const maxLines = words.length >= 4 ? 3 : 2;
+  const n = words.length;
+  let best = null;
+  for (let mask = 0; mask < 1 << n - 1; mask++) {
+    const lines = [];
+    let cur = [words[0]];
+    for (let i = 1; i < n; i++) {
+      if (mask & 1 << i - 1) {
+        lines.push(cur.join(" "));
+        cur = [words[i]];
+      } else cur.push(words[i]);
+    }
+    lines.push(cur.join(" "));
+    if (lines.length > maxLines) continue;
+    const cost = Math.round(
+      Math.max(...lines.map((l) => labelWidth(l, letterSpacing)))
+    );
+    const head = labelWidth(lines[0], letterSpacing);
+    if (!best || cost < best.cost || cost === best.cost && lines.length < best.lines.length || cost === best.cost && lines.length === best.lines.length && head > best.head)
+      best = { lines, cost, head };
+  }
+  return best?.lines ?? [text];
+}
+function rectAround(cx, cy, lines, letterSpacing, font = FONT) {
+  const lineHeight = font + 2;
+  const w = Math.max(...lines.map((l) => labelWidth(l, letterSpacing, font)));
+  const h = (lines.length - 1) * lineHeight + font + 2 * PADY;
+  return { x: cx - w / 2, y: cy - h / 2, w, h };
+}
+function rectFits(r, width, height) {
+  return r.x >= 0 && r.y >= 0 && r.x + r.w <= width && r.y + r.h <= height;
+}
+function overlapsPadded(a, b, pad) {
+  return a.x - pad < b.x + b.w && a.x + a.w + pad > b.x && a.y - pad < b.y + b.h && a.y + a.h + pad > b.y;
+}
+function placeContextLabels(args) {
+  const {
+    projection,
+    dLonSpan,
+    dLatSpan,
+    width,
+    height,
+    waterBodies,
+    countries,
+    palette,
+    countryTone,
+    waterTone,
+    project,
+    collides,
+    overLand
+  } = args;
+  void projection;
+  const band = tierBand(Math.max(dLonSpan, dLatSpan));
+  const budget = labelBudget(width, height, band);
+  if (budget <= 0) return [];
+  const waterColor = waterTone ?? mix(palette.colors.blue, palette.textMuted, 50);
+  const countryColor = countryTone ?? palette.textMuted;
+  const haloColor = palette.bg;
+  const candidates = [];
+  const center = [width / 2, height / 2];
+  for (const e of waterBodies?.entries ?? []) {
+    const [lat, lon, name, tier, kind, alt] = e;
+    if (!waterEligible(tier, kind, band)) continue;
+    const wlines = wrapLabel(name, WATER_LETTER_SPACING);
+    const anchorsLngLat = [[lon, lat]];
+    for (const a of alt ?? []) anchorsLngLat.push([a[1], a[0]]);
+    let best = null;
+    let bestD = Infinity;
+    let nearestProj = null;
+    let nearestProjD = Infinity;
+    for (const [aLon, aLat] of anchorsLngLat) {
+      const p = project(aLon, aLat);
+      if (!p || !Number.isFinite(p[0]) || !Number.isFinite(p[1])) continue;
+      const d = (p[0] - center[0]) ** 2 + (p[1] - center[1]) ** 2;
+      if (d < nearestProjD) {
+        nearestProjD = d;
+        nearestProj = p;
+      }
+      if (!insideViewport(p, width, height)) continue;
+      if (d < bestD) {
+        bestD = d;
+        best = p;
+      }
+    }
+    if (!best && tier === 0 && nearestProj) {
+      const overX = Math.max(0, -nearestProj[0], nearestProj[0] - width);
+      const overY = Math.max(0, -nearestProj[1], nearestProj[1] - height);
+      if (overX <= width * EDGE_CLAMP_OVERSHOOT && overY <= height * EDGE_CLAMP_OVERSHOOT) {
+        const halfW = Math.max(...wlines.map((l) => labelWidth(l, WATER_LETTER_SPACING))) / 2;
+        const halfH = ((wlines.length - 1) * LINE_HEIGHT + FONT + 2 * PADY) / 2;
+        const m = EDGE_CLAMP_MARGIN;
+        best = [
+          Math.min(Math.max(nearestProj[0], halfW + m), width - halfW - m),
+          Math.min(Math.max(nearestProj[1], halfH + m), height - halfH - m)
+        ];
+      }
+    }
+    if (!best) continue;
+    candidates.push({
+      text: name,
+      lines: wlines,
+      cx: best[0],
+      cy: best[1],
+      italic: true,
+      letterSpacing: WATER_LETTER_SPACING,
+      color: waterColor,
+      fontSize: FONT,
+      // water names keep the base font (no footprint to scale on)
+      // Orientation-value bands (lower = earlier): MAJOR water (oceans + major
+      // seas, tier ≤ 1) leads at `tier*10+kind` (0..~16); MINOR water (tier ≥ 2:
+      // smaller seas, bays, gulfs, straits) drops to band 2 (2000+) — BELOW the
+      // country band (1000+), so a big country outranks a minor basin.
+      sort: (tier <= 1 ? 0 : 2e3) + tier * 10 + KIND_ORDER[kind]
+    });
+  }
+  const ranked = countries.map((c) => {
+    const [x0, y0, x1, y1] = c.bbox;
+    const w = x1 - x0;
+    const h = y1 - y0;
+    return { c, w, h, area: w * h };
+  }).filter((r) => Number.isFinite(r.area) && r.area > 0).sort((a, b) => b.area - a.area);
+  const canvasLinear = Math.sqrt(Math.max(1, width * height));
+  let ci = 0;
+  for (const r of ranked) {
+    const { c, w, h, area } = r;
+    if (!c.curatedAnchor && w > width * 0.66 && h > height * 0.66) continue;
+    if (!insideViewport(c.anchor, width, height)) continue;
+    const sizeFrac = Math.sqrt(area) / canvasLinear;
+    const t = Math.min(
+      1,
+      Math.max(
+        0,
+        (sizeFrac - COUNTRY_SIZE_FRAC_MIN) / (COUNTRY_SIZE_FRAC_MAX - COUNTRY_SIZE_FRAC_MIN)
+      )
+    );
+    const fontSize = Math.round(FONT + t * (COUNTRY_FONT_MAX - FONT));
+    const color = countryColor;
+    const text = c.name;
+    const tw = labelWidth(text, 0, fontSize);
+    if (tw > w || fontSize + 2 * PADY > h) continue;
+    candidates.push({
+      text,
+      lines: [text],
+      cx: c.anchor[0],
+      cy: c.anchor[1],
+      italic: false,
+      letterSpacing: 0,
+      color,
+      fontSize,
+      ...c.bordering ? { bordering: true } : {},
+      // Multi-position dodging: carry the ordered interior positions through to the
+      // commit loop. Invariant anchor === positions[0], so `cx/cy` is positions[0].
+      ...c.positions ? { positions: c.positions } : {},
+      // Band 1 (orientation-value ranking): above MINOR water (band 2, 2000+) but
+      // below MAJOR water — oceans + major seas (band 0, ≤~16). So a big country
+      // (US, Canada, Russia) outranks a minor sea/bay (Sargasso, Bahía de
+      // Campeche) yet never displaces an ocean. Larger area = earlier within the
+      // band (`ci` is the area-desc rank index).
+      sort: 1e3 + ci++
+    });
+  }
+  candidates.sort((a, b) => a.sort - b.sort);
+  const placed = [];
+  const placedRects = [];
+  const stateCount = candidates.reduce(
+    (n, c) => n + (!c.italic && !c.bordering ? 1 : 0),
+    0
+  );
+  const waterCap = budget - Math.min(2, stateCount);
+  let waterPlaced = 0;
+  let budgetUsed = 0;
+  const gateAt = (cx, cy, cand) => {
+    const rect = rectAround(
+      cx,
+      cy,
+      cand.lines,
+      cand.letterSpacing,
+      cand.fontSize
+    );
+    if (!rectFits(rect, width, height)) return null;
+    if (cand.italic && overLand) {
+      const inset = 2;
+      const top = cy - (cand.lines.length - 1) / 2 * LINE_HEIGHT;
+      const touchesLand = cand.lines.some((line, li) => {
+        const lw = labelWidth(line, cand.letterSpacing);
+        const x0 = cx - lw / 2 + inset;
+        const x1 = cx + lw / 2 - inset;
+        const xs = [x0, (x0 + cx) / 2, cx, (cx + x1) / 2, x1];
+        const base = top + li * LINE_HEIGHT;
+        return [base, base - FONT * 0.4, base - FONT * 0.8].some(
+          (y) => xs.some((x) => overLand(x, y))
+        );
+      });
+      if (touchesLand) return null;
+    }
+    if (collides(rect)) return null;
+    if (placedRects.some((r) => overlapsPadded(rect, r, CONTEXT_PAD)))
+      return null;
+    return rect;
+  };
+  const tryPlace = (cand) => {
+    const positions = cand.positions ?? [[cand.cx, cand.cy]];
+    for (const [px, py] of positions) {
+      const rect = gateAt(px, py, cand);
+      if (!rect) continue;
+      placedRects.push(rect);
+      placed.push({
+        x: px,
+        y: py,
+        text: cand.text,
+        anchor: "middle",
+        color: cand.color,
+        // No halo: the bg-coloured outline reads as a ghost box behind the text
+        // over the tinted water/land. Context labels are muted enough to sit
+        // cleanly on the basemap without one.
+        halo: false,
+        haloColor,
+        fontSize: cand.fontSize,
+        italic: cand.italic,
+        letterSpacing: cand.letterSpacing,
+        ...cand.lines.length > 1 ? { lines: cand.lines } : {},
+        lineNumber: 0
+      });
+      return true;
+    }
+    return false;
+  };
+  for (const cand of candidates) if (cand.bordering) tryPlace(cand);
+  for (const cand of candidates) {
+    if (cand.bordering) continue;
+    if (budgetUsed >= budget) break;
+    if (cand.italic && waterPlaced >= waterCap) continue;
+    if (tryPlace(cand)) {
+      budgetUsed++;
+      if (cand.italic) waterPlaced++;
+    }
+  }
+  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;
+        }
+      }
+      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();
+    }
+  });
+}
+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 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] }
+  };
+}
+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;
+      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 (!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 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 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 {
+      type: "Feature",
+      properties: {},
+      geometry: { type: "MultiPoint", coordinates: coords }
+    };
+  };
+  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);
+      }
+    }
+  } 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
+  };
+}
+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]);
+    }
+  }
+  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 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);
+  }
+  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;
+  };
+  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 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 palette.text;
+  };
+  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]);
+      }
+    };
+    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 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);
+  };
+  const regionFill = (r) => {
+    const direct = directFill(r.color);
+    if (direct) return direct;
+    if (activeIsScore) {
+      return r.value !== void 0 ? fillForValue(r.value) : neutralFill;
+    }
+    if (colorizeActive) return (r.iso && colorByIso.get(r.iso)) ?? neutralFill;
+    return tagFill(r.tags, activeGroup) ?? neutralFill;
+  };
+  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 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];
+          }
+        }
+      }
+    }
+    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 (!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]);
+      }
+    }
+  }
+  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);
+      }
+    });
+    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 });
+      }
+      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;
+    }
+    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];
+    }
+    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;
+    }
+    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 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 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 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 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 }
+      });
+    }
+  };
+  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 inside;
+  };
+  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];
+      }
+    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 });
+    }
+  }
+  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 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 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 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;
+    }
+    return null;
+  };
+  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 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 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 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 = [];
+  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;
+  };
+  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 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 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 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 lp = legLabelPoint(a, b, leg.style === "arc", 0, center);
+      const bow = {
+        curved: leg.style === "arc",
+        offset: 0,
+        center,
+        labelX: lp.x,
+        labelY: lp.y
+      };
+      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 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 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]);
+  }
+  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 lp = legLabelPoint(a, b, curved, fanOffset);
+      const bow = {
+        curved,
+        offset: fanOffset,
+        labelX: lp.x,
+        labelY: lp.y
+      };
+      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
+        }
+      });
+    });
+  }
+  const labels = [];
+  const obstacles = [...topReserved];
+  const regionLabelGuards = [];
+  const markers = pois.map((p) => ({
+    cx: p.cx,
+    cy: p.cy,
+    r: p.r
+  }));
+  const legSegments = [];
+  for (const leg of legs) {
+    const m = /^M(-?[\d.]+),(-?[\d.]+)(?:L(-?[\d.]+),(-?[\d.]+)|Q(-?[\d.]+),(-?[\d.]+) (-?[\d.]+),(-?[\d.]+))$/.exec(
+      leg.d
+    );
+    if (!m) continue;
+    const x0 = +m[1];
+    const y0 = +m[2];
+    if (m[3] !== void 0) {
+      legSegments.push([x0, y0, +m[3], +m[4]]);
+    } else {
+      const cx = +m[5];
+      const cy = +m[6];
+      const ex = +m[7];
+      const ey = +m[8];
+      const N = 8;
+      let px = x0;
+      let py = y0;
+      for (let i = 1; i <= N; i++) {
+        const t = i / N;
+        const u = 1 - t;
+        const qx = u * u * x0 + 2 * u * t * cx + t * t * ex;
+        const qy = u * u * y0 + 2 * u * t * cy + t * t * ey;
+        legSegments.push([px, py, qx, qy]);
+        px = qx;
+        py = qy;
+      }
+    }
+  }
+  const collides = (rect) => markers.some((m) => rectCircleOverlap(rect, m)) || obstacles.some((o) => rectsOverlap(rect, o)) || legSegments.some((s) => segmentRectOverlap(s[0], s[1], s[2], s[3], rect));
+  const showRegionLabels = resolved.directives.noRegionLabels !== true;
+  const labeledRegionIds = /* @__PURE__ */ new Set();
+  const showRegionValues = resolved.directives.noRegionValue !== true && activeIsScore;
+  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 pushRegionLabel = (x, y, text, fill, lineNumber, valueLine, fontSize = FONT2, colorOverride) => {
+    const { color: baseColor, haloColor } = labelOnFill(fill);
+    const color = colorOverride ?? baseColor;
+    const vf = Math.round(fontSize * 0.82);
+    const halfW = Math.max(
+      measureLegendText(text, fontSize),
+      valueLine ? measureLegendText(valueLine, vf) : 0
+    ) / 2;
+    const overflows = [y - fontSize * 0.55, y - fontSize * 0.1].some(
+      (sy) => fillAt(x - halfW, sy) !== fill || fillAt(x + halfW, sy) !== fill
+    );
+    labels.push({
+      x,
+      y,
+      text,
+      anchor: "middle",
+      color,
+      // A backdrop label (colorOverride) NEVER haloes: the placement gate above
+      // guarantees it sits on a floored-readable substrate (own fill, neutral
+      // land, foreign land, or water), so a halo is pure noise. Data labels keep
+      // the containment-gated halo until the role-tier pass (Phase 3).
+      halo: colorOverride ? false : overflows,
+      haloColor,
+      ...fontSize !== FONT2 && { fontSize },
+      ...valueLine !== void 0 && { valueLine },
+      lineNumber
+    });
+  };
+  const REGION_LABEL_GAP = 2;
+  const regionLabelRect = (cx, cy, text, valueText, font = FONT2) => {
+    const vf = Math.round(font * 0.82);
+    const w = Math.max(
+      measureLegendText(text, font),
+      valueText ? measureLegendText(valueText, vf) : 0
+    ) + 2 * REGION_LABEL_GAP;
+    const h = valueText ? font + VALUE_GAP + vf : font;
+    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)
+      });
+    }
+  }
+  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));
+    const poiById = new Map(resolved.pois.map((q) => [q.id, q]));
+    const labelText = (p) => {
+      const src = poiById.get(p.id);
+      return src?.label ?? src?.name ?? p.id;
+    };
+    const poiLabH = FONT2 * 1.25;
+    const labelInfo = (p) => {
+      const text = labelText(p);
+      return { text, w: measureLegendText(text, FONT2) };
+    };
+    const GAP = 3;
+    const POI_EDGE_CLEAR = Math.max(
+      20,
+      Math.round(Math.min(width, height) * 0.03)
+    );
+    const clusterMembersById = /* @__PURE__ */ new Map();
+    for (const p of pois) {
+      if (p.clusterId === void 0) continue;
+      const arr = clusterMembersById.get(p.clusterId);
+      if (arr) arr.push(p);
+      else clusterMembersById.set(p.clusterId, [p]);
+    }
+    const inlineRect = (p, w, side) => {
+      switch (side) {
+        case "right":
+          return { x: p.cx + p.r + GAP, y: p.cy - poiLabH / 2, w, h: poiLabH };
+        case "left":
+          return {
+            x: p.cx - p.r - GAP - w,
+            y: p.cy - poiLabH / 2,
+            w,
+            h: poiLabH
+          };
+        case "above":
+          return {
+            x: p.cx - w / 2,
+            y: p.cy - p.r - GAP - poiLabH,
+            w,
+            h: poiLabH
+          };
+        case "below":
+          return { x: p.cx - w / 2, y: p.cy + p.r + GAP, 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;
+          return { x: p.cx + d, y: p.cy + d, w, h: poiLabH };
+        }
+        case "below-left": {
+          const d = (p.r + GAP) * 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;
+          return { x: p.cx + d, y: p.cy - d - poiLabH, w, h: poiLabH };
+        }
+        case "above-left": {
+          const d = (p.r + GAP) * 0.7071;
+          return { x: p.cx - d - w, y: p.cy - d - poiLabH, w, h: poiLabH };
+        }
+      }
+    };
+    const pushInline = (p, text, w, side, clusterId) => {
+      const rect = inlineRect(p, w, side);
+      obstacles.push(rect);
+      const startSide = side === "right" || side === "below-right" || side === "above-right";
+      const endSide = side === "left" || side === "below-left" || side === "above-left";
+      const anchor = startSide ? "start" : endSide ? "end" : "middle";
+      const x = startSide ? rect.x : endSide ? rect.x + w : p.cx;
+      labels.push({
+        x,
+        y: rect.y + poiLabH / 2 + FONT2 / 3,
+        text,
+        anchor,
+        color: palette.text,
+        halo: false,
+        haloColor: palette.bg,
+        poiId: p.id,
+        lineNumber: p.lineNumber,
+        ...clusterId !== void 0 && { clusterMember: clusterId }
+      });
+    };
+    const inlineFits = (p, w, side) => {
+      const rect = inlineRect(p, w, side);
+      return rect.x >= 0 && rect.x + rect.w <= width && rect.y >= 0 && rect.y + rect.h <= height && !collides(rect);
+    };
+    const GROUP_R = 30;
+    const groups2 = [];
+    for (const p of ordered) {
+      const near = groups2.find(
+        (g) => g.some((q) => Math.hypot(q.cx - p.cx, q.cy - p.cy) < GROUP_R)
+      );
+      if (near) near.push(p);
+      else groups2.push([p]);
+    }
+    const ROW_GAP = 3;
+    const step = poiLabH + ROW_GAP;
+    const COL_GAP = 16;
+    const makeItems = (group) => group.map((p) => ({ p, ...labelInfo(p) })).sort((a, b) => a.p.cy - b.p.cy || (a.text < b.text ? -1 : 1));
+    const columnRows = (items, side) => {
+      const left = Math.min(...items.map((o) => o.p.cx - o.p.r));
+      const right = Math.max(...items.map((o) => o.p.cx + o.p.r));
+      const maxW = Math.max(...items.map((o) => o.w));
+      const cyMid = (Math.min(...items.map((o) => o.p.cy)) + Math.max(...items.map((o) => o.p.cy))) / 2;
+      const colX = side === "right" ? Math.min(right + COL_GAP, width - POI_EDGE_CLEAR - maxW) : Math.max(left - COL_GAP, POI_EDGE_CLEAR + maxW);
+      const totalH = items.length * step;
+      let startY = cyMid - totalH / 2;
+      startY = Math.max(
+        POI_EDGE_CLEAR,
+        Math.min(startY, height - totalH - POI_EDGE_CLEAR)
+      );
+      return items.map((o, i) => {
+        const rowCy = startY + i * step + step / 2;
+        return {
+          o,
+          colX,
+          rowCy,
+          rect: {
+            x: side === "right" ? colX : colX - o.w,
+            y: rowCy - poiLabH / 2,
+            w: o.w,
+            h: poiLabH
+          }
+        };
+      });
+    };
+    const wouldColumnBeClean = (items, side) => columnRows(items, side).every(
+      ({ rect }) => rect.x >= 0 && rect.x + rect.w <= width && rect.y >= 0 && rect.y + rect.h <= height && !collides(rect)
+    );
+    const WATER_PREF = 1e3;
+    const openness = (rect) => {
+      const xs = [
+        rect.x + rect.w * 0.15,
+        rect.x + rect.w * 0.5,
+        rect.x + rect.w * 0.85
+      ];
+      const ys = [rect.y + rect.h * 0.25, rect.y + rect.h * 0.75];
+      let waterHits = 0;
+      for (const x of xs)
+        for (const y of ys) if (fillAt(x, y) === water) waterHits++;
+      const waterFrac = waterHits / (xs.length * ys.length);
+      const edgeClear = Math.max(
+        0,
+        Math.min(
+          rect.x,
+          width - (rect.x + rect.w),
+          rect.y,
+          height - (rect.y + rect.h)
+        )
+      );
+      return WATER_PREF * waterFrac + edgeClear * 0.1;
+    };
+    const columnSideScore = (items, side) => {
+      const rows = columnRows(items, side);
+      if (rows.length === 0) return -Infinity;
+      return rows.reduce((s, { rect }) => s + openness(rect), 0) / rows.length;
+    };
+    const defaultColumnSide = (items) => columnSideScore(items, "right") >= columnSideScore(items, "left") ? "right" : "left";
+    const commitColumn = (items, side, clusterId) => {
+      for (const { o, colX, rowCy, rect } of columnRows(items, side)) {
+        obstacles.push(rect);
+        labels.push({
+          x: colX,
+          y: rowCy + FONT2 / 3,
+          text: o.text,
+          anchor: side === "right" ? "start" : "end",
+          color: palette.text,
+          halo: false,
+          haloColor: palette.bg,
+          leader: {
+            x1: o.p.cx,
+            y1: o.p.cy,
+            x2: side === "right" ? colX - 2 : colX + 2,
+            y2: rowCy
+          },
+          leaderColor: o.p.fill,
+          poiId: o.p.id,
+          lineNumber: o.p.lineNumber,
+          ...clusterId !== void 0 && { clusterMember: clusterId }
+        });
+      }
+    };
+    const pushHidden = (p) => {
+      const { text, w } = labelInfo(p);
+      let x = p.cx + p.r + GAP;
+      let anchor = "start";
+      if (x + w > width) {
+        x = p.cx - p.r - GAP - w;
+        anchor = "end";
+      }
+      const y = Math.max(0, Math.min(p.cy - poiLabH / 2, height - poiLabH));
+      labels.push({
+        x: anchor === "start" ? x : x + w,
+        y: y + poiLabH / 2 + FONT2 / 3,
+        text,
+        anchor,
+        color: palette.text,
+        halo: false,
+        haloColor: palette.bg,
+        poiId: p.id,
+        hidden: true,
+        lineNumber: p.lineNumber
+      });
+    };
+    const STACK_RADIAL_MAX = 4;
+    const radialSide = (p, cx, cy) => {
+      const dx = p.cx - cx;
+      const dy = p.cy - cy;
+      return Math.abs(dy) >= Math.abs(dx) ? dy <= 0 ? "above" : "below" : dx < 0 ? "left" : "right";
+    };
+    const tryStackRadial = (items, clusterId) => {
+      const cluster = clusters.find((c) => c.id === clusterId);
+      if (!cluster || items.length > STACK_RADIAL_MAX) return false;
+      const temp = [];
+      const seated = [];
+      for (const { p, text, w } of items) {
+        const pref = radialSide(p, cluster.cx, cluster.cy);
+        const order = [
+          pref,
+          ...["above", "below", "right", "left"].filter(
+            (s) => s !== pref
+          )
+        ];
+        const side = order.find((s) => {
+          const rect = inlineRect(p, w, s);
+          return rect.x >= 0 && rect.x + rect.w <= width && rect.y >= 0 && rect.y + rect.h <= height && !collides(rect) && !temp.some((t) => rectsOverlap(t, rect));
+        });
+        if (side === void 0) return false;
+        temp.push(inlineRect(p, w, side));
+        seated.push({ p, text, w, side });
+      }
+      for (const { p, text, w, side } of seated)
+        pushInline(p, text, w, side, clusterId);
+      return true;
+    };
+    for (const [clusterId, members] of clusterMembersById) {
+      if (members.length === 0) continue;
+      const items = makeItems(members);
+      if (tryStackRadial(items, clusterId)) continue;
+      const cleanR = wouldColumnBeClean(items, "right");
+      const cleanL = wouldColumnBeClean(items, "left");
+      const side = cleanR && cleanL ? defaultColumnSide(items) : cleanR ? "right" : cleanL ? "left" : defaultColumnSide(items);
+      commitColumn(items, side, clusterId);
+    }
+    const CLEAR_CAP = 48;
+    const CLEAR_W = 8;
+    const WATER_W = 0.25;
+    const ptSegDist = (px, py, ax, ay, bx, by) => {
+      const dx = bx - ax;
+      const dy = by - ay;
+      const len2 = dx * dx + dy * dy;
+      let t = len2 > 0 ? ((px - ax) * dx + (py - ay) * dy) / len2 : 0;
+      t = Math.max(0, Math.min(1, t));
+      return Math.hypot(px - (ax + t * dx), py - (ay + t * dy));
+    };
+    const clearanceOf = (rect, ownId) => {
+      const cxL = rect.x + rect.w / 2;
+      const cyL = rect.y + rect.h / 2;
+      let d = CLEAR_CAP;
+      for (const q of pois) {
+        if (q.id === ownId) continue;
+        d = Math.min(d, Math.hypot(q.cx - cxL, q.cy - cyL) - q.r);
+      }
+      for (const s of legSegments)
+        d = Math.min(d, ptSegDist(cxL, cyL, s[0], s[1], s[2], s[3]));
+      return Math.max(0, d);
+    };
+    const LEGIBILITY = {
+      right: 160,
+      left: 160,
+      above: 100,
+      below: 100,
+      "below-right": 0,
+      "below-left": 0,
+      "above-right": 0,
+      "above-left": 0
+    };
+    const ALL_SIDES = Object.keys(LEGIBILITY);
+    const placementScore = (p, w, side) => {
+      const rect = inlineRect(p, w, side);
+      return CLEAR_W * clearanceOf(rect, p.id) + WATER_W * openness(rect) + LEGIBILITY[side];
+    };
+    const maxExtent = MAX_CLUSTER_EXTENT_FACTOR * Math.min(width, height);
+    const clusterPending = [];
+    for (const g of groups2) {
+      const items = makeItems(g);
+      if (g.length === 1) {
+        const { p, text, w } = items[0];
+        const scored = ALL_SIDES.filter((s) => inlineFits(p, w, s)).map(
+          (s) => ({
+            s,
+            v: placementScore(p, w, s)
+          })
+        );
+        if (scored.length === 0) {
+          commitColumn(items, defaultColumnSide(items));
+          continue;
+        }
+        const side = scored.reduce((b, c) => c.v > b.v ? c : b).s;
+        pushInline(p, text, w, side);
+        continue;
+      }
+      const left = Math.min(...items.map((o) => o.p.cx - o.p.r));
+      const right = Math.max(...items.map((o) => o.p.cx + o.p.r));
+      const minCy = Math.min(...items.map((o) => o.p.cy));
+      const maxCy = Math.max(...items.map((o) => o.p.cy));
+      const diag = Math.hypot(right - left, maxCy - minCy);
+      if (diag > maxExtent || items.length > MAX_COLUMN_ROWS) {
+        items.forEach((o) => pushHidden(o.p));
+      } else {
+        clusterPending.push(items);
+      }
+    }
+    for (const items of clusterPending) {
+      const cleanSides = ["right", "left"].filter(
+        (s) => wouldColumnBeClean(items, s)
+      );
+      const side = cleanSides.length > 1 ? defaultColumnSide(items) : cleanSides[0];
+      if (side) commitColumn(items, side);
+      else items.forEach((o) => pushHidden(o.p));
+    }
+    const clearancePass = opts._poiClearancePass ?? 0;
+    const MAX_CLEARANCE_PASSES = 4;
+    if (clearancePass < MAX_CLEARANCE_PASSES && pois.length > 0) {
+      const EDGE_CLEAR = POI_EDGE_CLEAR;
+      const capH = Math.floor(width * 0.3);
+      const capV = Math.floor(height * 0.3);
+      const poiById2 = new Map(pois.map((p) => [p.id, p]));
+      let needLeft = 0;
+      let needRight = 0;
+      let needTop = 0;
+      let needBottom = 0;
+      for (const p of pois) {
+        needLeft = Math.max(needLeft, EDGE_CLEAR - (p.cx - p.r));
+        needRight = Math.max(needRight, p.cx + p.r + EDGE_CLEAR - width);
+        needTop = Math.max(needTop, EDGE_CLEAR - (p.cy - p.r));
+        needBottom = Math.max(needBottom, p.cy + p.r + EDGE_CLEAR - height);
+      }
+      for (const l of labels) {
+        if (l.poiId === void 0) continue;
+        const p = poiById2.get(l.poiId);
+        if (!p) continue;
+        if (l.hidden || l.leader) {
+          const lw = l.hidden ? labelInfo(p).w : measureLegendText(l.text, FONT2);
+          const reach = p.r + COL_GAP + lw + EDGE_CLEAR;
+          if (p.cx >= width / 2)
+            needRight = Math.max(needRight, p.cx + reach - width);
+          else needLeft = Math.max(needLeft, reach - p.cx);
+          continue;
+        }
+        const w = measureLegendText(l.text, FONT2);
+        const boxLeft = l.anchor === "start" ? l.x : l.anchor === "end" ? l.x - w : l.x - w / 2;
+        const boxTop = l.y - FONT2 / 3 - poiLabH / 2;
+        const boxRight = boxLeft + w;
+        const boxBottom = boxTop + poiLabH;
+        needLeft = Math.max(needLeft, EDGE_CLEAR - boxLeft);
+        needRight = Math.max(needRight, boxRight + EDGE_CLEAR - width);
+        needTop = Math.max(needTop, EDGE_CLEAR - boxTop);
+        needBottom = Math.max(needBottom, boxBottom + EDGE_CLEAR - height);
+      }
+      needLeft = Math.min(Math.max(0, Math.ceil(needLeft)), capH);
+      needRight = Math.min(Math.max(0, Math.ceil(needRight)), capH);
+      needTop = Math.min(Math.max(0, Math.ceil(needTop)), capV);
+      needBottom = Math.min(Math.max(0, Math.ceil(needBottom)), capV);
+      if (needLeft >= 1 || needRight >= 1 || needTop >= 1 || needBottom >= 1) {
+        const prev = opts._calloutReserve;
+        const left = Math.min((prev?.left ?? 0) + needLeft, capH);
+        const right = Math.min((prev?.right ?? 0) + needRight, capH);
+        const top = Math.min((prev?.top ?? 0) + needTop, capV);
+        const bottom = Math.min((prev?.bottom ?? 0) + needBottom, capV);
+        return layoutMap(resolved, data, size, {
+          ...opts,
+          _poiClearancePass: clearancePass + 1,
+          _calloutReserve: {
+            ...left > 0 && { left },
+            ...right > 0 && { right },
+            ...top > 0 && { top },
+            ...bottom > 0 && { bottom }
+          }
+        });
+      }
+    }
+  }
+  if (regionLabelGuards.length > 0) {
+    const PAD = 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,
+        y: l.y - FONT2,
+        w: w + 2 * PAD,
+        h: FONT2 * 1.4 + 2 * PAD
+      };
+    });
+    for (const g of regionLabelGuards) {
+      if (poiRects.some((pr) => rectsOverlap(pr, g.rect))) {
+        const i = labels.indexOf(g.label);
+        if (i >= 0) labels.splice(i, 1);
+      }
+    }
+  }
+  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);
+    }
+  }
+  if (resolved.directives.noContextLabels !== true) {
+    for (const l of labels) {
+      if (l.hidden) continue;
+      const w = labelW(l.text);
+      const x = l.anchor === "start" ? l.x : l.anchor === "end" ? l.x - w : l.x - w / 2;
+      obstacles.push({ x, y: l.y - labelH / 2, w, h: labelH });
+    }
+    for (const box of insets)
+      obstacles.push({ x: box.x, y: box.y, w: box.w, h: box.h });
+    const countryCandidates = [];
+    const rawCountries = [];
+    for (const f of worldLayer.values()) {
+      const iso = typeof f.id === "string" ? f.id : String(f.id ?? "");
+      if (!iso || regionById.has(iso) || labeledRegionIds.has(iso)) continue;
+      if (usContext && iso === "US") continue;
+      let hasReferencedSub = false;
+      for (const k of regionById.keys())
+        if (k.startsWith(iso + "-")) {
+          hasReferencedSub = true;
+          break;
+        }
+      if (hasReferencedSub) continue;
+      const b = path.bounds(f);
+      const [x0, y0] = b[0];
+      const [x1, y1] = b[1];
+      if (!Number.isFinite(x0) || !Number.isFinite(x1)) continue;
+      const anchorLngLat = WORLD_LABEL_ANCHORS[iso];
+      const a = anchorLngLat ? project(anchorLngLat[0], anchorLngLat[1]) : path.centroid(f);
+      rawCountries.push({
+        f,
+        iso,
+        name: f.properties?.name ?? iso,
+        bbox: [x0, y0, x1, y1],
+        anchor: a && Number.isFinite(a[0]) ? [a[0], a[1]] : null,
+        curatedLngLat: anchorLngLat ?? null,
+        area: (x1 - x0) * (y1 - y0)
+      });
+    }
+    const cBand = tierBand(Math.max(dLonSpan, dLatSpan));
+    const cBudget = labelBudget(width, height, cBand);
+    const nationsUnconditional = cBand !== "world";
+    const topN = cBudget + COUNTRY_POS_TOPN_MARGIN;
+    const rankOrder = rawCountries.map((r, idx) => ({ idx, area: r.area })).filter((r) => Number.isFinite(r.area) && r.area > 0).sort((a, b) => b.area - a.area).slice(0, topN);
+    const genIdx = new Set(rankOrder.map((r) => r.idx));
+    for (let i = 0; i < rawCountries.length; i++) {
+      const r = rawCountries[i];
+      let anchor = r.anchor;
+      let positions;
+      if (genIdx.has(i) && anchor) {
+        const gb = geoBounds(r.f);
+        const gen = countryLabelPositions({
+          geometry: r.f.geometry,
+          bounds: gb,
+          project,
+          width,
+          height,
+          curated: r.curatedLngLat
+        });
+        if (gen.length) {
+          positions = gen.map((p) => p.screen);
+          anchor = positions[0];
+        }
+      }
+      countryCandidates.push({
+        name: r.name,
+        bbox: r.bbox,
+        anchor,
+        curatedAnchor: !!r.curatedLngLat,
+        bordering: nationsUnconditional,
+        ...positions ? { positions } : {}
+      });
+    }
+    const framedStateContainers = (resolved.poiFrameContainers ?? []).some(
+      (id) => id.startsWith("US-")
+    );
+    if (usLayer && framedStateContainers) {
+      for (const [iso, f] of usLayer) {
+        if (regionById.has(iso) || labeledRegionIds.has(iso)) continue;
+        const viewF = cullFeatureToView(f);
+        if (!viewF) continue;
+        const b = path.bounds(viewF);
+        const [x0, y0] = b[0];
+        const [x1, y1] = b[1];
+        if (!Number.isFinite(x0) || !Number.isFinite(x1)) continue;
+        const a = path.centroid(viewF);
+        countryCandidates.push({
+          name: f.properties?.name ?? iso,
+          bbox: [x0, y0, x1, y1],
+          anchor: a && Number.isFinite(a[0]) ? [a[0], a[1]] : null
+        });
+      }
+    }
+    const contextLabels = placeContextLabels({
+      projection: resolved.projection,
+      dLonSpan,
+      dLatSpan,
+      width,
+      height,
+      waterBodies: data.waterBodies,
+      countries: countryCandidates,
+      palette,
+      // One muted, contrast-floored tone shared with the orientation backdrop
+      // (region pass) so a context country (Canada) and an orientation region
+      // (Minnesota) read identically — never below the WCAG-AA floor, no fade.
+      countryTone: backdropLandTone,
+      waterTone: backdropWaterTone,
+      project,
+      collides,
+      // Water labels must stay over open water — `fillAt` returns the ocean
+      // backdrop colour off-land and a region fill on-land (lakes/states count
+      // as land here, which is the safe side for an ocean name).
+      overLand: (x, y) => fillAt(x, y) !== water
+    });
+    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]) });
+    }
+  }
+  return {
+    width,
+    height,
+    background: water,
+    title: shownTitle,
+    ...resolved.subtitle !== void 0 && { subtitle: resolved.subtitle },
+    ...resolved.caption !== void 0 && { caption: resolved.caption },
+    regions,
+    rivers,
+    relief,
+    reliefHatch,
+    coastlineStyle,
+    legs,
+    pois,
+    cityDots,
+    clusters,
+    labels,
+    legend,
+    insets,
+    insetRegions,
+    projection,
+    stretch: stretchParams,
+    diagnostics: []
+  };
+}
+
+export {
+  mapLegendGroups,
+  mapLegendConfig,
+  mapBackgroundColor,
+  mapNeutralLandColor,
+  buildMapProjection,
+  parsePathRings,
+  albersSkewFallback,
+  layoutMap
+};
+//# sourceMappingURL=chunk-IPWPWM6R.js.map