@diagrammo/dgmo 0.21.0 → 0.22.0

package/dist/index.cjs

@@ -93,18 +93,18 @@ function computeQuadrantPointLabels(points, chartBounds, obstacles, pointRadius,
   const results = [];
   for (let i = 0; i < points.length; i++) {
     const pt = points[i];
-    const labelWidth = pt.label.length * fontSize * CHAR_WIDTH_RATIO + 8;
+    const labelWidth2 = pt.label.length * fontSize * CHAR_WIDTH_RATIO + 8;
     let best = null;
     const directions = [
       {
         // Above
         gen: (offset) => {
-          const lx = pt.cx - labelWidth / 2;
+          const lx = pt.cx - labelWidth2 / 2;
           const ly = pt.cy - offset - labelHeight;
-          if (ly < chartBounds.top || lx < chartBounds.left || lx + labelWidth > chartBounds.right)
+          if (ly < chartBounds.top || lx < chartBounds.left || lx + labelWidth2 > chartBounds.right)
             return null;
           return {
-            rect: { x: lx, y: ly, w: labelWidth, h: labelHeight },
+            rect: { x: lx, y: ly, w: labelWidth2, h: labelHeight },
             textX: pt.cx,
             textY: ly + labelHeight / 2,
             anchor: "middle"
@@ -114,12 +114,12 @@ function computeQuadrantPointLabels(points, chartBounds, obstacles, pointRadius,
       {
         // Below
         gen: (offset) => {
-          const lx = pt.cx - labelWidth / 2;
+          const lx = pt.cx - labelWidth2 / 2;
           const ly = pt.cy + offset;
-          if (ly + labelHeight > chartBounds.bottom || lx < chartBounds.left || lx + labelWidth > chartBounds.right)
+          if (ly + labelHeight > chartBounds.bottom || lx < chartBounds.left || lx + labelWidth2 > chartBounds.right)
             return null;
           return {
-            rect: { x: lx, y: ly, w: labelWidth, h: labelHeight },
+            rect: { x: lx, y: ly, w: labelWidth2, h: labelHeight },
             textX: pt.cx,
             textY: ly + labelHeight / 2,
             anchor: "middle"
@@ -131,10 +131,10 @@ function computeQuadrantPointLabels(points, chartBounds, obstacles, pointRadius,
         gen: (offset) => {
           const lx = pt.cx + offset;
           const ly = pt.cy - labelHeight / 2;
-          if (lx + labelWidth > chartBounds.right || ly < chartBounds.top || ly + labelHeight > chartBounds.bottom)
+          if (lx + labelWidth2 > chartBounds.right || ly < chartBounds.top || ly + labelHeight > chartBounds.bottom)
             return null;
           return {
-            rect: { x: lx, y: ly, w: labelWidth, h: labelHeight },
+            rect: { x: lx, y: ly, w: labelWidth2, h: labelHeight },
             textX: lx,
             textY: pt.cy,
             anchor: "start"
@@ -144,13 +144,13 @@ function computeQuadrantPointLabels(points, chartBounds, obstacles, pointRadius,
       {
         // Left
         gen: (offset) => {
-          const lx = pt.cx - offset - labelWidth;
+          const lx = pt.cx - offset - labelWidth2;
           const ly = pt.cy - labelHeight / 2;
           if (lx < chartBounds.left || ly < chartBounds.top || ly + labelHeight > chartBounds.bottom)
             return null;
           return {
-            rect: { x: lx, y: ly, w: labelWidth, h: labelHeight },
-            textX: lx + labelWidth,
+            rect: { x: lx, y: ly, w: labelWidth2, h: labelHeight },
+            textX: lx + labelWidth2,
             textY: pt.cy,
             anchor: "end"
           };
@@ -200,10 +200,10 @@ function computeQuadrantPointLabels(points, chartBounds, obstacles, pointRadius,
       }
     }
     if (!best) {
-      const lx = pt.cx - labelWidth / 2;
+      const lx = pt.cx - labelWidth2 / 2;
       const ly = pt.cy - minGap - labelHeight;
       best = {
-        rect: { x: lx, y: ly, w: labelWidth, h: labelHeight },
+        rect: { x: lx, y: ly, w: labelWidth2, h: labelHeight },
         textX: pt.cx,
         textY: ly + labelHeight / 2,
         anchor: "middle",
@@ -838,6 +838,9 @@ var init_reserved_key_registry = __esm({
       "value",
       "label",
       "style"
+      // `surface:` was removed in the 2026-06-02 defaults-on review — it is no longer
+      // a recognized metadata key (the route/edge surface feature was cut; §24B.7).
+      // A stray `surface: water` is no longer captured as a reserved key.
     ]);
     ORG_REGISTRY = staticRegistry([
       "color",
@@ -1900,77 +1903,266 @@ function getSegmentColors(palette, count) {
     (_, i) => hslToHex(Math.round((startHue + i * step) % 360), avgS, avgL)
   );
 }
+function politicalTints(palette, count, isDark) {
+  if (count <= 0) return [];
+  const base = isDark ? palette.surface : palette.bg;
+  const c = palette.colors;
+  const swatches = [
+    .../* @__PURE__ */ new Set([
+      c.green,
+      c.yellow,
+      c.orange,
+      c.purple,
+      c.red,
+      c.teal,
+      c.cyan,
+      c.blue
+    ])
+  ];
+  const bands = isDark ? POLITICAL_TINT_BANDS.dark : POLITICAL_TINT_BANDS.light;
+  const out = [];
+  for (const pct of bands) {
+    if (out.length >= count) break;
+    for (const s of swatches) out.push(mix(s, base, pct));
+  }
+  return out.slice(0, count);
+}
+var POLITICAL_TINT_BANDS;
 var init_color_utils = __esm({
   "src/palettes/color-utils.ts"() {
     "use strict";
+    POLITICAL_TINT_BANDS = {
+      light: [32, 48, 64, 80],
+      dark: [44, 58, 72, 86]
+    };
   }
 });
 
-// src/palettes/bold.ts
-var boldPalette;
-var init_bold = __esm({
-  "src/palettes/bold.ts"() {
+// src/palettes/atlas.ts
+var atlasPalette;
+var init_atlas = __esm({
+  "src/palettes/atlas.ts"() {
     "use strict";
     init_registry();
-    boldPalette = {
-      id: "bold",
-      name: "Bold",
+    atlasPalette = {
+      id: "atlas",
+      name: "Atlas",
       light: {
-        bg: "#ffffff",
-        surface: "#f0f0f0",
-        overlay: "#f0f0f0",
-        border: "#cccccc",
-        text: "#000000",
-        textMuted: "#666666",
-        textOnFillLight: "#ffffff",
-        textOnFillDark: "#000000",
-        primary: "#0000ff",
-        secondary: "#ff00ff",
-        accent: "#00cccc",
-        destructive: "#ff0000",
+        bg: "#f3ead3",
+        // warm manila / parchment
+        surface: "#ece0c0",
+        // deeper paper (cards, panels)
+        overlay: "#e8dab8",
+        // popovers, dropdowns
+        border: "#bcaa86",
+        // muted sepia rule line
+        text: "#463a26",
+        // aged sepia-brown ink
+        textMuted: "#7a6a4f",
+        // faded annotation ink
+        textOnFillLight: "#f7f1de",
+        // parchment (light text on dark fills)
+        textOnFillDark: "#3a2e1c",
+        // deep ink (dark text on light fills)
+        primary: "#5b7a99",
+        // pull-down map ocean (steel-blue)
+        secondary: "#7e9a6f",
+        // lowland sage / celadon
+        accent: "#b07f7c",
+        // dusty rose
+        destructive: "#b25a45",
+        // brick / terracotta
         colors: {
-          red: "#ff0000",
-          orange: "#ff8000",
-          yellow: "#ffcc00",
-          green: "#00cc00",
-          blue: "#0000ff",
-          purple: "#cc00cc",
-          teal: "#008080",
-          cyan: "#00cccc",
-          gray: "#808080",
-          black: "#000000",
-          white: "#f0f0f0"
+          red: "#bf6a52",
+          // terracotta brick
+          orange: "#cf9a5c",
+          // map tan / ochre
+          yellow: "#cdb35e",
+          // straw / muted lemon
+          green: "#7e9a6f",
+          // sage / celadon lowland
+          blue: "#5b7a99",
+          // steel-blue ocean
+          purple: "#9a7fa6",
+          // dusty lilac / mauve
+          teal: "#6fa094",
+          // muted seafoam
+          cyan: "#79a7b5",
+          // shallow-water blue
+          gray: "#8a7d68",
+          // warm taupe
+          black: "#463a26",
+          // ink
+          white: "#ece0c0"
+          // paper
         }
       },
       dark: {
-        bg: "#000000",
-        surface: "#111111",
-        overlay: "#1a1a1a",
-        border: "#333333",
-        text: "#ffffff",
-        textMuted: "#aaaaaa",
-        textOnFillLight: "#ffffff",
-        textOnFillDark: "#000000",
-        primary: "#00ccff",
-        secondary: "#ff00ff",
-        accent: "#ffff00",
-        destructive: "#ff0000",
+        bg: "#1e2a33",
+        // deep map ocean (night globe)
+        surface: "#27353f",
+        // raised ocean
+        overlay: "#2e3d48",
+        // popovers, dropdowns
+        border: "#3d4f5c",
+        // depth-contour line
+        text: "#e8dcc0",
+        // parchment ink, inverted
+        textMuted: "#a89a7d",
+        // faded label
+        textOnFillLight: "#f7f1de",
+        // parchment
+        textOnFillDark: "#1a242c",
+        // deep ocean ink
+        primary: "#7ba0bf",
+        // brighter ocean
+        secondary: "#9bb588",
+        // sage, lifted
+        accent: "#cf9a96",
+        // dusty rose, lifted
+        destructive: "#c9745c",
+        // brick, lifted
         colors: {
-          red: "#ff0000",
-          orange: "#ff8000",
-          yellow: "#ffff00",
-          green: "#00ff00",
-          blue: "#0066ff",
-          purple: "#ff00ff",
-          teal: "#00cccc",
-          cyan: "#00ffff",
-          gray: "#808080",
-          black: "#111111",
-          white: "#ffffff"
+          red: "#cf7a60",
+          // terracotta
+          orange: "#d9a96a",
+          // tan / ochre
+          yellow: "#d8c074",
+          // straw
+          green: "#9bb588",
+          // sage lowland
+          blue: "#7ba0bf",
+          // ocean
+          purple: "#b59ac0",
+          // lilac / mauve
+          teal: "#85b3a6",
+          // seafoam
+          cyan: "#92bccb",
+          // shallow-water blue
+          gray: "#9a8d76",
+          // warm taupe
+          black: "#27353f",
+          // raised ocean
+          white: "#e8dcc0"
+          // parchment
         }
       }
     };
-    registerPalette(boldPalette);
+    registerPalette(atlasPalette);
+  }
+});
+
+// src/palettes/blueprint.ts
+var blueprintPalette;
+var init_blueprint = __esm({
+  "src/palettes/blueprint.ts"() {
+    "use strict";
+    init_registry();
+    blueprintPalette = {
+      id: "blueprint",
+      name: "Blueprint",
+      light: {
+        bg: "#f4f8fb",
+        // pale drafting white (faint cyan)
+        surface: "#e6eef4",
+        // drafting panel
+        overlay: "#dde9f1",
+        // popovers, dropdowns
+        border: "#aac3d6",
+        // pale blue grid line
+        text: "#123a5e",
+        // blueprint navy ink
+        textMuted: "#4f7390",
+        // faint draft note
+        textOnFillLight: "#f4f8fb",
+        // drafting white
+        textOnFillDark: "#0c2f4d",
+        // deep blueprint navy
+        primary: "#1f5e8c",
+        // blueprint blue
+        secondary: "#5b7d96",
+        // steel
+        accent: "#b08a3e",
+        // draftsman's ochre highlight
+        destructive: "#c0504d",
+        // correction red
+        colors: {
+          red: "#c25a4e",
+          // correction red
+          orange: "#c2823e",
+          // ochre
+          yellow: "#c2a843",
+          // pencil gold
+          green: "#4f8a6b",
+          // drafting green
+          blue: "#1f5e8c",
+          // blueprint blue
+          purple: "#6f5e96",
+          // indigo pencil
+          teal: "#3a8a8a",
+          // teal
+          cyan: "#3f8fb5",
+          // cyan
+          gray: "#7e8e98",
+          // graphite
+          black: "#123a5e",
+          // navy ink
+          white: "#e6eef4"
+          // panel
+        }
+      },
+      dark: {
+        bg: "#103a5e",
+        // deep blueprint blue (cyanotype ground)
+        surface: "#16466e",
+        // raised sheet
+        overlay: "#1c5180",
+        // popovers, dropdowns
+        border: "#3a6f96",
+        // grid line
+        text: "#eaf2f8",
+        // chalk white
+        textMuted: "#9fc0d6",
+        // faint chalk note
+        textOnFillLight: "#eaf2f8",
+        // chalk white
+        textOnFillDark: "#0c2f4d",
+        // deep blueprint navy
+        primary: "#7fb8d8",
+        // chalk cyan
+        secondary: "#9fb8c8",
+        // pale steel
+        accent: "#d8c27a",
+        // chalk amber
+        destructive: "#e08a7a",
+        // chalk correction red
+        colors: {
+          red: "#e0907e",
+          // chalk red
+          orange: "#e0ab78",
+          // chalk amber
+          yellow: "#e3d089",
+          // chalk gold
+          green: "#93c79e",
+          // chalk green
+          blue: "#8ec3e0",
+          // chalk cyan-blue
+          purple: "#b6a6d8",
+          // chalk indigo
+          teal: "#84c7c2",
+          // chalk teal
+          cyan: "#9fd6e0",
+          // chalk cyan
+          gray: "#aebecb",
+          // chalk graphite
+          black: "#16466e",
+          // raised sheet
+          white: "#eaf2f8"
+          // chalk white
+        }
+      }
+    };
+    registerPalette(blueprintPalette);
   }
 });
 
@@ -2467,6 +2659,120 @@ var init_rose_pine = __esm({
   }
 });
 
+// src/palettes/slate.ts
+var slatePalette;
+var init_slate = __esm({
+  "src/palettes/slate.ts"() {
+    "use strict";
+    init_registry();
+    slatePalette = {
+      id: "slate",
+      name: "Slate",
+      light: {
+        bg: "#ffffff",
+        // clean slide white
+        surface: "#f3f5f8",
+        // light cool-gray panel
+        overlay: "#eaeef3",
+        // popovers, dropdowns
+        border: "#d4dae1",
+        // hairline rule
+        text: "#1f2933",
+        // near-black slate (softer than pure black)
+        textMuted: "#5b6672",
+        // secondary label
+        textOnFillLight: "#ffffff",
+        // light text on dark fills
+        textOnFillDark: "#1f2933",
+        // dark text on light fills
+        primary: "#3b6ea5",
+        // confident corporate blue
+        secondary: "#5b6672",
+        // slate gray
+        accent: "#3a9188",
+        // muted teal accent
+        destructive: "#c0504d",
+        // brick red
+        colors: {
+          red: "#c0504d",
+          // brick
+          orange: "#cc7a33",
+          // muted amber
+          yellow: "#c9a227",
+          // gold (not neon)
+          green: "#5b9357",
+          // forest / sage
+          blue: "#3b6ea5",
+          // corporate blue
+          purple: "#7d5ba6",
+          // muted violet
+          teal: "#3a9188",
+          // teal
+          cyan: "#4f96c4",
+          // steel cyan
+          gray: "#7e8a97",
+          // cool gray
+          black: "#1f2933",
+          // slate ink
+          white: "#f3f5f8"
+          // panel
+        }
+      },
+      dark: {
+        bg: "#161b22",
+        // deep slate (keynote dark)
+        surface: "#202833",
+        // raised panel
+        overlay: "#29323e",
+        // popovers, dropdowns
+        border: "#38424f",
+        // divider
+        text: "#e6eaef",
+        // off-white
+        textMuted: "#9aa5b1",
+        // secondary label
+        textOnFillLight: "#ffffff",
+        // light text on dark fills
+        textOnFillDark: "#161b22",
+        // dark text on light fills
+        primary: "#5b9bd5",
+        // lifted corporate blue
+        secondary: "#8593a3",
+        // slate gray, lifted
+        accent: "#45b3a3",
+        // teal, lifted
+        destructive: "#e07b6e",
+        // brick, lifted
+        colors: {
+          red: "#e07b6e",
+          // brick
+          orange: "#e0975a",
+          // amber
+          yellow: "#d9bd5a",
+          // gold
+          green: "#74b56e",
+          // forest / sage
+          blue: "#5b9bd5",
+          // corporate blue
+          purple: "#a585c9",
+          // violet
+          teal: "#45b3a3",
+          // teal
+          cyan: "#62b0d9",
+          // steel cyan
+          gray: "#95a1ae",
+          // cool gray
+          black: "#202833",
+          // raised panel
+          white: "#e6eaef"
+          // off-white
+        }
+      }
+    };
+    registerPalette(slatePalette);
+  }
+});
+
 // src/palettes/solarized.ts
 var solarizedPalette;
 var init_solarized = __esm({
@@ -2562,6 +2868,120 @@ var init_solarized = __esm({
   }
 });
 
+// src/palettes/tidewater.ts
+var tidewaterPalette;
+var init_tidewater = __esm({
+  "src/palettes/tidewater.ts"() {
+    "use strict";
+    init_registry();
+    tidewaterPalette = {
+      id: "tidewater",
+      name: "Tidewater",
+      light: {
+        bg: "#eceff0",
+        // weathered sea-mist paper
+        surface: "#e0e4e3",
+        // worn deck panel
+        overlay: "#dadfdf",
+        // popovers, dropdowns
+        border: "#a9b2b3",
+        // muted slate rule
+        text: "#18313f",
+        // ship's-log navy ink
+        textMuted: "#51636b",
+        // faded log entry
+        textOnFillLight: "#f3f5f3",
+        // weathered white
+        textOnFillDark: "#162c38",
+        // deep navy
+        primary: "#1f4e6b",
+        // deep-sea navy
+        secondary: "#b08a4f",
+        // rope / manila tan
+        accent: "#c69a3e",
+        // brass
+        destructive: "#c1433a",
+        // signal-flag red
+        colors: {
+          red: "#c1433a",
+          // signal-flag red
+          orange: "#cc7a38",
+          // weathered amber
+          yellow: "#d6bf5a",
+          // brass gold
+          green: "#4f8a6b",
+          // sea-glass green
+          blue: "#1f4e6b",
+          // deep-sea navy
+          purple: "#6a5a8c",
+          // twilight harbor
+          teal: "#3d8c8c",
+          // sea-glass teal
+          cyan: "#4f9bb5",
+          // shallow water
+          gray: "#8a8d86",
+          // driftwood gray
+          black: "#18313f",
+          // navy ink
+          white: "#e0e4e3"
+          // deck panel
+        }
+      },
+      dark: {
+        bg: "#0f2230",
+        // night-harbor deep sea
+        surface: "#16303f",
+        // raised hull
+        overlay: "#1d3a4a",
+        // popovers, dropdowns
+        border: "#2c4856",
+        // rigging line
+        text: "#e6ebe8",
+        // weathered white
+        textMuted: "#9aaab0",
+        // faded label
+        textOnFillLight: "#f3f5f3",
+        // weathered white
+        textOnFillDark: "#0f2230",
+        // deep sea
+        primary: "#4f9bc4",
+        // lifted sea blue
+        secondary: "#c9a46a",
+        // rope tan, lifted
+        accent: "#d9b25a",
+        // brass, lifted
+        destructive: "#e06a5e",
+        // signal red, lifted
+        colors: {
+          red: "#e06a5e",
+          // signal-flag red
+          orange: "#df9a52",
+          // amber
+          yellow: "#e0c662",
+          // brass gold
+          green: "#6fb58c",
+          // sea-glass green
+          blue: "#4f9bc4",
+          // sea blue
+          purple: "#9486bf",
+          // twilight harbor
+          teal: "#5cb0ac",
+          // sea-glass teal
+          cyan: "#62b4cf",
+          // shallow water
+          gray: "#9aa39c",
+          // driftwood gray
+          black: "#16303f",
+          // raised hull
+          white: "#e6ebe8"
+          // weathered white
+        }
+      }
+    };
+    registerPalette(tidewaterPalette);
+  }
+});
+
 // src/palettes/tokyo-night.ts
 var tokyoNightPalette;
 var init_tokyo_night = __esm({
@@ -2837,7 +3257,8 @@ var init_monokai = __esm({
 // src/palettes/index.ts
 var palettes_exports = {};
 __export(palettes_exports, {
-  boldPalette: () => boldPalette,
+  atlasPalette: () => atlasPalette,
+  blueprintPalette: () => blueprintPalette,
   catppuccinPalette: () => catppuccinPalette,
   contrastText: () => contrastText,
   draculaPalette: () => draculaPalette,
@@ -2858,7 +3279,9 @@ __export(palettes_exports, {
   rosePinePalette: () => rosePinePalette,
   shade: () => shade,
   shapeFill: () => shapeFill,
+  slatePalette: () => slatePalette,
   solarizedPalette: () => solarizedPalette,
+  tidewaterPalette: () => tidewaterPalette,
   tint: () => tint,
   tokyoNightPalette: () => tokyoNightPalette
 });
@@ -2868,17 +3291,21 @@ var init_palettes = __esm({
     "use strict";
     init_registry();
     init_color_utils();
-    init_bold();
+    init_atlas();
+    init_blueprint();
     init_catppuccin();
     init_gruvbox();
     init_nord();
     init_one_dark();
     init_rose_pine();
+    init_slate();
     init_solarized();
+    init_tidewater();
     init_tokyo_night();
     init_dracula();
     init_monokai();
-    init_bold();
+    init_atlas();
+    init_blueprint();
     init_catppuccin();
     init_dracula();
     init_gruvbox();
@@ -2886,9 +3313,15 @@ var init_palettes = __esm({
     init_nord();
     init_one_dark();
     init_rose_pine();
+    init_slate();
     init_solarized();
+    init_tidewater();
     init_tokyo_night();
     palettes = {
+      atlas: atlasPalette,
+      blueprint: blueprintPalette,
+      slate: slatePalette,
+      tidewater: tidewaterPalette,
       nord: nordPalette,
       catppuccin: catppuccinPalette,
       solarized: solarizedPalette,
@@ -2897,8 +3330,7 @@ var init_palettes = __esm({
       oneDark: oneDarkPalette,
       rosePine: rosePinePalette,
       dracula: draculaPalette,
-      monokai: monokaiPalette,
-      bold: boldPalette
+      monokai: monokaiPalette
     };
   }
 });
@@ -3408,6 +3840,9 @@ function controlsGroupCapsuleWidth(toggles) {
   }
   return w;
 }
+function isAppHostedControls(config, isExport) {
+  return !isExport && config.controlsHost === "app" && !!config.controlsGroup && config.controlsGroup.toggles.length > 0;
+}
 function buildControlsGroupLayout(config, state) {
   const cg = config.controlsGroup;
   if (!cg || cg.toggles.length === 0) return void 0;
@@ -3461,6 +3896,7 @@ function buildControlsGroupLayout(config, state) {
 function computeLegendLayout(config, state, containerWidth) {
   const { groups, controls: configControls, mode } = config;
   const isExport = mode === "export";
+  const gated = isAppHostedControls(config, isExport);
   const activeGroupName = state.activeGroup?.toLowerCase() ?? null;
   if (isExport && !activeGroupName) {
     return {
@@ -3471,7 +3907,7 @@ function computeLegendLayout(config, state, containerWidth) {
       pills: []
     };
   }
-  const controlsGroupLayout = isExport ? void 0 : buildControlsGroupLayout(config, state);
+  const controlsGroupLayout = isExport || gated ? void 0 : buildControlsGroupLayout(config, state);
   const visibleGroups = config.showEmptyGroups ? groups : groups.filter((g) => g.entries.length > 0 || !!g.gradient);
   if (visibleGroups.length === 0 && (!configControls || configControls.length === 0) && !controlsGroupLayout) {
     return {
@@ -8351,8 +8787,8 @@ function computeScatterLabelGraphics(points, chartBounds, fontSize, symbolSize,
     const pt = points[i];
     const ptSize = pt.size ?? symbolSize;
     const minGap = ptSize / 2 + 4;
-    const labelWidth = pt.name.length * fontSize * 0.6 + 8;
-    const labelX = pt.px - labelWidth / 2;
+    const labelWidth2 = pt.name.length * fontSize * 0.6 + 8;
+    const labelX = pt.px - labelWidth2 / 2;
     let bestLabelY = 0;
     let bestOffset = Infinity;
     let placed = false;
@@ -8364,7 +8800,7 @@ function computeScatterLabelGraphics(points, chartBounds, fontSize, symbolSize,
         const candidate = {
           x: labelX,
           y: labelY,
-          w: labelWidth,
+          w: labelWidth2,
           h: labelHeight
         };
         let collision = false;
@@ -8406,7 +8842,7 @@ function computeScatterLabelGraphics(points, chartBounds, fontSize, symbolSize,
     const labelRect = {
       x: labelX,
       y: bestLabelY,
-      w: labelWidth,
+      w: labelWidth2,
       h: labelHeight
     };
     placedLabels.push(labelRect);
@@ -8442,7 +8878,7 @@ function computeScatterLabelGraphics(points, chartBounds, fontSize, symbolSize,
         shape: {
           x: labelX - bgPad,
           y: bestLabelY - bgPad,
-          width: labelWidth + bgPad * 2,
+          width: labelWidth2 + bgPad * 2,
           height: labelHeight + bgPad * 2
         },
         style: { fill: bg },
@@ -15882,10 +16318,6 @@ function parseMap(content) {
       handleTag(trimmed, lineNumber);
       continue;
     }
-    if ((firstWord === "muted" || firstWord === "natural") && trimmed === firstWord) {
-      handleDirective(firstWord, "", lineNumber);
-      continue;
-    }
     if (DIRECTIVE_SET.has(firstWord) && !trimmed.slice(firstWord.length).trimStart().startsWith(":")) {
       handleDirective(
         firstWord,
@@ -15932,28 +16364,13 @@ function parseMap(content) {
         pushWarning(line12, `Duplicate directive "${key}" \u2014 last value wins.`);
     };
     switch (key) {
-      case "region":
-        dup(d.region);
-        d.region = value;
-        break;
-      case "projection":
-        dup(d.projection);
-        if (value && ![
-          "equirectangular",
-          "natural-earth",
-          "albers-usa",
-          "mercator"
-        ].includes(value))
-          pushWarning(
-            line12,
-            `Unknown projection "${value}" (expected equirectangular | natural-earth | albers-usa | mercator).`
-          );
-        d.projection = value;
-        break;
-      case "region-metric":
+      case "region-metric": {
         dup(d.regionMetric);
-        d.regionMetric = value;
+        const { label: rmLabel, colorName: rmColor } = peelTrailingColorName(value);
+        d.regionMetric = rmLabel;
+        if (rmColor) d.regionMetricColor = rmColor;
         break;
+      }
       case "poi-metric":
         dup(d.poiMetric);
         d.poiMetric = value;
@@ -15962,85 +16379,43 @@ function parseMap(content) {
         dup(d.flowMetric);
         d.flowMetric = value;
         break;
-      case "scale":
-        dup(d.scale);
-        {
-          const s = parseScale(value, line12);
-          if (s) d.scale = s;
-        }
-        break;
-      case "region-labels":
-        dup(d.regionLabels);
-        if (value && !["full", "abbrev", "off"].includes(value))
-          pushWarning(
-            line12,
-            `Unknown region-labels "${value}" (expected full | abbrev | off).`
-          );
-        d.regionLabels = value;
-        break;
-      case "poi-labels":
-        dup(d.poiLabels);
-        if (value && !["off", "auto", "all"].includes(value))
-          pushWarning(
-            line12,
-            `Unknown poi-labels "${value}" (expected off | auto | all).`
-          );
-        d.poiLabels = value;
-        break;
-      case "default-country":
-        dup(d.defaultCountry);
-        d.defaultCountry = value;
-        break;
-      case "default-state":
-        dup(d.defaultState);
-        d.defaultState = value;
+      case "locale":
+        dup(d.locale);
+        d.locale = value;
         break;
       case "active-tag":
         dup(d.activeTag);
         d.activeTag = value;
         break;
+      case "caption":
+        dup(d.caption);
+        d.caption = value;
+        break;
+      // ── Cosmetic `no-*` opt-outs: bare flags, idempotent (mirror `no-legend`,
+      //    no dup warning); each defaults the feature ON when absent. ──
       case "no-legend":
         d.noLegend = true;
         break;
-      case "muted":
-      case "natural":
-        if (d.basemapStyle !== void 0 && d.basemapStyle !== key)
-          pushWarning(
-            line12,
-            `Conflicting basemap dress \u2014 "${d.basemapStyle}" then "${key}"; last wins.`
-          );
-        d.basemapStyle = key;
+      case "no-coastline":
+        d.noCoastline = true;
         break;
-      case "subtitle":
-        dup(d.subtitle);
-        d.subtitle = value;
+      case "no-relief":
+        d.noRelief = true;
         break;
-      case "caption":
-        dup(d.caption);
-        d.caption = value;
+      case "no-context-labels":
+        d.noContextLabels = true;
+        break;
+      case "no-region-labels":
+        d.noRegionLabels = true;
+        break;
+      case "no-poi-labels":
+        d.noPoiLabels = true;
+        break;
+      case "no-colorize":
+        d.noColorize = true;
         break;
     }
   }
-  function parseScale(value, line12) {
-    const toks = value.split(/\s+/).filter(Boolean);
-    const min = Number(toks[0]);
-    const max = Number(toks[1]);
-    if (!Number.isFinite(min) || !Number.isFinite(max)) {
-      pushError(line12, `scale requires numeric <min> <max> (got "${value}").`);
-      return null;
-    }
-    const scale = { min, max };
-    if (toks[2] === "center") {
-      const c = Number(toks[3]);
-      if (Number.isFinite(c)) scale.center = c;
-      else
-        pushError(
-          line12,
-          `scale center requires a number (got "${toks[3] ?? ""}").`
-        );
-    }
-    return scale;
-  }
   function handleTag(trimmed, line12) {
     const m = matchTagBlockHeading(trimmed);
     if (!m) {
@@ -16114,6 +16489,7 @@ function parseMap(content) {
     };
     if (regionScope !== void 0) region.scope = regionScope;
     if (valueNum !== void 0) region.value = valueNum;
+    if (split.color) region.color = split.color;
     regions.push(region);
   }
   function handlePoi(rest, line12, indent) {
@@ -16138,6 +16514,7 @@ function parseMap(content) {
     const poi = { pos, tags, meta, lineNumber: line12 };
     if (split.alias) poi.alias = split.alias;
     if (label !== void 0) poi.label = label;
+    if (split.color) poi.color = split.color;
     pois.push(poi);
     open.poi = { poi, indent };
   }
@@ -16238,13 +16615,15 @@ function parseMap(content) {
         pushError(line12, `Edge has an empty endpoint: "${trimmed}".`);
         continue;
       }
-      const meta = k === links.length - 1 ? lastSplit.meta : {};
+      const isLast = k === links.length - 1;
+      const meta = isLast ? lastSplit.meta : {};
+      const style = links[k].style === "arc" ? "arc" : "straight";
       edges.push({
         from,
         to,
         ...links[k].label !== void 0 && { label: links[k].label },
         directed: links[k].directed,
-        style: links[k].style,
+        style,
         meta,
         lineNumber: line12
       });
@@ -16330,20 +16709,19 @@ var init_parser12 = __esm({
     LEG_ARROW_RE = /^(-[^>]*?->|->|~[^>]*?~>|~>|--)\s+(.+)$/;
     AT_RE = /(^|[\s,])at\s*:/i;
     DIRECTIVE_SET = /* @__PURE__ */ new Set([
-      "region",
-      "projection",
       "region-metric",
       "poi-metric",
       "flow-metric",
-      "scale",
-      "region-labels",
-      "poi-labels",
-      "default-country",
-      "default-state",
+      "locale",
       "active-tag",
+      "caption",
       "no-legend",
-      "subtitle",
-      "caption"
+      "no-coastline",
+      "no-relief",
+      "no-context-labels",
+      "no-region-labels",
+      "no-poi-labels",
+      "no-colorize"
     ]);
   }
 });
@@ -24264,8 +24642,8 @@ function renderKanban(container, parsed, palette, isDark, options) {
         let metaY = separatorY + sCardSeparatorGap + sCardMetaFontSize;
         for (const meta of tagMeta) {
           cg.append("text").attr("x", cx + sCardPaddingX).attr("y", metaY).attr("font-size", sCardMetaFontSize).attr("fill", onCardText).text(`${meta.label}: `);
-          const labelWidth = (meta.label.length + 2) * sCardMetaFontSize * 0.6;
-          cg.append("text").attr("x", cx + sCardPaddingX + labelWidth).attr("y", metaY).attr("font-size", sCardMetaFontSize).attr("fill", onCardText).text(meta.value);
+          const labelWidth2 = (meta.label.length + 2) * sCardMetaFontSize * 0.6;
+          cg.append("text").attr("x", cx + sCardPaddingX + labelWidth2).attr("y", metaY).attr("font-size", sCardMetaFontSize).attr("fill", onCardText).text(meta.value);
           metaY += sCardMetaLineHeight;
         }
         for (const detail of card.details) {
@@ -24609,8 +24987,8 @@ function renderSwimlaneCard(parent, cardLayout, tagGroups, activeTagGroup, palet
     let metaY = separatorY + sCardSeparatorGap + sCardMetaFontSize;
     for (const meta of tagMeta) {
       cg.append("text").attr("x", cx + sCardPaddingX).attr("y", metaY).attr("font-size", sCardMetaFontSize).attr("fill", palette.textMuted).text(`${meta.label}: `);
-      const labelWidth = (meta.label.length + 2) * sCardMetaFontSize * 0.6;
-      cg.append("text").attr("x", cx + sCardPaddingX + labelWidth).attr("y", metaY).attr("font-size", sCardMetaFontSize).attr("fill", onCardText).text(meta.value);
+      const labelWidth2 = (meta.label.length + 2) * sCardMetaFontSize * 0.6;
+      cg.append("text").attr("x", cx + sCardPaddingX + labelWidth2).attr("y", metaY).attr("font-size", sCardMetaFontSize).attr("fill", onCardText).text(meta.value);
       metaY += sCardMetaLineHeight;
     }
     for (const detail of card.details) {
@@ -25445,8 +25823,8 @@ function classifyEREntities(tables, relationships) {
     }
   }
   const mmParticipants = /* @__PURE__ */ new Set();
-  for (const [id, neighbors] of tableStarNeighbors) {
-    if (neighbors.size >= 2) mmParticipants.add(id);
+  for (const [id, neighbors2] of tableStarNeighbors) {
+    if (neighbors2.size >= 2) mmParticipants.add(id);
   }
   const indegreeValues = Object.values(indegreeMap);
   const mean = indegreeValues.reduce((a, b) => a + b, 0) / indegreeValues.length;
@@ -26117,7 +26495,8 @@ function renderBoxesAndLines(container, parsed, layout, palette, isDark, options
     controlsExpanded,
     onToggleDescriptions,
     onToggleControlsExpand,
-    exportMode = false
+    exportMode = false,
+    controlsHost
   } = options ?? {};
   d3Selection6.select(container).selectAll(":not([data-d3-tooltip])").remove();
   const width = exportDims?.width ?? container.clientWidth;
@@ -26135,7 +26514,11 @@ function renderBoxesAndLines(container, parsed, layout, palette, isDark, options
   const sGroupLabelZone = sctx.structural(GROUP_LABEL_ZONE);
   const sTitleFontSize = sctx.text(TITLE_FONT_SIZE);
   const sTitleY = sctx.structural(TITLE_Y);
-  const sLegendHeight = sctx.structural(
+  const reserveHasDescriptions = parsed.nodes.some(
+    (n) => n.description && n.description.length > 0
+  );
+  const willRenderLegend = parsed.tagGroups.length > 0 || reserveHasDescriptions && controlsHost !== "app";
+  const sLegendHeight = willRenderLegend ? sctx.structural(
     getMaxLegendReservedHeight(
       {
         groups: parsed.tagGroups,
@@ -26144,7 +26527,7 @@ function renderBoxesAndLines(container, parsed, layout, palette, isDark, options
       },
       width
     )
-  );
+  ) : 0;
   const activeGroup = resolveActiveTagGroup(
     parsed.tagGroups,
     parsed.options["active-tag"],
@@ -26459,10 +26842,10 @@ function renderBoxesAndLines(container, parsed, layout, palette, isDark, options
   const hasDescriptions = parsed.nodes.some(
     (n) => n.description && n.description.length > 0
   );
-  const hasLegend = parsed.tagGroups.length > 0 || hasDescriptions;
+  const hasLegend = parsed.tagGroups.length > 0 || hasDescriptions && controlsHost !== "app";
   if (hasLegend) {
     let controlsGroup;
-    if (hasDescriptions && onToggleDescriptions) {
+    if (hasDescriptions && (onToggleDescriptions || controlsHost === "app")) {
       controlsGroup = {
         toggles: [
           {
@@ -26480,7 +26863,14 @@ function renderBoxesAndLines(container, parsed, layout, palette, isDark, options
       groups: parsed.tagGroups,
       position: { placement: "top-center", titleRelation: "below-title" },
       mode: exportMode ? "export" : "preview",
-      ...controlsGroup !== void 0 && { controlsGroup }
+      // Keep inactive sibling tag groups visible as collapsed pills so the user
+      // can click one to flip the active colouring dimension (preview only —
+      // export shows just the active group). Without this, declaring a second
+      // tag group (e.g. Team) leaves it invisible whenever another group is
+      // active. The app's BoxesAndLinesPreview already wires pill clicks.
+      showInactivePills: true,
+      ...controlsGroup !== void 0 && { controlsGroup },
+      ...controlsHost !== void 0 && { controlsHost }
     };
     const legendState = {
       activeGroup,
@@ -27728,8 +28118,9 @@ function renderMindmap(container, parsed, layout, palette, isDark, onClickItem,
   const containerHeight = exportDims?.height ?? (container.getBoundingClientRect().height || 600);
   d3Selection7.select(container).selectAll("*").remove();
   const svg = d3Selection7.select(container).append("svg").attr("width", containerWidth).attr("height", containerHeight).attr("viewBox", `0 0 ${containerWidth} ${containerHeight}`).attr("preserveAspectRatio", "xMidYMin meet").style("font-family", FONT_FAMILY);
+  const appHosted = options?.controlsHost === "app";
   const hasControls = !!options?.onToggleColorByDepth || !!options?.onToggleDescriptions;
-  const hasLegend = parsed.tagGroups.length > 0 || hasControls;
+  const hasLegend = parsed.tagGroups.length > 0 || hasControls && !appHosted;
   const fixedLegend = !isExport && hasLegend;
   const legendReserve = fixedLegend ? getMaxLegendReservedHeight(
     {
@@ -27823,7 +28214,10 @@ function renderMindmap(container, parsed, layout, palette, isDark, onClickItem,
       }),
       position: { placement: "top-center", titleRelation: "below-title" },
       mode: options?.exportMode ? "export" : "preview",
-      ...controlsToggles !== void 0 && { controlsGroup: controlsToggles }
+      ...controlsToggles !== void 0 && { controlsGroup: controlsToggles },
+      ...options?.controlsHost !== void 0 && {
+        controlsHost: options.controlsHost
+      }
     };
     const legendState = {
       activeGroup: options?.colorByDepth ? null : activeTagGroup !== void 0 ? activeTagGroup : parsed.options["active-tag"] ?? null,
@@ -28267,8 +28661,8 @@ function computeFieldAlignX(children) {
   for (const child of children) {
     if (child.metadata["_labelField"] === "true" && child.children.length >= 2) {
       const labelEl = child.children[0];
-      const labelWidth = labelEl.label.length * CHAR_WIDTH5;
-      maxLabelWidth = Math.max(maxLabelWidth, labelWidth);
+      const labelWidth2 = labelEl.label.length * CHAR_WIDTH5;
+      maxLabelWidth = Math.max(maxLabelWidth, labelWidth2);
       labelFieldCount++;
     }
   }
@@ -33232,7 +33626,7 @@ function hasRoles(node) {
 function computeNodeWidth2(node, expanded, options) {
   const badgeVal = node.computedConcurrentInvocations === 0 && node.computedInstances > 1 ? node.computedInstances : 0;
   const badgeLen = badgeVal > 0 ? `${badgeVal}x`.length + 2 : 0;
-  const labelWidth = (node.label.length + badgeLen) * CHAR_WIDTH7 + PADDING_X3;
+  const labelWidth2 = (node.label.length + badgeLen) * CHAR_WIDTH7 + PADDING_X3;
   const allKeys = [];
   if (node.computedRps > 0) allKeys.push("RPS");
   if (expanded) {
@@ -33276,7 +33670,7 @@ function computeNodeWidth2(node, expanded, options) {
         allKeys.push("overflow");
     }
   }
-  if (allKeys.length === 0) return Math.max(MIN_NODE_WIDTH2, labelWidth);
+  if (allKeys.length === 0) return Math.max(MIN_NODE_WIDTH2, labelWidth2);
   const maxKeyLen = Math.max(...allKeys.map((k) => k.length));
   let maxRowWidth = 0;
   if (node.computedRps > 0) {
@@ -33364,7 +33758,7 @@ function computeNodeWidth2(node, expanded, options) {
       truncated.length * META_CHAR_WIDTH3 + PADDING_X3
     );
   }
-  return Math.max(MIN_NODE_WIDTH2, labelWidth, maxRowWidth + 20, descWidth);
+  return Math.max(MIN_NODE_WIDTH2, labelWidth2, maxRowWidth + 20, descWidth);
 }
 function computeNodeHeight2(node, expanded, options) {
   const propCount = countDisplayProps(node, expanded, options);
@@ -34913,8 +35307,9 @@ function computeInfraLegendGroups(nodes, tagGroups, palette, edges) {
   }
   return groups;
 }
-function renderLegend3(rootSvg, legendGroups, totalWidth, legendY, palette, isDark, activeGroup, playback, exportMode = false) {
+function renderLegend3(rootSvg, legendGroups, totalWidth, legendY, palette, isDark, activeGroup, playback, exportMode = false, controlsHost) {
   if (legendGroups.length === 0 && !playback) return;
+  const appHostedPlayback = controlsHost === "app" && !!playback;
   const legendG = rootSvg.append("g").attr("transform", `translate(0, ${legendY})`);
   if (activeGroup) {
     legendG.attr("data-legend-active", activeGroup.toLowerCase());
@@ -34923,14 +35318,29 @@ function renderLegend3(rootSvg, legendGroups, totalWidth, legendY, palette, isDa
     name: g.name,
     entries: g.entries.map((e) => ({ value: e.value, color: e.color }))
   }));
-  if (playback) {
+  if (playback && !appHostedPlayback) {
     allGroups.push({ name: "Playback", entries: [] });
   }
   const legendConfig = {
     groups: allGroups,
     position: { placement: "top-center", titleRelation: "below-title" },
     mode: exportMode ? "export" : "preview",
-    showEmptyGroups: true
+    showEmptyGroups: true,
+    ...appHostedPlayback && {
+      controlsHost: "app",
+      controlsGroup: {
+        toggles: [
+          {
+            id: "playback",
+            type: "toggle",
+            label: "Playback",
+            active: true,
+            onToggle: () => {
+            }
+          }
+        ]
+      }
+    }
   };
   const legendState = { activeGroup };
   renderLegendD3(
@@ -34981,8 +35391,9 @@ function renderLegend3(rootSvg, legendGroups, totalWidth, legendY, palette, isDa
     }
   }
 }
-function renderInfra(container, layout, palette, isDark, title, titleLineNumber, tagGroups, activeGroup, animate, playback, expandedNodeIds, exportMode, collapsedNodes) {
+function renderInfra(container, layout, palette, isDark, title, titleLineNumber, tagGroups, activeGroup, animate, playback, expandedNodeIds, exportMode, collapsedNodes, controlsHost) {
   d3Selection11.select(container).selectAll(":not([data-d3-tooltip])").remove();
+  const appHostedPlayback = controlsHost === "app" && !!playback;
   const ctx = ScaleContext.identity();
   const sc = buildScaledConstants(ctx);
   const legendGroups = computeInfraLegendGroups(
@@ -34991,7 +35402,7 @@ function renderInfra(container, layout, palette, isDark, title, titleLineNumber,
     palette,
     layout.edges
   );
-  const hasLegend = legendGroups.length > 0 || !!playback;
+  const hasLegend = legendGroups.length > 0 || !!playback && !appHostedPlayback;
   const fixedLegend = !exportMode && hasLegend;
   const legendDynamicH = hasLegend ? getMaxLegendReservedHeight(
     {
@@ -35135,7 +35546,8 @@ function renderInfra(container, layout, palette, isDark, title, titleLineNumber,
         isDark,
         activeGroup ?? null,
         playback ?? void 0,
-        exportMode
+        exportMode,
+        controlsHost
       );
       legendSvg.selectAll(".infra-legend-group").style("pointer-events", "auto");
     } else {
@@ -35148,7 +35560,8 @@ function renderInfra(container, layout, palette, isDark, title, titleLineNumber,
         isDark,
         activeGroup ?? null,
         playback ?? void 0,
-        exportMode
+        exportMode,
+        controlsHost
       );
     }
   }
@@ -42783,6 +43196,9 @@ function renderTechRadar(container, parsed, palette, isDark, onClickItem, export
             onToggle: (active) => options.onToggleListing(active)
           }
         ]
+      },
+      ...options.controlsHost !== void 0 && {
+        controlsHost: options.controlsHost
       }
     };
     const legendState = {
@@ -44606,7 +45022,7 @@ function computeCycleLayout(parsed, options) {
   const circleNodes = parsed.options["circle-nodes"] === "true";
   const nodeDims = parsed.nodes.map((node) => {
     const hasDesc = !hideDescriptions && node.description.length > 0;
-    const labelWidth = Math.max(
+    const labelWidth2 = Math.max(
       MIN_NODE_WIDTH4,
       node.label.length * LABEL_CHAR_W + NODE_PAD_X * 2
     );
@@ -44615,12 +45031,12 @@ function computeCycleLayout(parsed, options) {
     }
     if (!hasDesc) {
       return {
-        width: Math.min(MAX_NODE_WIDTH3, labelWidth),
+        width: Math.min(MAX_NODE_WIDTH3, labelWidth2),
         height: PLAIN_NODE_HEIGHT,
         wrappedDesc: []
       };
     }
-    return chooseDescribedRectDims(node.description, labelWidth);
+    return chooseDescribedRectDims(node.description, labelWidth2);
   });
   if (circleNodes) {
     const maxDiam = Math.max(...nodeDims.map((d) => d.width));
@@ -44816,10 +45232,10 @@ function computeCycleLayout(parsed, options) {
     scale
   };
 }
-function chooseDescribedRectDims(description, labelWidth) {
+function chooseDescribedRectDims(description, labelWidth2) {
   const minW = Math.min(
     MAX_NODE_WIDTH3,
-    Math.max(MIN_NODE_WIDTH4, labelWidth, DESC_MIN_WIDTH)
+    Math.max(MIN_NODE_WIDTH4, labelWidth2, DESC_MIN_WIDTH)
   );
   let best = null;
   let bestScore = Infinity;
@@ -45247,7 +45663,8 @@ function renderCycle(container, parsed, palette, isDark, onClickItem, exportDims
   const hideDescriptions = (renderOptions?.hideDescriptions ?? false) || parsed.options["no-descriptions"] === "true" || viewState?.hd === true;
   const showDescriptions = !hideDescriptions;
   const hasDescriptions = parsed.nodes.some((n) => n.description.length > 0) || parsed.edges.some((e) => e.description.length > 0);
-  const hasLegend = hasDescriptions && !!renderOptions?.onToggleDescriptions;
+  const appHostedControls = renderOptions?.controlsHost === "app";
+  const hasLegend = !appHostedControls && hasDescriptions && !!renderOptions?.onToggleDescriptions;
   const showTitle = !!parsed.title && parsed.options["no-title"] !== "on";
   const legendOffset = hasLegend ? sLegendHeight : 0;
   const layoutHeight = height - (showTitle ? sTitleAreaHeight : 0) - legendOffset;
@@ -45284,7 +45701,10 @@ function renderCycle(container, parsed, palette, isDark, onClickItem, exportDims
       groups: [],
       position: { placement: "top-center", titleRelation: "below-title" },
       mode: renderOptions?.exportMode ? "export" : "preview",
-      controlsGroup
+      controlsGroup,
+      ...renderOptions?.controlsHost !== void 0 && {
+        controlsHost: renderOptions.controlsHost
+      }
     };
     const legendState = {
       activeGroup: null,
@@ -45555,6 +45975,107 @@ function featureIndex(topo) {
   }
   return idx;
 }
+function buildAdjacency(topo) {
+  const cached = adjacencyCache.get(topo);
+  if (cached) return cached;
+  const geometries = geomObject(topo).geometries;
+  const nb = (0, import_topojson_client.neighbors)(geometries);
+  const sets = /* @__PURE__ */ new Map();
+  geometries.forEach((g, i) => {
+    if (!g.type || g.type === "null") return;
+    let set = sets.get(g.id);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      sets.set(g.id, set);
+    }
+    for (const j of nb[i] ?? []) {
+      const nid = geometries[j]?.id;
+      if (nid && nid !== g.id) set.add(nid);
+    }
+  });
+  const out = /* @__PURE__ */ new Map();
+  for (const [iso, set] of sets) out.set(iso, [...set].sort());
+  adjacencyCache.set(topo, out);
+  return out;
+}
+function decodeFeatures(topo) {
+  return geomObject(topo).geometries.map((g) => {
+    const f = (0, import_topojson_client.feature)(topo, g);
+    return {
+      type: "Feature",
+      id: g.id,
+      properties: g.properties,
+      geometry: f.geometry
+    };
+  });
+}
+function pointInRing(lon, lat, ring) {
+  let inside = false;
+  for (let i = 0, j = ring.length - 1; i < ring.length; j = i++) {
+    const xi = ring[i][0];
+    const yi = ring[i][1];
+    const xj = ring[j][0];
+    const yj = ring[j][1];
+    const intersect = yi > lat !== yj > lat && lon < (xj - xi) * (lat - yi) / (yj - yi) + xi;
+    if (intersect) inside = !inside;
+  }
+  return inside;
+}
+function pointOnRingEdge(lon, lat, ring) {
+  for (let i = 0, j = ring.length - 1; i < ring.length; j = i++) {
+    const xi = ring[i][0];
+    const yi = ring[i][1];
+    const xj = ring[j][0];
+    const yj = ring[j][1];
+    if (lon < Math.min(xi, xj) - EDGE_EPS || lon > Math.max(xi, xj) + EDGE_EPS)
+      continue;
+    if (lat < Math.min(yi, yj) - EDGE_EPS || lat > Math.max(yi, yj) + EDGE_EPS)
+      continue;
+    const cross = (xj - xi) * (lat - yi) - (yj - yi) * (lon - xi);
+    if (Math.abs(cross) <= EDGE_EPS) return true;
+  }
+  return false;
+}
+function pointInGeometry(geometry, lon, lat) {
+  const g = geometry;
+  if (!g) return false;
+  const polys = g.type === "Polygon" ? [g.coordinates] : g.type === "MultiPolygon" ? g.coordinates : [];
+  for (const rings of polys) {
+    if (!rings.length) continue;
+    if (pointOnRingEdge(lon, lat, rings[0])) return true;
+    if (!pointInRing(lon, lat, rings[0])) continue;
+    let inHole = false;
+    for (let h = 1; h < rings.length; h++) {
+      if (pointInRing(lon, lat, rings[h]) && !pointOnRingEdge(lon, lat, rings[h])) {
+        inHole = true;
+        break;
+      }
+    }
+    if (!inHole) return true;
+  }
+  return false;
+}
+function regionAt(lonLat, countries, states) {
+  const lon = lonLat[0];
+  const lat = lonLat[1];
+  let country = null;
+  for (const f of countries) {
+    if (pointInGeometry(f.geometry, lon, lat)) {
+      country = { iso: f.id, name: f.properties.name };
+      break;
+    }
+  }
+  let state = null;
+  if (country?.iso === "US" && states) {
+    for (const f of states) {
+      if (pointInGeometry(f.geometry, lon, lat)) {
+        state = { iso: f.id, name: f.properties.name };
+        break;
+      }
+    }
+  }
+  return { country, state };
+}
 function featureBbox(topo, geomId) {
   const geom = geomObject(topo).geometries.find((g) => g.id === geomId);
   if (!geom) return null;
@@ -45566,6 +46087,74 @@ function featureBbox(topo, geomId) {
     [b[1][0], b[1][1]]
   ];
 }
+function explodePolygons(gj) {
+  const g = gj.geometry ?? gj;
+  const t = g.type;
+  const coords = g.coordinates;
+  if (t === "Polygon") {
+    return [
+      { type: "Feature", geometry: { type: "Polygon", coordinates: coords } }
+    ];
+  }
+  if (t === "MultiPolygon") {
+    return coords.map((rings) => ({
+      type: "Feature",
+      geometry: { type: "Polygon", coordinates: rings }
+    }));
+  }
+  return [];
+}
+function bboxGap(a, b) {
+  const lonGap = Math.max(0, a[0][0] - b[1][0], b[0][0] - a[1][0]);
+  const latGap = Math.max(0, a[0][1] - b[1][1], b[0][1] - a[1][1]);
+  return Math.max(lonGap, latGap);
+}
+function featureBboxPrimary(topo, geomId) {
+  const geom = geomObject(topo).geometries.find((g) => g.id === geomId);
+  if (!geom) return null;
+  const gj = (0, import_topojson_client.feature)(topo, geom);
+  const parts = explodePolygons(gj);
+  if (parts.length <= 1) return featureBbox(topo, geomId);
+  const polys = parts.map((p) => {
+    const b = (0, import_d3_geo.geoBounds)(p);
+    if (!b || !Number.isFinite(b[0][0])) return null;
+    const wraps = b[1][0] < b[0][0];
+    const bbox = [
+      [b[0][0], b[0][1]],
+      [b[1][0], b[1][1]]
+    ];
+    return { bbox, area: (0, import_d3_geo.geoArea)(p), wraps };
+  }).filter(
+    (p) => p !== null
+  );
+  if (polys.length <= 1 || polys.some((p) => p.wraps))
+    return featureBbox(topo, geomId);
+  const maxArea = Math.max(...polys.map((p) => p.area));
+  const anchor = polys.find((p) => p.area === maxArea);
+  const cluster = [
+    [anchor.bbox[0][0], anchor.bbox[0][1]],
+    [anchor.bbox[1][0], anchor.bbox[1][1]]
+  ];
+  const remaining = polys.filter((p) => p !== anchor);
+  let added = true;
+  while (added) {
+    added = false;
+    for (let i = remaining.length - 1; i >= 0; i--) {
+      const p = remaining[i];
+      const near = bboxGap(p.bbox, cluster) <= DETACH_GAP_DEG;
+      const large = p.area >= DETACH_AREA_FRAC * maxArea;
+      if (near || large) {
+        cluster[0][0] = Math.min(cluster[0][0], p.bbox[0][0]);
+        cluster[0][1] = Math.min(cluster[0][1], p.bbox[0][1]);
+        cluster[1][0] = Math.max(cluster[1][0], p.bbox[1][0]);
+        cluster[1][1] = Math.max(cluster[1][1], p.bbox[1][1]);
+        remaining.splice(i, 1);
+        added = true;
+      }
+    }
+  }
+  return cluster;
+}
 function unionExtent(boxes, points) {
   const lats = [];
   const lons = [];
@@ -45604,13 +46193,17 @@ function unionLongitudes(lons) {
   }
   return { west: pts[gapIdx], east: pts[gapIdx - 1] + 360 };
 }
-var import_topojson_client, import_d3_geo, fold;
+var import_topojson_client, import_d3_geo, fold, adjacencyCache, EDGE_EPS, DETACH_GAP_DEG, DETACH_AREA_FRAC;
 var init_geo = __esm({
   "src/map/geo.ts"() {
     "use strict";
     import_topojson_client = require("topojson-client");
     import_d3_geo = require("d3-geo");
     fold = (s) => s.normalize("NFD").replace(/\p{Diacritic}/gu, "").toLowerCase().trim();
+    adjacencyCache = /* @__PURE__ */ new WeakMap();
+    EDGE_EPS = 1e-9;
+    DETACH_GAP_DEG = 10;
+    DETACH_AREA_FRAC = 0.25;
   }
 });
 
@@ -45628,6 +46221,12 @@ function looksUS(lat, lon) {
   if (lat < 15 || lat > 72) return false;
   return lon >= -180 && lon <= -64 || lon >= 172;
 }
+function looksNorthAmericaNeighbor(lat, lon) {
+  return lat >= 14 && lat <= 72 && lon >= -141 && lon <= -52;
+}
+function isWholeSphere(bb) {
+  return bb[0][0] <= -179 && bb[1][0] >= 179 && bb[0][1] <= -89 && bb[1][1] >= 89;
+}
 function resolveMap(parsed, data) {
   const diagnostics = [...parsed.diagnostics];
   const err = (line12, message, code) => {
@@ -45638,9 +46237,6 @@ function resolveMap(parsed, data) {
   };
   const result = {
     title: parsed.title,
-    ...parsed.directives.subtitle !== void 0 && {
-      subtitle: parsed.directives.subtitle
-    },
     ...parsed.directives.caption !== void 0 && {
       caption: parsed.directives.caption
     },
@@ -45650,7 +46246,7 @@ function resolveMap(parsed, data) {
     // renderer's job (step 4) — the resolver only carries `tags` + `tagGroups`
     // through; it never resolves a tag value to a palette color (#10).
     directives: { ...parsed.directives },
-    basemaps: { world: "coarse", subdivisions: [] },
+    basemaps: { world: "detail", subdivisions: [] },
     regions: [],
     pois: [],
     edges: [],
@@ -45659,7 +46255,8 @@ function resolveMap(parsed, data) {
       [-180, -85],
       [180, 85]
     ],
-    projection: "natural-earth",
+    projection: "equirectangular",
+    poiFrameContainers: [],
     diagnostics,
     error: parsed.error
   };
@@ -45669,7 +46266,10 @@ function resolveMap(parsed, data) {
     ...[...countryIndex.values()].map((v) => v.name),
     ...[...usStateIndex.values()].map((v) => v.name)
   ];
-  const usScoped = parsed.directives.region === "us-states" || parsed.directives.defaultCountry?.toUpperCase() === "US" || parsed.regions.some((r) => {
+  const localeRaw = parsed.directives.locale?.toUpperCase();
+  const localeCountry = localeRaw ? localeRaw.split("-")[0] : void 0;
+  const localeSubdivision = localeRaw && /^[A-Z]{2}-/.test(localeRaw) ? localeRaw : void 0;
+  const usScoped = localeCountry === "US" || parsed.regions.some((r) => {
     const f = fold(r.name);
     return usStateIndex.has(f) && !countryIndex.has(f);
   }) || parsed.regions.some(
@@ -45714,12 +46314,12 @@ function resolveMap(parsed, data) {
         chosen = { ...inState, layer: "us-state" };
       } else {
         chosen = { ...inCountry, layer: "country" };
+        warn(
+          r.lineNumber,
+          `"${r.name}" is both a country and a US state \u2014 resolved as ${chosen.layer} (${chosen.id}). Pin it with an ISO code (${inState.id} / ${inCountry.id}) or name + scope ("${r.name} US" / "${r.name} ${inCountry.id}").`,
+          "W_MAP_REGION_AMBIGUOUS"
+        );
       }
-      warn(
-        r.lineNumber,
-        `"${r.name}" is both a country and a US state \u2014 resolved as ${chosen.layer} (${chosen.id}). Pin it with an ISO code (${inState.id} / ${inCountry.id}) or name + scope ("${r.name} US" / "${r.name} ${inCountry.id}").`,
-        "W_MAP_REGION_AMBIGUOUS"
-      );
     } else if (inState) {
       chosen = { ...inState, layer: "us-state" };
     } else if (inCountry) {
@@ -45743,6 +46343,7 @@ function resolveMap(parsed, data) {
       name: chosen.name,
       layer: chosen.layer,
       ...r.value !== void 0 && { value: r.value },
+      ...r.color !== void 0 && { color: r.color },
       tags: r.tags,
       meta: r.meta,
       lineNumber: r.lineNumber
@@ -45819,7 +46420,7 @@ function resolveMap(parsed, data) {
       if (!scope)
         warn(
           line12,
-          `"${name}" is ambiguous \u2014 resolved to the most-populous match.`,
+          `"${name}" is ambiguous \u2014 resolved to the most-populous match. Set a default with \`locale <ISO>\` (e.g. \`locale US\` / \`locale US-GA\`) to steer it.`,
           "W_MAP_AMBIGUOUS_NAME"
         );
     }
@@ -45832,17 +46433,21 @@ function resolveMap(parsed, data) {
     return fold(pos.name);
   };
   const poiCountries = [];
-  let anyNonUsPoi = false;
+  let anyUsPoi = false;
+  let anyNonNaPoi = false;
   const noteCountry = (iso) => {
     if (iso) {
       poiCountries.push(iso);
-      if (iso !== "US") anyNonUsPoi = true;
+      if (iso === "US") anyUsPoi = true;
+      if (iso !== "US" && iso !== "CA" && iso !== "MX") anyNonNaPoi = true;
     }
   };
   const deferred = [];
   for (const p of parsed.pois) {
     if (p.pos.kind === "coords") {
-      if (!looksUS(p.pos.lat, p.pos.lon)) anyNonUsPoi = true;
+      if (looksUS(p.pos.lat, p.pos.lon)) anyUsPoi = true;
+      else if (!looksNorthAmericaNeighbor(p.pos.lat, p.pos.lon))
+        anyNonNaPoi = true;
       addResolvedPoi(p.pos.lat, p.pos.lon, p);
       continue;
     }
@@ -45860,14 +46465,15 @@ function resolveMap(parsed, data) {
       deferred.push(p);
     }
   }
-  const inferredCountry = parsed.directives.defaultCountry?.toUpperCase() ?? mostCommonCountry(regions, poiCountries) ?? void 0;
+  const inferredCountry = localeCountry ?? mostCommonCountry(regions, poiCountries) ?? void 0;
+  const inferredScope = localeSubdivision ?? inferredCountry;
   for (const p of deferred) {
     if (p.pos.kind !== "name") continue;
     const got = lookupName(
       p.pos.name,
       p.pos.scope,
       p.lineNumber,
-      inferredCountry,
+      inferredScope,
       true
     );
     if (got.kind === "ok") {
@@ -45884,6 +46490,7 @@ function resolveMap(parsed, data) {
       lat,
       lon,
       ...p.label !== void 0 && { label: p.label },
+      ...p.color !== void 0 && { color: p.color },
       tags: p.tags,
       meta: p.meta,
       lineNumber: p.lineNumber
@@ -45936,7 +46543,8 @@ function resolveMap(parsed, data) {
     const meta = sizeValue !== void 0 ? { value: sizeValue } : {};
     if (pos.kind === "coords") {
       const id = alias ? fold(alias) : `@${pos.lat},${pos.lon}`;
-      if (!looksUS(pos.lat, pos.lon)) anyNonUsPoi = true;
+      if (looksUS(pos.lat, pos.lon)) anyUsPoi = true;
+      else if (!looksNorthAmericaNeighbor(pos.lat, pos.lon)) anyNonNaPoi = true;
       if (!registry.has(id)) {
         registerPoi(
           id,
@@ -45959,7 +46567,7 @@ function resolveMap(parsed, data) {
     if (registry.has(f)) return f;
     const aliased = declaredByName.get(f);
     if (aliased) return aliased;
-    const got = lookupName(pos.name, pos.scope, line12, inferredCountry, true);
+    const got = lookupName(pos.name, pos.scope, line12, inferredScope, true);
     if (got.kind !== "ok") return null;
     noteCountry(got.iso);
     registerPoi(
@@ -46016,9 +46624,12 @@ function resolveMap(parsed, data) {
     }
     routes.push({ stopIds, legs, lineNumber: rt.lineNumber });
   }
+  const hasUsContent = usSubdivisionReferenced || anyUsPoi || localeCountry === "US";
+  const usOriented = !anyNonNaPoi && !regions.some(
+    (r) => r.layer === "country" && !["US", "CA", "MX"].includes(r.iso)
+  ) && hasUsContent;
   const subdivisions = [];
-  if (usSubdivisionReferenced || parsed.directives.region === "us-states")
-    subdivisions.push("us-states");
+  if (usSubdivisionReferenced || usOriented) subdivisions.push("us-states");
   const regionBoxes = [];
   for (const ref of referencedRegionIds) {
     const bb = featureBbox(data.usStates, ref.id);
@@ -46026,7 +46637,7 @@ function resolveMap(parsed, data) {
   }
   for (const r of regions) {
     if (r.layer === "country") {
-      const bb = featureBbox(data.worldCoarse, r.iso);
+      const bb = featureBboxPrimary(data.worldCoarse, r.iso);
       if (bb) regionBoxes.push(bb);
     }
   }
@@ -46036,23 +46647,56 @@ function resolveMap(parsed, data) {
     [-180, -85],
     [180, 85]
   ];
-  let extent2 = unioned ? pad(unioned, PAD_FRACTION) : DEFAULT_EXTENT;
+  const basePad = regions.length > 0 ? REGION_PAD_FRACTION : PAD_FRACTION;
+  let extent2 = unioned ? pad(unioned, basePad) : DEFAULT_EXTENT;
+  const isPoiOnly = pois.length > 0 && regions.length === 0;
+  const containerRegionIds = [];
+  if (isPoiOnly) {
+    const countries = decodeFeatures(data.worldDetail);
+    const states = decodeFeatures(data.usStates);
+    const seen = /* @__PURE__ */ new Set();
+    const containerBoxes = [];
+    for (const p of pois) {
+      const { country, state } = regionAt([p.lon, p.lat], countries, states);
+      const id = state?.iso ?? country?.iso;
+      if (!id || seen.has(id)) continue;
+      seen.add(id);
+      containerRegionIds.push(id);
+      const bb = state ? featureBbox(data.usStates, id) : featureBboxPrimary(data.worldCoarse, id);
+      if (bb && !isWholeSphere(bb)) containerBoxes.push(bb);
+    }
+    const containerUnion = unionExtent(containerBoxes, points);
+    if (containerUnion) extent2 = pad(containerUnion, PAD_FRACTION);
+  }
+  if (isPoiOnly) {
+    const cx = (extent2[0][0] + extent2[1][0]) / 2;
+    const cy = (extent2[0][1] + extent2[1][1]) / 2;
+    const lon = extent2[1][0] - extent2[0][0];
+    const lat = extent2[1][1] - extent2[0][1];
+    const longer = Math.max(lon, lat);
+    if (longer > 0 && longer < POI_ZOOM_FLOOR_DEG) {
+      const k = POI_ZOOM_FLOOR_DEG / longer;
+      const halfLon = lon * k / 2;
+      const halfLat = lat * k / 2;
+      extent2 = [
+        [cx - halfLon, cy - halfLat],
+        [cx + halfLon, cy + halfLat]
+      ];
+    }
+  }
   const lonSpan = extent2[1][0] - extent2[0][0];
   const latSpan = extent2[1][1] - extent2[0][1];
   const span = Math.max(lonSpan, latSpan);
-  const usDominant = (subdivisions.includes("us-states") || regions.some((r) => r.layer === "us-state")) && !regions.some((r) => r.layer === "country" && r.iso !== "US") && !anyNonUsPoi;
+  const maxAbsLat = Math.max(Math.abs(extent2[0][1]), Math.abs(extent2[1][1]));
   let projection;
-  const override = parsed.directives.projection;
-  if (override === "equirectangular" || override === "natural-earth" || override === "albers-usa" || override === "mercator") {
-    projection = override;
-  } else if (usDominant) {
+  if (isPoiOnly && usOriented && lonSpan < US_NATIONAL_LON_SPAN) {
+    projection = "mercator";
+  } else if (usOriented) {
     projection = "albers-usa";
-  } else if (span > WORLD_SPAN) {
+  } else if (span > WORLD_SPAN || maxAbsLat > MERCATOR_MAX_LAT) {
     projection = "equirectangular";
-  } else if (span < MERCATOR_MAX_SPAN) {
-    projection = "mercator";
   } else {
-    projection = "equirectangular";
+    projection = "mercator";
   }
   if (lonSpan >= 180) {
     extent2 = [
@@ -46065,11 +46709,20 @@ function resolveMap(parsed, data) {
   result.edges = edges;
   result.routes = routes;
   result.basemaps = {
-    world: span > WORLD_SPAN ? "coarse" : "detail",
+    // Tier is intentionally pinned to detail (50m) at ALL scales. Diagrammo maps
+    // are presentational (palette tints, relief hachures, POI hubs), not
+    // survey-grade — recognizability > generalization: 110m coarse drops the
+    // Italian boot to a stump at world scale. `WORLD_SPAN` lives on only for the
+    // projection decision (the `usOriented`/`span > WORLD_SPAN` chain above); it
+    // no longer gates basemap resolution.
+    // `worldCoarse` is still loaded — it's the authoritative name/bbox index
+    // (featureIndex, featureBboxPrimary), not dead code.
+    world: "detail",
     subdivisions
   };
   result.extent = extent2;
   result.projection = projection;
+  result.poiFrameContainers = containerRegionIds;
   result.error = parsed.error ?? firstError(diagnostics);
   return result;
 }
@@ -46106,17 +46759,20 @@ function firstError(diags) {
   const e = diags.find((d) => d.severity === "error");
   return e ? formatDgmoError(e) : null;
 }
-var WORLD_SPAN, MERCATOR_MAX_SPAN, PAD_FRACTION, WORLD_LAT_SOUTH, WORLD_LAT_NORTH, REGION_ALIASES, US_STATE_POSTAL;
+var WORLD_SPAN, MERCATOR_MAX_LAT, PAD_FRACTION, REGION_PAD_FRACTION, WORLD_LAT_SOUTH, WORLD_LAT_NORTH, POI_ZOOM_FLOOR_DEG, US_NATIONAL_LON_SPAN, REGION_ALIASES, US_STATE_POSTAL;
 var init_resolver2 = __esm({
   "src/map/resolver.ts"() {
     "use strict";
     init_diagnostics();
     init_geo();
     WORLD_SPAN = 90;
-    MERCATOR_MAX_SPAN = 25;
+    MERCATOR_MAX_LAT = 80;
     PAD_FRACTION = 0.05;
+    REGION_PAD_FRACTION = 0.12;
     WORLD_LAT_SOUTH = -58;
     WORLD_LAT_NORTH = 78;
+    POI_ZOOM_FLOOR_DEG = 7;
+    US_NATIONAL_LON_SPAN = 48;
     REGION_ALIASES = {
       // Common everyday names → the Natural-Earth display name actually shipped.
       "united states": "united states of america",
@@ -46194,112 +46850,269 @@ var init_resolver2 = __esm({
   }
 });
 
-// src/map/load-data.ts
-var load_data_exports = {};
-__export(load_data_exports, {
-  loadMapData: () => loadMapData
+// 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 };
+}
+var init_colorize = __esm({
+  "src/map/colorize.ts"() {
+    "use strict";
+  }
 });
-async function loadNodeBuiltins() {
-  const [{ readFile }, { fileURLToPath }, { dirname, resolve }] = await Promise.all([
-    import("fs/promises"),
-    import("url"),
-    import("path")
-  ]);
-  return { readFile, fileURLToPath, dirname, resolve };
-}
-async function readJson(nb, dir, name) {
-  return JSON.parse(await nb.readFile(nb.resolve(dir, name), "utf8"));
-}
-async function firstExistingDir(nb, baseDir) {
-  for (const rel of CANDIDATE_DIRS) {
-    const dir = nb.resolve(baseDir, rel);
-    try {
-      await nb.readFile(nb.resolve(dir, FILES.gazetteer), "utf8");
-      return dir;
-    } catch {
+
+// src/map/context-labels.ts
+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: 6,
+    continental: 5,
+    regional: 4,
+    local: 3
+  };
+  const area2 = Math.floor(Math.sqrt(Math.max(0, width * height)) / 150);
+  return Math.max(0, Math.min(area2, 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) {
+  const spacing = letterSpacing > 0 ? Math.max(0, text.length - 1) * letterSpacing : 0;
+  return measureLegendText(text, FONT) + spacing + 2 * PADX;
+}
+function wrapLabel2(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 };
   }
-  throw new Error(
-    `map data assets not found near ${baseDir} (looked in ${CANDIDATE_DIRS.join(", ")}). Run \`pnpm build:map-data\` and \`pnpm build\`.`
-  );
+  return best?.lines ?? [text];
 }
-function validate(data) {
-  const topoOk = (t) => !!t && t.type === "Topology" && !!t.objects;
-  if (!topoOk(data.worldCoarse) || !topoOk(data.worldDetail) || !topoOk(data.usStates) || !data.gazetteer || !Array.isArray(data.gazetteer.cities) || !data.gazetteer.byName) {
-    throw new Error("map data assets are malformed (failed shape validation)");
-  }
-  return data;
+function rectAround(cx, cy, lines, letterSpacing) {
+  const w = Math.max(...lines.map((l) => labelWidth(l, letterSpacing)));
+  const h = (lines.length - 1) * LINE_HEIGHT + FONT + 2 * PADY;
+  return { x: cx - w / 2, y: cy - h / 2, w, h };
 }
-function moduleBaseDir(nb) {
-  try {
-    const url = import_meta.url;
-    if (url) return nb.dirname(nb.fileURLToPath(url));
-  } catch {
-  }
-  if (typeof __dirname !== "undefined") return __dirname;
-  return process.cwd();
+function rectFits(r, width, height) {
+  return r.x >= 0 && r.y >= 0 && r.x + r.w <= width && r.y + r.h <= height;
 }
-function loadMapData() {
-  cache ??= (async () => {
-    const nb = await loadNodeBuiltins();
-    const dir = await firstExistingDir(nb, moduleBaseDir(nb));
-    const [
-      worldCoarse,
-      worldDetail,
-      usStates,
-      lakes,
-      rivers,
-      naLand,
-      naLakes,
-      gazetteer
-    ] = await Promise.all([
-      readJson(nb, dir, FILES.worldCoarse),
-      readJson(nb, dir, FILES.worldDetail),
-      readJson(nb, dir, FILES.usStates),
-      // Lakes/rivers/NA assets are optional — older bundles may predate them.
-      readJson(nb, dir, FILES.lakes).catch(() => void 0),
-      readJson(nb, dir, FILES.rivers).catch(() => void 0),
-      readJson(nb, dir, FILES.naLand).catch(() => void 0),
-      readJson(nb, dir, FILES.naLakes).catch(() => void 0),
-      readJson(nb, dir, FILES.gazetteer)
-    ]);
-    return validate({
-      worldCoarse,
-      worldDetail,
-      usStates,
-      gazetteer,
-      ...lakes && { lakes },
-      ...rivers && { rivers },
-      ...naLand && { naLand },
-      ...naLakes && { naLakes }
+function overlapsPadded(a, b, pad2) {
+  return a.x - pad2 < b.x + b.w && a.x + a.w + pad2 > b.x && a.y - pad2 < b.y + b.h && a.y + a.h + pad2 > b.y;
+}
+function placeContextLabels(args) {
+  const {
+    projection,
+    dLonSpan,
+    dLatSpan,
+    width,
+    height,
+    waterBodies,
+    countries,
+    palette,
+    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 = mix(palette.colors.blue, palette.textMuted, 50);
+  const countryColor = 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 = wrapLabel2(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,
+      // Water before any country (×1000), then by tier, then kind, then name.
+      sort: tier * 10 + KIND_ORDER[kind]
     });
-  })().catch((e) => {
-    cache = void 0;
-    throw e;
-  });
-  return cache;
+  }
+  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);
+  let ci = 0;
+  for (const r of ranked) {
+    const { c, w, h } = r;
+    if (w > width * 0.66 || h > height * 0.66) continue;
+    if (!insideViewport(c.anchor, width, height)) continue;
+    const text = c.name;
+    const tw = labelWidth(text, 0);
+    if (tw > w || FONT + 2 * PADY > h) continue;
+    candidates.push({
+      text,
+      lines: [text],
+      cx: c.anchor[0],
+      cy: c.anchor[1],
+      italic: false,
+      letterSpacing: 0,
+      color: countryColor,
+      // Always after every water body (+1e6); larger area = earlier.
+      sort: 1e6 + ci++
+    });
+  }
+  candidates.sort((a, b) => a.sort - b.sort);
+  const placed = [];
+  const placedRects = [];
+  for (const cand of candidates) {
+    if (placed.length >= budget) break;
+    const rect = rectAround(cand.cx, cand.cy, cand.lines, cand.letterSpacing);
+    if (!rectFits(rect, width, height)) continue;
+    if (cand.italic && overLand) {
+      const inset = 2;
+      const top = cand.cy - (cand.lines.length - 1) / 2 * LINE_HEIGHT;
+      const touchesLand = cand.lines.some((line12, li) => {
+        const lw = labelWidth(line12, cand.letterSpacing);
+        const x0 = cand.cx - lw / 2 + inset;
+        const x1 = cand.cx + lw / 2 - inset;
+        const xs = [x0, (x0 + cand.cx) / 2, cand.cx, (cand.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) continue;
+    }
+    if (collides(rect)) continue;
+    if (placedRects.some((r) => overlapsPadded(rect, r, CONTEXT_PAD))) continue;
+    placedRects.push(rect);
+    placed.push({
+      x: cand.cx,
+      y: cand.cy,
+      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,
+      italic: cand.italic,
+      letterSpacing: cand.letterSpacing,
+      ...cand.lines.length > 1 ? { lines: cand.lines } : {},
+      lineNumber: 0
+    });
+  }
+  return placed;
 }
-var import_meta, FILES, CANDIDATE_DIRS, cache;
-var init_load_data = __esm({
-  "src/map/load-data.ts"() {
+var FONT, LINE_HEIGHT, PADX, PADY, WATER_LETTER_SPACING, CONTEXT_PAD, EDGE_CLAMP_MARGIN, EDGE_CLAMP_OVERSHOOT, KIND_ORDER;
+var init_context_labels = __esm({
+  "src/map/context-labels.ts"() {
     "use strict";
-    import_meta = {};
-    FILES = {
-      worldCoarse: "world-coarse.json",
-      worldDetail: "world-detail.json",
-      usStates: "us-states.json",
-      lakes: "lakes.json",
-      rivers: "rivers.json",
-      naLand: "na-land.json",
-      naLakes: "na-lakes.json",
-      gazetteer: "gazetteer.json"
+    init_color_utils();
+    init_legend_constants();
+    FONT = 11;
+    LINE_HEIGHT = FONT + 2;
+    PADX = 4;
+    PADY = 3;
+    WATER_LETTER_SPACING = 1.5;
+    CONTEXT_PAD = 4;
+    EDGE_CLAMP_MARGIN = 8;
+    EDGE_CLAMP_OVERSHOOT = 0.35;
+    KIND_ORDER = {
+      ocean: 0,
+      sea: 1,
+      gulf: 2,
+      bay: 3,
+      strait: 4,
+      channel: 5,
+      sound: 6
     };
-    CANDIDATE_DIRS = [
-      "./data",
-      "./map-data",
-      "../map-data",
-      "../src/map/data"
-    ];
   }
 });
 
@@ -46308,12 +47121,34 @@ function geomObject2(topo) {
   const key = Object.keys(topo.objects)[0];
   return topo.objects[key];
 }
+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 geomObject2(topo).geometries) {
     const f = (0, import_topojson_client2.feature)(topo, g);
-    out.set(g.id, { ...f, id: g.id });
+    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 projectionFor(family) {
@@ -46322,38 +47157,35 @@ function projectionFor(family) {
       return usConusProjection();
     case "mercator":
       return (0, import_d3_geo2.geoMercator)();
+    case "equal-earth":
+      return (0, import_d3_geo2.geoEqualEarth)();
+    case "equirectangular":
+      return (0, import_d3_geo2.geoEquirectangular)();
     case "natural-earth":
       return (0, import_d3_geo2.geoNaturalEarth1)();
-    case "equirectangular":
     default:
       return (0, import_d3_geo2.geoEquirectangular)();
   }
 }
-function mapBackgroundColor(palette, isDark = false, dataActive = false) {
-  if (dataActive)
-    return mix(
-      palette.colors.gray,
-      palette.bg,
-      isDark ? MUTED_WATER_DARK : MUTED_WATER_LIGHT
-    );
-  return mix(palette.colors.blue, palette.bg, WATER_TINT);
+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) {
-  if (dataActive)
-    return isDark ? mix(palette.colors.gray, palette.bg, MUTED_LAND_DARK) : palette.bg;
+function mapNeutralLandColor(palette, isDark, _dataActive = false) {
   return mix(
     palette.colors.green,
     palette.bg,
     isDark ? LAND_TINT_DARK : LAND_TINT_LIGHT
   );
 }
-function layoutMap(resolved, data, size, opts) {
-  const { palette, isDark } = opts;
-  const { width, height } = size;
+function buildMapProjection(resolved, data) {
   const wantsUsStates = resolved.basemaps.subdivisions.includes("us-states");
-  const usCrisp = resolved.projection === "albers-usa" && wantsUsStates && !!data.naLand;
+  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 = decodeLayer(worldTopo);
+  const worldLayer = new Map(decodeLayer(worldTopo));
   if (usCrisp && data.naLand) {
     const [nbW, nbS, nbE, nbN] = [-140, 10, -52, 66];
     const crisp = decodeLayer(data.naLand);
@@ -46362,17 +47194,110 @@ function layoutMap(resolved, data, size, opts) {
       if (!base) continue;
       const [[bw, bs], [be, bn]] = (0, import_d3_geo2.geoBounds)(base);
       if (bw >= nbW && be <= nbE && bs >= nbS && bn <= nbN)
-        worldLayer.set(iso, cf);
+        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);
+  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 = (0, import_d3_geo2.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 layoutMap(resolved, data, size, opts) {
+  const { palette, isDark } = opts;
+  const { width, height } = size;
+  const {
+    projection,
+    fitTarget,
+    fitIsGlobal,
+    worldLayer,
+    usLayer,
+    usCrisp,
+    worldTopo
+  } = buildMapProjection(resolved, data);
   const usContext = usLayer !== null;
   const regionStroke = isDark ? mix(palette.bg, palette.text, 78) : mix(palette.text, palette.bg, 78);
   const values = resolved.regions.filter((r) => r.value !== void 0).map((r) => r.value);
-  const scaleOverride = resolved.directives.scale;
-  const rampMin = scaleOverride ? scaleOverride.min : Math.min(...values);
-  const rampMax = scaleOverride ? scaleOverride.max : Math.max(...values);
-  const rampHue = palette.colors.red;
+  const allNonNegative = values.length > 0 && values.every((v) => v >= 0);
+  const rampMin = allNonNegative ? 0 : Math.min(...values);
+  const rampMax = Math.max(...values);
+  const rampHue = resolveColor(resolved.directives.regionMetricColor ?? "", palette) ?? palette.colors.red;
   const hasRamp = values.length > 0;
   const VALUE_NAME = hasRamp ? resolved.directives.regionMetric?.trim() || "Value" : null;
   const matchColorGroup = (v) => {
@@ -46392,14 +47317,48 @@ function layoutMap(resolved, data, size, opts) {
     activeGroup = VALUE_NAME ?? (resolved.tagGroups.length > 0 ? resolved.tagGroups[0].name : null);
   }
   const activeIsScore = VALUE_NAME !== null && activeGroup === VALUE_NAME;
-  const mutedBasemap = resolved.directives.basemapStyle === "muted" ? true : resolved.directives.basemapStyle === "natural" ? false : activeGroup !== null;
+  const mutedBasemap = activeGroup !== null;
   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 colorizeActive = resolved.directives.noColorize !== true && !hasRamp && resolved.tagGroups.length === 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 = (fill2) => mix(fill2, palette.text, 35);
   const rampBase = isDark ? mix(palette.surface, palette.text, 28) : palette.bg;
   const fillForValue = (s) => {
     const t = rampMax > rampMin ? (s - rampMin) / (rampMax - rampMin) : 1;
@@ -46424,47 +47383,26 @@ function layoutMap(resolved, data, size, opts) {
       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]));
-  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);
-  } else {
-    fitFeatures = [extentOutline()];
-  }
-  const fitTarget = { type: "FeatureCollection", features: fitFeatures };
-  const projection = projectionFor(resolved.projection);
-  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 TITLE_GAP = 16;
+  const TITLE_GAP2 = 16;
   let topPad = FIT_PAD;
   if (resolved.title && 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);
+    topPad = Math.max(FIT_PAD, bannerBottom + TITLE_GAP2);
   }
   const fitBox = [
     [FIT_PAD, topPad],
@@ -46474,11 +47412,10 @@ function layoutMap(resolved, data, size, opts) {
     ]
   ];
   projection.fitExtent(fitBox, fitTarget);
-  const fitGB = (0, import_d3_geo2.geoBounds)(fitTarget);
-  const fitIsGlobal = fitGB[1][0] - fitGB[0][0] >= 270 || fitGB[1][1] - fitGB[0][1] >= 130;
   let path;
   let project;
-  if (fitIsGlobal) {
+  let stretchParams = null;
+  if (fitIsGlobal && !opts.preferContain) {
     const cb = (0, import_d3_geo2.geoPath)(projection).bounds(fitTarget);
     const bx0 = cb[0][0];
     const by0 = cb[0][1];
@@ -46488,6 +47425,7 @@ function layoutMap(resolved, data, size, opts) {
     const oy = fitBox[0][1];
     const sx = cw > 0 ? (fitBox[1][0] - ox) / cw : 1;
     const sy = ch > 0 ? (fitBox[1][1] - oy) / ch : 1;
+    stretchParams = { sx, sy, ox, oy, bx0, by0 };
     const stretch = (x, y) => [
       ox + (x - bx0) * sx,
       oy + (y - by0) * sy
@@ -46519,7 +47457,9 @@ function layoutMap(resolved, data, size, opts) {
   const insets = [];
   const insetRegions = [];
   const insetLabelSeeds = [];
-  if (resolved.projection === "albers-usa" && usLayer) {
+  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;
@@ -46550,38 +47490,14 @@ function layoutMap(resolved, data, size, opts) {
       }
       return y;
     };
-    const coastTop = (x0, xr) => {
+    const coastFloor = (x0, xr) => {
       const n = 24;
-      const pts = [];
       let maxY = -Infinity;
       for (let i = 0; i <= n; i++) {
-        const x = x0 + (xr - x0) * i / n;
-        const y = at(x);
-        if (y > -Infinity) {
-          pts.push([x, y]);
-          if (y > maxY) maxY = y;
-        }
-      }
-      if (pts.length === 0) return () => yB - height * 0.42;
-      let m = 0;
-      if (pts.length >= 2) {
-        let sx = 0, sy = 0, sxx = 0, sxy = 0;
-        for (const [x, y] of pts) {
-          sx += x;
-          sy += y;
-          sxx += x * x;
-          sxy += x * y;
-        }
-        const den = pts.length * sxx - sx * sx;
-        if (den !== 0) m = (pts.length * sxy - sx * sy) / den;
-      }
-      m = Math.max(-0.35, Math.min(0.35, m));
-      let c = -Infinity;
-      for (const [x, y] of pts) {
-        const need = y - m * x + GAP;
-        if (need > c) c = need;
-      }
-      return (x) => m * x + c;
+        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);
@@ -46590,19 +47506,15 @@ function layoutMap(resolved, data, size, opts) {
       const iw = Math.min(iwReq, width - FIT_PAD - x0 - 2 * PAD);
       if (iw < 24) return boxX;
       const xr = x0 + iw + 2 * PAD;
-      const top = coastTop(x0, xr);
-      const yL = top(x0);
-      const yR = top(xr);
+      const floor = coastFloor(x0, xr);
+      const topGuess = floor > -Infinity ? floor + GAP : yB - height * 0.42;
       proj.fitWidth(iw, f);
       const bb = (0, import_d3_geo2.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 = Math.max(yL, yR);
+      let topFit = topGuess;
       const bottom = Math.min(topFit + needH, yB);
       if (bottom - topFit < needH) topFit = bottom - needH;
-      const lift = topFit - Math.max(yL, yR);
-      const topL = yL + lift;
-      const topR = yR + lift;
       proj.fitExtent(
         [
           [x0 + PAD, topFit + PAD],
@@ -46612,8 +47524,18 @@ function layoutMap(resolved, data, size, opts) {
       );
       const d = (0, import_d3_geo2.geoPath)(proj)(f) ?? "";
       if (!d) return xr;
+      let contextLand;
+      if (iso === "US-AK") {
+        const can = worldLayer.get("CA");
+        const cd = can ? (0, import_d3_geo2.geoPath)(proj)(can) ?? "" : "";
+        if (cd)
+          contextLand = {
+            d: cd,
+            fill: colorizeActive ? colorByIso.get("CA") ?? foreignFill : foreignFill
+          };
+      }
       const r = regionById.get(iso);
-      let fill2 = neutralFill;
+      let fill2 = colorizeActive ? colorByIso.get(iso) ?? neutralFill : neutralFill;
       let lineNumber = -1;
       if (r?.layer === "us-state") {
         fill2 = regionFill(r);
@@ -46621,21 +47543,25 @@ function layoutMap(resolved, data, size, opts) {
       }
       insets.push({
         x: x0,
-        y: Math.min(topL, topR),
+        y: topFit,
         w: xr - x0,
-        h: bottom - Math.min(topL, topR),
+        h: bottom - topFit,
         points: [
-          [x0, topL],
-          [xr, topR],
+          [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: fill2,
-        stroke: regionStroke,
+        stroke: colorizeActive ? colorizeStroke(fill2) : regionStroke,
         lineNumber,
         layer: "us-state",
         ...r?.value !== void 0 && { value: r.value },
@@ -46648,13 +47574,16 @@ function layoutMap(resolved, data, size, opts) {
       }
       return xr;
     };
-    const akRight = placeInset(
-      "US-AK",
-      alaskaProjection(),
-      FIT_PAD,
-      width * 0.15
-    );
-    placeInset("US-HI", hawaiiProjection(), akRight + 24, width * 0.1);
+    let akRight = FIT_PAD;
+    if (akRef)
+      akRight = placeInset("US-AK", alaskaProjection(), FIT_PAD, width * 0.15);
+    if (hiRef)
+      placeInset(
+        "US-HI",
+        hawaiiProjection(),
+        akRef ? akRight + 24 : FIT_PAD,
+        width * 0.1
+      );
   }
   const conusFit = resolved.projection === "albers-usa" && !!usLayer;
   const classifyExtent = conusFit ? (0, import_d3_geo2.geoBounds)(fitTarget) : resolved.extent;
@@ -46670,15 +47599,24 @@ function layoutMap(resolved, data, size, opts) {
   };
   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;
     }
-    if (loMax - loMin > 270) return false;
-    if (rawMax - rawMin > 180 && loMax - loMin < 90) return false;
+    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);
@@ -46751,7 +47689,7 @@ function layoutMap(resolved, data, size, opts) {
   const regions = [];
   const pushRegionLayer = (layerFeatures, layerKind, shouldCull) => {
     for (const [iso, f] of layerFeatures) {
-      if (layerKind === "us-state" && usContext && INSET_STATES.has(iso))
+      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"))
@@ -46763,7 +47701,8 @@ function layoutMap(resolved, data, size, opts) {
       if (!d) continue;
       const isThisLayer = r?.layer === layerKind;
       const isForeign = layerKind === "country" && usContext && iso !== "US";
-      let fill2 = isForeign ? foreignFill : neutralFill;
+      const baseFill = isForeign ? foreignFill : neutralFill;
+      let fill2 = colorizeActive ? colorByIso.get(iso) ?? baseFill : baseFill;
       let label;
       let lineNumber = -1;
       let layer = "base";
@@ -46772,12 +47711,14 @@ function layoutMap(resolved, data, size, opts) {
         lineNumber = r.lineNumber;
         layer = layerKind;
         label = r.name;
+      } else {
+        label = f.properties?.name;
       }
       regions.push({
         id: iso,
         d,
         fill: fill2,
-        stroke: regionStroke,
+        stroke: colorizeActive ? colorizeStroke(fill2) : regionStroke,
         lineNumber,
         layer,
         ...label !== void 0 && { label },
@@ -46799,13 +47740,88 @@ function layoutMap(resolved, data, size, opts) {
         id: "lake",
         d,
         fill: water,
-        stroke: "none",
+        stroke: lakeStroke,
         lineNumber: -1,
         layer: "base"
       });
     }
   }
-  const riverColor = water;
+  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) => ({
+    fill: r.fill,
+    rings: parsePathRings(r.d)
+  }));
+  const fillAt = (x, y) => {
+    let hit = water;
+    for (const t of fillHitTargets)
+      if (pointInRings(x, y, t.rings)) hit = t.fill;
+    return hit;
+  };
+  const labelOnFill = (fill2) => {
+    const color = contrastRatio(fill2, palette.textOnFillDark) >= contrastRatio(fill2, palette.textOnFillLight) ? palette.textOnFillDark : palette.textOnFillLight;
+    const haloColor = color === palette.textOnFillLight ? palette.textOnFillDark : palette.textOnFillLight;
+    return {
+      color,
+      halo: contrastRatio(fill2, 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 area2 = path.area(viewF);
+      if (!Number.isFinite(area2) || area2 < 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)) {
@@ -46826,6 +47842,9 @@ function layoutMap(resolved, data, size, opts) {
     return R_MIN + Math.max(0, Math.min(1, t)) * (R_MAX - R_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[group.name.toLowerCase()];
       if (!val) continue;
@@ -46858,38 +47877,108 @@ function layoutMap(resolved, data, size, opts) {
     const xy = project(p.lon, p.lat);
     if (xy) projected.push({ p, xy });
   }
-  const coloGroups = /* @__PURE__ */ new Map();
+  const placePoi = (e, cx, cy, clusterId) => {
+    const { fill: fill2, stroke: stroke2 } = poiFill(e.p);
+    poiScreen.set(e.p.id, { cx, cy, r: radiusFor(e.p) });
+    const num = routeNumberById.get(e.p.id);
+    pois.push({
+      id: e.p.id,
+      cx,
+      cy,
+      r: radiusFor(e.p),
+      fill: fill2,
+      stroke: stroke2,
+      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) {
-    const key = `${Math.round(e.xy[0] / COLO_EPS)},${Math.round(e.xy[1] / COLO_EPS)}`;
-    const arr = coloGroups.get(key);
-    if (arr) arr.push(e);
-    else coloGroups.set(key, [e]);
-  }
-  for (const group of coloGroups.values()) {
-    group.forEach((e, i) => {
-      let cx = e.xy[0];
-      let cy = e.xy[1];
-      if (group.length > 1) {
-        const ang = i * GOLDEN_ANGLE;
-        cx += Math.cos(ang) * COLO_R;
-        cy += Math.sin(ang) * COLO_R;
-      }
-      const { fill: fill2, stroke: stroke2 } = poiFill(e.p);
-      poiScreen.set(e.p.id, { cx, cy, r: radiusFor(e.p) });
-      const num = routeNumberById.get(e.p.id);
-      pois.push({
-        id: e.p.id,
-        cx,
-        cy,
-        r: radiusFor(e.p),
-        fill: fill2,
-        stroke: stroke2,
-        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 }
-      });
+    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 = [];
@@ -46939,16 +48028,26 @@ function layoutMap(resolved, data, size, opts) {
       if (!a || !b) continue;
       const mx = (a.cx + b.cx) / 2;
       const my = (a.cy + b.cy) / 2;
+      const bow = {
+        curved: leg.style === "arc",
+        offset: 0,
+        labelX: mx,
+        labelY: my - 4
+      };
+      const routeLabelStyle = leg.label !== void 0 ? labelOnFill(fillAt(bow.labelX, bow.labelY)) : void 0;
       legs.push({
-        d: legPath(a, b, leg.style === "arc", 0),
+        d: legPath(a, b, bow.curved, bow.offset),
         width: routeWidthFor(Number(leg.value)),
         color: mix(palette.text, palette.bg, 72),
         arrow: true,
         lineNumber: leg.lineNumber,
         ...leg.label !== void 0 && {
           label: leg.label,
-          labelX: mx,
-          labelY: my - 4
+          labelX: bow.labelX,
+          labelY: bow.labelY,
+          labelColor: routeLabelStyle.color,
+          labelHalo: routeLabelStyle.halo,
+          labelHaloColor: routeLabelStyle.haloColor
         }
       });
     }
@@ -46976,20 +48075,29 @@ function layoutMap(resolved, data, size, opts) {
       const a = poiScreen.get(e.fromId);
       const b = poiScreen.get(e.toId);
       if (!a || !b) return;
-      const curved = e.style === "arc" || n > 1;
-      const offset = n > 1 ? (i - (n - 1) / 2) * FAN_STEP : 0;
+      const fanOffset = n > 1 ? (i - (n - 1) / 2) * FAN_STEP : 0;
       const mx = (a.cx + b.cx) / 2;
       const my = (a.cy + b.cy) / 2;
+      const bow = {
+        curved: e.style === "arc" || n > 1,
+        offset: fanOffset,
+        labelX: mx,
+        labelY: my - 4
+      };
+      const edgeLabelStyle = e.label !== void 0 ? labelOnFill(fillAt(bow.labelX, bow.labelY)) : void 0;
       legs.push({
-        d: legPath(a, b, curved, offset),
+        d: legPath(a, b, bow.curved, bow.offset),
         width: widthFor(e),
         color: mix(palette.text, palette.bg, 66),
         arrow: e.directed,
         lineNumber: e.lineNumber,
         ...e.label !== void 0 && {
           label: e.label,
-          labelX: mx,
-          labelY: my - 4
+          labelX: bow.labelX,
+          labelY: bow.labelY,
+          labelColor: edgeLabelStyle.color,
+          labelHalo: edgeLabelStyle.halo,
+          labelHaloColor: edgeLabelStyle.haloColor
         }
       });
     });
@@ -47031,25 +48139,25 @@ function layoutMap(resolved, data, size, opts) {
     }
   }
   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 regionLabelMode = resolved.directives.regionLabels ?? "off";
+  const showRegionLabels = resolved.directives.noRegionLabels !== true;
+  const isCompact = width < COMPACT_WIDTH_PX;
   const LABEL_PADX = 6;
   const LABEL_PADY = 3;
-  const labelW = (text) => measureLegendText(text, FONT) + 2 * LABEL_PADX;
-  const labelH = FONT + 2 * LABEL_PADY;
+  const labelW = (text) => measureLegendText(text, FONT2) + 2 * LABEL_PADX;
+  const labelH = FONT2 + 2 * LABEL_PADY;
   const pushRegionLabel = (x, y, text, fill2, lineNumber) => {
-    const color = contrastText(
-      fill2,
-      palette.textOnFillLight,
-      palette.textOnFillDark
+    const { color, haloColor } = labelOnFill(fill2);
+    const halfW = measureLegendText(text, FONT2) / 2;
+    const overflows = [y - FONT2 * 0.55, y - FONT2 * 0.1].some(
+      (sy) => fillAt(x - halfW, sy) !== fill2 || fillAt(x + halfW, sy) !== fill2
     );
-    const haloColor = color === palette.textOnFillLight ? palette.textOnFillDark : palette.textOnFillLight;
     labels.push({
       x,
       y,
       text,
       anchor: "middle",
       color,
-      halo: true,
+      halo: overflows,
       haloColor,
       lineNumber
     });
@@ -47058,21 +48166,50 @@ function layoutMap(resolved, data, size, opts) {
     US: [-98.5, 39.5]
     // CONUS geographic centre (near Lebanon, Kansas)
   };
-  if (regionLabelMode === "full" || regionLabelMode === "abbrev") {
-    for (const r of regions) {
-      if (r.layer === "base" || r.label === void 0) continue;
-      const f = r.layer === "us-state" ? usLayer?.get(r.id) : worldLayer.get(r.id);
-      if (!f) continue;
+  const REGION_LABEL_GAP = 2;
+  const regionLabelRect = (cx, cy, text) => {
+    const w = measureLegendText(text, FONT2) + 2 * REGION_LABEL_GAP;
+    return { x: cx - w / 2, y: cy - FONT2 / 2, w, h: FONT2 };
+  };
+  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 text = regionLabelMode === "abbrev" ? r.id.replace(/^US-/, "") : r.label;
-      if (labelW(text) > x1 - x0 || labelH > y1 - y0) continue;
-      const anchor = r.layer !== "us-state" ? WORLD_LABEL_ANCHORS[r.id] : void 0;
+      const boxW = x1 - x0;
+      const boxH = y1 - y0;
+      const abbrev = isUsState ? r.id.replace(/^US-/, "") : void 0;
+      const candidates = abbrev !== void 0 ? isCompact ? [abbrev, 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])) continue;
+      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 = [];
+    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)
+    }));
+    for (const { r, c, boxW, boxH, candidates } of entries) {
+      const text = candidates.find((t) => {
+        if (labelW(t) > boxW || labelH > boxH) return false;
+        const rect = regionLabelRect(c[0], c[1], t);
+        return !placedRegionRects.some((p) => rectsOverlap(rect, p)) && !poiObstacles.some((o) => rectsOverlap(rect, o));
+      });
+      if (text === void 0) continue;
+      placedRegionRects.push(regionLabelRect(c[0], c[1], text));
       pushRegionLabel(c[0], c[1], text, r.fill, r.lineNumber);
     }
     for (const seed of insetLabelSeeds) {
-      const text = regionLabelMode === "abbrev" ? seed.iso.replace(/^US-/, "") : seed.name;
+      const text = isCompact ? seed.iso.replace(/^US-/, "") : seed.name;
       const src = regionById.get(seed.iso);
       pushRegionLabel(
         seed.x,
@@ -47083,22 +48220,26 @@ function layoutMap(resolved, data, size, opts) {
       );
     }
   }
-  const poiLabelMode = resolved.directives.poiLabels ?? "auto";
-  if (poiLabelMode !== "off") {
-    const ordered = [...pois].sort(
-      (a, b) => a.lineNumber - b.lineNumber || (a.id < b.id ? -1 : 1)
-    );
+  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 = FONT * 1.25;
+    const poiLabH = FONT2 * 1.25;
     const labelInfo = (p) => {
       const text = labelText(p);
-      return { text, w: measureLegendText(text, FONT) };
+      return { text, w: measureLegendText(text, FONT2) };
     };
     const GAP = 3;
+    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":
@@ -47128,11 +48269,11 @@ function layoutMap(resolved, data, size, opts) {
       const x = side === "right" ? rect.x : side === "left" ? rect.x + w : p.cx;
       labels.push({
         x,
-        y: rect.y + poiLabH / 2 + FONT / 3,
+        y: rect.y + poiLabH / 2 + FONT2 / 3,
         text,
         anchor,
         color: palette.text,
-        halo: true,
+        halo: false,
         haloColor: palette.bg,
         poiId: p.id,
         lineNumber: p.lineNumber
@@ -47143,43 +48284,60 @@ function layoutMap(resolved, data, size, opts) {
       return rect.x >= 0 && rect.x + rect.w <= width && rect.y >= 0 && rect.y + rect.h <= height && !collides(rect);
     };
     const GROUP_R = 30;
-    const groups = [];
+    const groups2 = [];
     for (const p of ordered) {
-      const near = groups.find(
+      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 groups.push([p]);
+      else groups2.push([p]);
     }
     const ROW_GAP2 = 3;
     const step = poiLabH + ROW_GAP2;
     const COL_GAP = 16;
-    const placeColumn = (group) => {
-      const items = group.map((p) => ({ p, ...labelInfo(p) })).sort((a, b) => a.p.cy - b.p.cy || (a.text < b.text ? -1 : 1));
+    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 cyMid = (Math.min(...items.map((o) => o.p.cy)) + Math.max(...items.map((o) => o.p.cy))) / 2;
       const maxW = Math.max(...items.map((o) => o.w));
-      const side = right + COL_GAP + maxW <= width - 2 ? "right" : "left";
-      const colX = side === "right" ? right + COL_GAP : left - COL_GAP;
+      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 - 2 - maxW) : Math.max(left - COL_GAP, 2 + maxW);
       const totalH = items.length * step;
       let startY = cyMid - totalH / 2;
       startY = Math.max(2, Math.min(startY, height - totalH - 2));
-      items.forEach((o, i) => {
+      return items.map((o, i) => {
         const rowCy = startY + i * step + step / 2;
-        obstacles.push({
-          x: side === "right" ? colX : colX - o.w,
-          y: rowCy - poiLabH / 2,
-          w: o.w,
-          h: poiLabH
-        });
+        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 defaultColumnSide = (items) => {
+      const right = Math.max(...items.map((o) => o.p.cx + o.p.r));
+      const maxW = Math.max(...items.map((o) => o.w));
+      return right + COL_GAP + maxW <= width - 2 ? "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 + FONT / 3,
+          y: rowCy + FONT2 / 3,
           text: o.text,
           anchor: side === "right" ? "start" : "end",
           color: palette.text,
-          halo: true,
+          halo: false,
           haloColor: palette.bg,
           leader: {
             x1: o.p.cx,
@@ -47189,24 +48347,141 @@ function layoutMap(resolved, data, size, opts) {
           },
           leaderColor: o.p.fill,
           poiId: o.p.id,
-          lineNumber: o.p.lineNumber
+          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
       });
     };
-    for (const g of groups) {
+    for (const [clusterId, members] of clusterMembersById) {
+      if (members.length === 0) continue;
+      const items = makeItems(members);
+      const side = wouldColumnBeClean(items, "right") ? "right" : wouldColumnBeClean(items, "left") ? "left" : defaultColumnSide(items);
+      commitColumn(items, side, clusterId);
+    }
+    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 = g[0];
-        const { text, w } = labelInfo(p);
+        const { p, text, w } = items[0];
         const side = ["right", "left", "above", "below"].find(
           (s) => inlineFits(p, w, s)
         );
-        if (side) {
-          pushInline(p, text, w, side);
-          continue;
+        if (side) pushInline(p, text, w, side);
+        else commitColumn(items, defaultColumnSide(items));
+        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 side = ["right", "left"].find(
+        (s) => wouldColumnBeClean(items, s)
+      );
+      if (side) commitColumn(items, side);
+      else items.forEach((o) => pushHidden(o.p));
+    }
+  }
+  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 = [];
+    for (const f of worldLayer.values()) {
+      const iso = typeof f.id === "string" ? f.id : String(f.id ?? "");
+      if (!iso || regionById.has(iso)) 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);
+      countryCandidates.push({
+        name: f.properties?.name ?? iso,
+        bbox: [x0, y0, x1, y1],
+        anchor: a && Number.isFinite(a[0]) ? [a[0], a[1]] : null
+      });
+    }
+    const framedStateContainers = (resolved.poiFrameContainers ?? []).some(
+      (id) => id.startsWith("US-")
+    );
+    if (usLayer && framedStateContainers) {
+      const containerSet = new Set(resolved.poiFrameContainers);
+      for (const [iso, f] of usLayer) {
+        if (containerSet.has(iso) || regionById.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
+        });
       }
-      placeColumn(g);
     }
+    const contextLabels = placeContextLabels({
+      projection: resolved.projection,
+      dLonSpan,
+      dLatSpan,
+      width,
+      height,
+      waterBodies: data.waterBodies,
+      countries: countryCandidates,
+      palette,
+      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);
   }
   let legend = null;
   if (!resolved.directives.noLegend) {
@@ -47241,24 +48516,35 @@ function layoutMap(resolved, data, size, opts) {
     ...resolved.caption !== void 0 && { caption: resolved.caption },
     regions,
     rivers,
+    relief,
+    reliefHatch,
+    coastlineStyle,
     legs,
     pois,
+    clusters,
     labels,
     legend,
     insets,
-    insetRegions
+    insetRegions,
+    projection,
+    stretch: stretchParams,
+    diagnostics: []
   };
 }
-var import_d3_geo2, import_topojson_client2, FIT_PAD, RAMP_FLOOR, R_DEFAULT, R_MIN, R_MAX, W_MIN, W_MAX, FONT, COLO_EPS, LAND_TINT_LIGHT, LAND_TINT_DARK, TAG_TINT_LIGHT, TAG_TINT_DARK, WATER_TINT, RIVER_WIDTH, FOREIGN_TINT_LIGHT, FOREIGN_TINT_DARK, MUTED_WATER_LIGHT, MUTED_WATER_DARK, MUTED_FOREIGN_LIGHT, MUTED_FOREIGN_DARK, MUTED_LAND_DARK, COLO_R, GOLDEN_ANGLE, FAN_STEP, ARC_CURVE_FRAC, usConusProjection, alaskaProjection, hawaiiProjection, INSET_STATES, US_NON_CONUS;
+var import_d3_geo2, import_topojson_client2, FIT_PAD, RAMP_FLOOR, R_DEFAULT, R_MIN, R_MAX, W_MIN, W_MAX, FONT2, MAX_CLUSTER_EXTENT_FACTOR, MAX_COLUMN_ROWS, REGION_LABEL_HALO_RATIO, LAND_TINT_LIGHT, LAND_TINT_DARK, TAG_TINT_LIGHT, TAG_TINT_DARK, WATER_TINT_LIGHT, WATER_TINT_DARK, RIVER_WIDTH, COMPACT_WIDTH_PX, RELIEF_MIN_AREA, RELIEF_MIN_DIM, RELIEF_HATCH_SPACING, RELIEF_HATCH_WIDTH, RELIEF_HATCH_STRENGTH, COASTLINE_RING_COUNT, COASTLINE_D0, COASTLINE_STEP, COASTLINE_THICKNESS, COASTLINE_OPACITY_NEAR, COASTLINE_OPACITY_FAR, COASTLINE_MIN_EXTENT, COASTLINE_MIN_EXTENT_GLOBAL, COASTLINE_STROKE_MIX, FOREIGN_TINT_LIGHT, FOREIGN_TINT_DARK, MUTED_FOREIGN_LIGHT, MUTED_FOREIGN_DARK, COLO_R, GOLDEN_ANGLE, STACK_OVERLAP, STACK_RING_MAX, STACK_RING_GAP, FAN_STEP, ARC_CURVE_FRAC, decodeCache, usConusProjection, alaskaProjection, hawaiiProjection, INSET_STATES, inAlaska, inHawaii, FOREIGN_BORDER, US_NON_CONUS;
 var init_layout15 = __esm({
   "src/map/layout.ts"() {
     "use strict";
     import_d3_geo2 = require("d3-geo");
     import_topojson_client2 = require("topojson-client");
     init_color_utils();
+    init_geo();
+    init_colorize();
+    init_colors();
     init_label_layout();
     init_legend_constants();
     init_title_constants();
+    init_context_labels();
     FIT_PAD = 24;
     RAMP_FLOOR = 15;
     R_DEFAULT = 6;
@@ -47266,29 +48552,66 @@ var init_layout15 = __esm({
     R_MAX = 22;
     W_MIN = 1.25;
     W_MAX = 8;
-    FONT = 11;
-    COLO_EPS = 1.5;
-    LAND_TINT_LIGHT = 58;
-    LAND_TINT_DARK = 75;
+    FONT2 = 11;
+    MAX_CLUSTER_EXTENT_FACTOR = 0.18;
+    MAX_COLUMN_ROWS = 7;
+    REGION_LABEL_HALO_RATIO = 4.5;
+    LAND_TINT_LIGHT = 12;
+    LAND_TINT_DARK = 24;
     TAG_TINT_LIGHT = 60;
     TAG_TINT_DARK = 68;
-    WATER_TINT = 55;
+    WATER_TINT_LIGHT = 24;
+    WATER_TINT_DARK = 24;
     RIVER_WIDTH = 1.3;
+    COMPACT_WIDTH_PX = 480;
+    RELIEF_MIN_AREA = 12;
+    RELIEF_MIN_DIM = 2;
+    RELIEF_HATCH_SPACING = 2;
+    RELIEF_HATCH_WIDTH = 0.15;
+    RELIEF_HATCH_STRENGTH = 32;
+    COASTLINE_RING_COUNT = 5;
+    COASTLINE_D0 = 16e-4;
+    COASTLINE_STEP = 28e-4;
+    COASTLINE_THICKNESS = 14e-4;
+    COASTLINE_OPACITY_NEAR = 0.5;
+    COASTLINE_OPACITY_FAR = 0.1;
+    COASTLINE_MIN_EXTENT = 6e-4;
+    COASTLINE_MIN_EXTENT_GLOBAL = 6e-4;
+    COASTLINE_STROKE_MIX = 32;
     FOREIGN_TINT_LIGHT = 30;
     FOREIGN_TINT_DARK = 62;
-    MUTED_WATER_LIGHT = 14;
-    MUTED_WATER_DARK = 10;
     MUTED_FOREIGN_LIGHT = 28;
     MUTED_FOREIGN_DARK = 16;
-    MUTED_LAND_DARK = 24;
     COLO_R = 9;
     GOLDEN_ANGLE = 2.399963229728653;
+    STACK_OVERLAP = 1;
+    STACK_RING_MAX = 8;
+    STACK_RING_GAP = 4;
     FAN_STEP = 16;
     ARC_CURVE_FRAC = 0.18;
+    decodeCache = /* @__PURE__ */ new WeakMap();
     usConusProjection = () => (0, import_d3_geo2.geoConicEqualArea)().parallels([29.5, 45.5]).rotate([96, 0]);
     alaskaProjection = () => (0, import_d3_geo2.geoConicEqualArea)().rotate([154, 0]).center([-2, 58.5]).parallels([55, 65]);
     hawaiiProjection = () => (0, import_d3_geo2.geoMercator)();
     INSET_STATES = /* @__PURE__ */ new Set(["US-AK", "US-HI"]);
+    inAlaska = (lon, lat) => lat >= 51 && (lon <= -129 || lon >= 172);
+    inHawaii = (lon, lat) => lat >= 18 && lat <= 23 && lon >= -161 && lon <= -154;
+    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"]
+    };
     US_NON_CONUS = /* @__PURE__ */ new Set([
       "US-AK",
       "US-HI",
@@ -47307,6 +48630,58 @@ __export(renderer_exports16, {
   renderMap: () => renderMap,
   renderMapForExport: () => renderMapForExport
 });
+function pointInRing2(px, py, ring) {
+  let inside = false;
+  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;
+}
+function ringToPath(ring) {
+  let d = "";
+  for (let i = 0; i < ring.length; i++)
+    d += (i ? "L" : "M") + ring[i][0] + "," + ring[i][1];
+  return d + "Z";
+}
+function coastlineOuterRings(regions, minExtent) {
+  const paths = [];
+  for (const r of regions) {
+    const rings = parsePathRings(r.d);
+    for (let i = 0; i < rings.length; i++) {
+      const ring = rings[i];
+      if (ring.length < 3) continue;
+      let minX = Infinity;
+      let minY = Infinity;
+      let maxX = -Infinity;
+      let maxY = -Infinity;
+      for (const [x, y] of ring) {
+        if (x < minX) minX = x;
+        if (x > maxX) maxX = x;
+        if (y < minY) minY = y;
+        if (y > maxY) maxY = y;
+      }
+      if (Math.max(maxX - minX, maxY - minY) < minExtent) continue;
+      const [fx, fy] = ring[0];
+      let depth = 0;
+      for (let j = 0; j < rings.length; j++)
+        if (j !== i && pointInRing2(fx, fy, rings[j])) depth++;
+      if (depth % 2 === 1) continue;
+      paths.push(ringToPath(ring));
+    }
+  }
+  return paths;
+}
+function appendWaterLines(g, outerRings, style, flatWater) {
+  const d = outerRings.join(" ");
+  const linesOuterFirst = [...style.lines].sort((a, b) => b.d - a.d);
+  for (const line12 of linesOuterFirst) {
+    g.append("path").attr("d", d).attr("stroke", style.color).attr("stroke-width", 2 * (line12.d + line12.thickness)).attr("stroke-opacity", line12.opacity).attr("stroke-linejoin", "round").attr("stroke-linecap", "round");
+    g.append("path").attr("d", d).attr("stroke", flatWater).attr("stroke-width", 2 * line12.d).attr("stroke-linejoin", "round").attr("stroke-linecap", "round");
+  }
+}
 function renderMap(container, resolved, data, palette, isDark, onClickItem, exportDims, activeGroupOverride) {
   d3Selection18.select(container).selectAll(":not([data-d3-tooltip])").remove();
   const width = exportDims?.width ?? container.clientWidth;
@@ -47319,6 +48694,11 @@ function renderMap(container, resolved, data, palette, isDark, onClickItem, expo
     {
       palette,
       isDark,
+      // Export-only: forward the contain-fit request from mapExportDimensions so a
+      // clamped/floored (off-aspect) export canvas letterboxes instead of
+      // stretch-distorting. The in-app preview pane passes no exportDims → unset →
+      // keeps the global stretch-fill.
+      preferContain: exportDims?.preferContain ?? false,
       ...activeGroupOverride !== void 0 && {
         activeGroup: activeGroupOverride
       }
@@ -47332,6 +48712,7 @@ function renderMap(container, resolved, data, palette, isDark, onClickItem, expo
   const gRegions = svg.append("g").attr("class", "dgmo-map-regions");
   const drawRegion = (g, r, strokeWidth) => {
     const p = g.append("path").attr("d", r.d).attr("fill", r.fill).attr("stroke", r.stroke).attr("stroke-width", strokeWidth);
+    if (r.label) p.attr("data-region-name", r.label);
     if (r.layer !== "base") {
       p.classed("dgmo-map-region", true).attr("data-region", r.id);
       if (r.value !== void 0) p.attr("data-value", r.value);
@@ -47352,6 +48733,52 @@ function renderMap(container, resolved, data, palette, isDark, onClickItem, expo
     }
   };
   for (const r of layout.regions) drawRegion(gRegions, r, 0.5);
+  if (layout.relief.length && layout.reliefHatch) {
+    const h = layout.reliefHatch;
+    const rangeClipId = "dgmo-relief-clip";
+    const landClipId = "dgmo-relief-land";
+    const rangeClip = defs.append("clipPath").attr("id", rangeClipId);
+    for (const s of layout.relief) rangeClip.append("path").attr("d", s.d);
+    const landClip = defs.append("clipPath").attr("id", landClipId);
+    for (const r of layout.regions)
+      if (r.id !== "lake") landClip.append("path").attr("d", r.d);
+    const gRelief = svg.append("g").attr("clip-path", `url(#${landClipId})`).append("g").attr("class", "dgmo-map-relief").attr("clip-path", `url(#${rangeClipId})`).attr("stroke", h.color).attr("stroke-width", h.width).attr("vector-effect", "non-scaling-stroke");
+    for (let y = h.spacing; y < height; y += h.spacing) {
+      gRelief.append("line").attr("x1", 0).attr("y1", y).attr("x2", width).attr("y2", y);
+    }
+  }
+  if (layout.coastlineStyle) {
+    const cs = layout.coastlineStyle;
+    const maskId = "dgmo-map-water-mask";
+    const mask = defs.append("mask").attr("id", maskId).attr("maskUnits", "userSpaceOnUse").attr("x", 0).attr("y", 0).attr("width", width).attr("height", height);
+    mask.append("rect").attr("x", 0).attr("y", 0).attr("width", width).attr("height", height).attr("fill", "white");
+    const landD = layout.regions.filter((r) => r.id !== "lake").map((r) => r.d).join(" ");
+    const lakeD = layout.regions.filter((r) => r.id === "lake").map((r) => r.d).join(" ");
+    if (landD) mask.append("path").attr("d", landD).attr("fill", "black");
+    if (lakeD) mask.append("path").attr("d", lakeD).attr("fill", "white");
+    if (layout.insets.length) {
+      const reach = Math.max(0, ...cs.lines.map((l) => l.d + l.thickness));
+      for (const box of layout.insets) {
+        const d = box.points.map((p, i) => `${i ? "L" : "M"}${p[0]},${p[1]}`).join("") + "Z";
+        mask.append("path").attr("d", d).attr("fill", "black").attr("stroke", "black").attr("stroke-width", 2 * reach).attr("stroke-linejoin", "round");
+      }
+    }
+    const gWater = svg.append("g").attr("class", "dgmo-map-water-lines").attr("fill", "none").attr("mask", `url(#${maskId})`);
+    appendWaterLines(
+      gWater,
+      coastlineOuterRings(layout.regions, cs.minExtent),
+      cs,
+      layout.background
+    );
+    const byStroke = /* @__PURE__ */ new Map();
+    for (const r of layout.regions) {
+      const arr = byStroke.get(r.stroke);
+      if (arr) arr.push(r.d);
+      else byStroke.set(r.stroke, [r.d]);
+    }
+    for (const [stroke2, ds] of byStroke)
+      gWater.append("path").attr("d", ds.join(" ")).attr("stroke", stroke2).attr("stroke-width", 0.5).attr("stroke-linejoin", "round");
+  }
   if (layout.rivers.length) {
     const gRivers = svg.append("g").attr("class", "dgmo-map-rivers").attr("fill", "none");
     for (const r of layout.rivers) {
@@ -47360,15 +48787,61 @@ function renderMap(container, resolved, data, palette, isDark, onClickItem, expo
   }
   if (layout.insets.length) {
     const insetG = svg.append("g").attr("class", "dgmo-map-insets");
-    for (const box of layout.insets) {
+    layout.insets.forEach((box, bi) => {
       const d = box.points.map((p, i) => `${i ? "L" : "M"}${p[0]},${p[1]}`).join("") + "Z";
       insetG.append("path").attr("d", d).attr("fill", layout.background).attr("stroke", mix(palette.text, palette.bg, 55)).attr("stroke-width", 1).attr("stroke-linejoin", "round");
-    }
+      if (box.contextLand) {
+        const clipId = `dgmo-map-inset-clip-${bi}`;
+        defs.append("clipPath").attr("id", clipId).append("path").attr("d", d);
+        insetG.append("path").attr("d", box.contextLand.d).attr("fill", box.contextLand.fill).attr("clip-path", `url(#${clipId})`);
+      }
+    });
     for (const r of layout.insetRegions) drawRegion(insetG, r, 0.5);
-  }
+    if (layout.coastlineStyle) {
+      const cs = layout.coastlineStyle;
+      const maskId = "dgmo-map-inset-water-mask";
+      const mask = defs.append("mask").attr("id", maskId).attr("maskUnits", "userSpaceOnUse").attr("x", 0).attr("y", 0).attr("width", width).attr("height", height);
+      for (const box of layout.insets) {
+        const d = box.points.map((p, i) => `${i ? "L" : "M"}${p[0]},${p[1]}`).join("") + "Z";
+        mask.append("path").attr("d", d).attr("fill", "white");
+      }
+      layout.insets.forEach((box, bi) => {
+        if (box.contextLand)
+          mask.append("path").attr("d", box.contextLand.d).attr("fill", "black").attr("clip-path", `url(#dgmo-map-inset-clip-${bi})`);
+      });
+      for (const r of layout.insetRegions)
+        if (r.id !== "lake")
+          mask.append("path").attr("d", r.d).attr("fill", "black");
+      for (const r of layout.insetRegions)
+        if (r.id === "lake")
+          mask.append("path").attr("d", r.d).attr("fill", "white");
+      const clipId = "dgmo-map-inset-water-clip";
+      const clip = defs.append("clipPath").attr("id", clipId);
+      for (const box of layout.insets) {
+        const d = box.points.map((p, i) => `${i ? "L" : "M"}${p[0]},${p[1]}`).join("") + "Z";
+        clip.append("path").attr("d", d);
+      }
+      const gInsetWater = insetG.append("g").attr("clip-path", `url(#${clipId})`).append("g").attr("class", "dgmo-map-inset-water-lines").attr("fill", "none").attr("mask", `url(#${maskId})`);
+      appendWaterLines(
+        gInsetWater,
+        coastlineOuterRings(layout.insetRegions, cs.minExtent),
+        cs,
+        layout.background
+      );
+      for (const r of layout.insetRegions)
+        gInsetWater.append("path").attr("d", r.d).attr("stroke", r.stroke).attr("stroke-width", 0.5).attr("stroke-linejoin", "round");
+    }
+  }
+  const wireSync = (sel, lineNumber) => {
+    if (lineNumber < 1) return;
+    sel.attr("data-line-number", lineNumber);
+    if (onClickItem)
+      sel.style("cursor", "pointer").on("click", () => onClickItem(lineNumber));
+  };
   const gLegs = svg.append("g").attr("class", "dgmo-map-legs").attr("fill", "none");
   layout.legs.forEach((leg, i) => {
     const p = gLegs.append("path").attr("d", leg.d).attr("stroke", leg.color).attr("stroke-width", leg.width).attr("stroke-linecap", "round");
+    wireSync(p, leg.lineNumber);
     if (leg.arrow) {
       const id = `dgmo-map-arrow-${i}`;
       const s = arrowSize(leg.width);
@@ -47376,25 +48849,38 @@ function renderMap(container, resolved, data, palette, isDark, onClickItem, expo
       p.attr("marker-end", `url(#${id})`);
     }
     if (leg.label !== void 0 && leg.labelX !== void 0) {
-      emitText(
+      const lt = emitText(
         gLegs,
         leg.labelX,
         leg.labelY ?? 0,
         leg.label,
         "middle",
-        palette.textMuted,
-        haloColor,
-        true,
+        leg.labelColor ?? palette.textMuted,
+        leg.labelHaloColor ?? haloColor,
+        leg.labelHalo ?? true,
         LABEL_FONT - 1
       );
+      wireSync(lt, leg.lineNumber);
     }
   });
+  const gSpider = svg.append("g").attr("class", "dgmo-map-spider");
+  for (const cl of layout.clusters) {
+    if (!exportDims) {
+      gSpider.append("circle").attr("cx", cl.cx).attr("cy", cl.cy).attr("r", cl.hitR).attr("fill", "transparent").attr("data-cluster-hit", cl.id).style("cursor", "pointer");
+    }
+    for (const leg of cl.legs) {
+      gSpider.append("line").attr("x1", cl.cx).attr("y1", cl.cy).attr("x2", leg.x2).attr("y2", leg.y2).attr("stroke", leg.color).attr("stroke-width", 1).attr("data-cluster-deco", cl.id).style("pointer-events", "none");
+    }
+    gSpider.append("circle").attr("cx", cl.cx).attr("cy", cl.cy).attr("r", 2).attr("fill", mix(palette.textMuted, palette.bg, 40)).attr("data-cluster-deco", cl.id).style("pointer-events", "none");
+  }
   const gPois = svg.append("g").attr("class", "dgmo-map-pois");
   for (const poi of layout.pois) {
     if (poi.isOrigin) {
       gPois.append("circle").attr("cx", poi.cx).attr("cy", poi.cy).attr("r", poi.r + 3).attr("fill", "none").attr("stroke", poi.stroke).attr("stroke-width", 1.5);
     }
     const c = gPois.append("circle").attr("cx", poi.cx).attr("cy", poi.cy).attr("r", poi.r).attr("fill", poi.fill).attr("stroke", poi.stroke).attr("stroke-width", 1).attr("data-line-number", poi.lineNumber).attr("data-poi", poi.id);
+    if (poi.clusterId !== void 0)
+      c.attr("data-cluster-member", poi.clusterId);
     if (poi.tags) {
       for (const [group, value] of Object.entries(poi.tags)) {
         c.attr(`data-tag-${group.toLowerCase()}`, value.toLowerCase());
@@ -47422,12 +48908,32 @@ function renderMap(container, resolved, data, palette, isDark, onClickItem, expo
   }
   const gLabels = svg.append("g").attr("class", "dgmo-map-labels");
   for (const lab of layout.labels) {
+    if (lab.hidden) {
+      if (exportDims) continue;
+      emitText(
+        gLabels,
+        lab.x,
+        lab.y,
+        lab.text,
+        lab.anchor,
+        lab.color,
+        lab.haloColor,
+        lab.halo,
+        LABEL_FONT,
+        lab.italic,
+        lab.letterSpacing
+      ).attr("data-poi", lab.poiId ?? null).attr("data-poi-hidden", "").style("opacity", 0).style("pointer-events", "none");
+      continue;
+    }
     if (lab.leader) {
       const line12 = gLabels.append("line").attr("x1", lab.leader.x1).attr("y1", lab.leader.y1).attr("x2", lab.leader.x2).attr("y2", lab.leader.y2).attr(
         "stroke",
         lab.leaderColor ?? mix(palette.textMuted, palette.bg, 60)
       ).attr("stroke-width", lab.leaderColor ? 1 : 0.75);
       if (lab.poiId !== void 0) line12.attr("data-poi", lab.poiId);
+      if (lab.clusterMember !== void 0)
+        line12.attr("data-cluster-member", lab.clusterMember);
+      wireSync(line12, lab.lineNumber);
     }
     const t = emitText(
       gLabels,
@@ -47438,11 +48944,38 @@ function renderMap(container, resolved, data, palette, isDark, onClickItem, expo
       lab.color,
       lab.haloColor,
       lab.halo,
-      LABEL_FONT
+      LABEL_FONT,
+      lab.italic,
+      lab.letterSpacing,
+      lab.lines
     );
     if (lab.poiId !== void 0) {
       t.attr("data-poi", lab.poiId).style("cursor", "default");
     }
+    if (lab.clusterMember !== void 0) {
+      t.attr("data-cluster-member", lab.clusterMember);
+    }
+    wireSync(t, lab.lineNumber);
+  }
+  if (!exportDims && layout.clusters.length) {
+    const gBadge = svg.append("g").attr("class", "dgmo-map-cluster-badges");
+    for (const cl of layout.clusters) {
+      const g = gBadge.append("g").attr("data-cluster", cl.id).style("opacity", 0).style("pointer-events", "none");
+      const R = 9;
+      g.append("circle").attr("cx", cl.cx).attr("cy", cl.cy).attr("r", R).attr("fill", mix(palette.textMuted, palette.bg, 35)).attr("stroke", palette.textMuted).attr("stroke-width", 1);
+      g.append("circle").attr("cx", cl.cx).attr("cy", cl.cy).attr("r", R + 2.5).attr("fill", "none").attr("stroke", palette.textMuted).attr("stroke-width", 1);
+      emitText(
+        g,
+        cl.cx,
+        cl.cy + 3,
+        String(cl.count),
+        "middle",
+        palette.text,
+        palette.bg,
+        false,
+        LABEL_FONT
+      );
+    }
   }
   if (layout.legend) {
     const legendY = (layout.title ? TITLE_Y + TITLE_FONT_SIZE : 0) + (layout.subtitle ? TITLE_FONT_SIZE : 0) + 8;
@@ -47476,10 +49009,10 @@ function renderMap(container, resolved, data, palette, isDark, onClickItem, expo
     }
   }
   if (layout.title) {
-    svg.append("text").attr("x", width / 2).attr("y", TITLE_Y).attr("text-anchor", "middle").attr("font-size", TITLE_FONT_SIZE).attr("font-weight", TITLE_FONT_WEIGHT).attr("fill", palette.text).attr("paint-order", "stroke fill").attr("stroke", palette.bg).attr("stroke-width", 4).attr("stroke-linejoin", "round").attr("stroke-opacity", 0.7).text(layout.title);
+    svg.append("text").attr("class", "dgmo-map-title").attr("x", width / 2).attr("y", TITLE_Y).attr("text-anchor", "middle").attr("font-size", TITLE_FONT_SIZE).attr("font-weight", TITLE_FONT_WEIGHT).attr("fill", palette.text).attr("paint-order", "stroke fill").attr("stroke", palette.bg).attr("stroke-width", 4).attr("stroke-linejoin", "round").attr("stroke-opacity", 0.7).text(layout.title);
   }
   if (layout.subtitle) {
-    svg.append("text").attr("x", width / 2).attr("y", TITLE_Y + TITLE_FONT_SIZE).attr("text-anchor", "middle").attr("font-size", LABEL_FONT + 1).attr("fill", palette.textMuted).attr("paint-order", "stroke fill").attr("stroke", palette.bg).attr("stroke-width", 3).attr("stroke-linejoin", "round").attr("stroke-opacity", 0.7).text(layout.subtitle);
+    svg.append("text").attr("class", "dgmo-map-subtitle").attr("x", width / 2).attr("y", TITLE_Y + TITLE_FONT_SIZE).attr("text-anchor", "middle").attr("font-size", LABEL_FONT + 1).attr("fill", palette.textMuted).attr("paint-order", "stroke fill").attr("stroke", palette.bg).attr("stroke-width", 3).attr("stroke-linejoin", "round").attr("stroke-opacity", 0.7).text(layout.subtitle);
   }
   if (layout.caption) {
     svg.append("text").attr("x", width / 2).attr("y", height - 8).attr("text-anchor", "middle").attr("font-size", LABEL_FONT).attr("fill", palette.textMuted).attr("paint-order", "stroke fill").attr("stroke", palette.bg).attr("stroke-width", 3).attr("stroke-linejoin", "round").attr("stroke-opacity", 0.7).text(layout.caption);
@@ -47488,10 +49021,21 @@ function renderMap(container, resolved, data, palette, isDark, onClickItem, expo
 function renderMapForExport(container, resolved, data, palette, isDark, exportDims) {
   renderMap(container, resolved, data, palette, isDark, void 0, exportDims);
 }
-function emitText(g, x, y, text, anchor, color, halo, withHalo, fontSize) {
-  const t = g.append("text").attr("x", x).attr("y", y).attr("text-anchor", anchor).attr("font-size", fontSize).attr("fill", color).text(text);
+function emitText(g, x, y, text, anchor, color, halo, withHalo, fontSize, italic, letterSpacing, lines) {
+  const t = g.append("text").attr("x", x).attr("y", y).attr("text-anchor", anchor).attr("font-size", fontSize).attr("fill", color);
+  if (lines && lines.length > 1) {
+    const lineHeight = fontSize + 2;
+    const startDy = -((lines.length - 1) / 2) * lineHeight;
+    lines.forEach((ln, i) => {
+      t.append("tspan").attr("x", x).attr("dy", i === 0 ? startDy : lineHeight).text(ln);
+    });
+  } else {
+    t.text(text);
+  }
+  if (italic) t.attr("font-style", "italic");
+  if (letterSpacing) t.attr("letter-spacing", letterSpacing);
   if (withHalo) {
-    t.attr("paint-order", "stroke fill").attr("stroke", halo).attr("stroke-width", 3).attr("stroke-linejoin", "round").attr("stroke-opacity", 0.7);
+    t.attr("paint-order", "stroke fill").attr("stroke", halo).attr("stroke-width", 2).attr("stroke-linejoin", "round").attr("stroke-linecap", "round").attr("stroke-opacity", 0.55);
   }
   return t;
 }
@@ -47509,6 +49053,179 @@ var init_renderer16 = __esm({
   }
 });
 
+// src/map/dimensions.ts
+var dimensions_exports = {};
+__export(dimensions_exports, {
+  mapContentAspect: () => mapContentAspect,
+  mapExportDimensions: () => mapExportDimensions
+});
+function mapContentAspect(resolved, data, ref = REF) {
+  const { projection, fitTarget } = buildMapProjection(resolved, data);
+  projection.fitSize([ref, ref], fitTarget);
+  const b = (0, import_d3_geo3.geoPath)(projection).bounds(fitTarget);
+  const w = b[1][0] - b[0][0];
+  const h = b[1][1] - b[0][1];
+  const aspect = w / h;
+  return Number.isFinite(aspect) && aspect > 0 ? aspect : FALLBACK_ASPECT;
+}
+function mapExportDimensions(resolved, data, baseWidth = 1200) {
+  const raw = mapContentAspect(resolved, data);
+  const clamped = Math.max(ASPECT_MIN, Math.min(ASPECT_MAX, raw));
+  const width = baseWidth;
+  let height = Math.round(width / clamped);
+  let chromeReserve = 0;
+  if (resolved.title && resolved.pois.length > 0) {
+    const bannerBottom = (resolved.subtitle ? TITLE_Y + TITLE_FONT_SIZE : TITLE_Y) + TITLE_FONT_SIZE / 2;
+    chromeReserve += Math.max(FIT_PAD2, bannerBottom + TITLE_GAP) - FIT_PAD2;
+  }
+  let floored = false;
+  if (height - chromeReserve < MIN_MAP_BAND) {
+    height = Math.round(chromeReserve + MIN_MAP_BAND);
+    floored = true;
+  }
+  const preferContain = clamped !== raw || floored;
+  return { width, height, preferContain };
+}
+var import_d3_geo3, FIT_PAD2, TITLE_GAP, ASPECT_MAX, ASPECT_MIN, MIN_MAP_BAND, FALLBACK_ASPECT, REF;
+var init_dimensions = __esm({
+  "src/map/dimensions.ts"() {
+    "use strict";
+    import_d3_geo3 = require("d3-geo");
+    init_title_constants();
+    init_layout15();
+    FIT_PAD2 = 24;
+    TITLE_GAP = 16;
+    ASPECT_MAX = 3;
+    ASPECT_MIN = 0.9;
+    MIN_MAP_BAND = 200;
+    FALLBACK_ASPECT = 1.5;
+    REF = 1e3;
+  }
+});
+
+// src/map/load-data.ts
+var load_data_exports = {};
+__export(load_data_exports, {
+  loadMapData: () => loadMapData
+});
+async function loadNodeBuiltins() {
+  const [{ readFile }, { fileURLToPath }, { dirname, resolve }] = await Promise.all([
+    import("fs/promises"),
+    import("url"),
+    import("path")
+  ]);
+  return { readFile, fileURLToPath, dirname, resolve };
+}
+async function readJson(nb, dir, name) {
+  return JSON.parse(await nb.readFile(nb.resolve(dir, name), "utf8"));
+}
+async function firstExistingDir(nb, baseDir) {
+  for (const rel of CANDIDATE_DIRS) {
+    const dir = nb.resolve(baseDir, rel);
+    try {
+      await nb.readFile(nb.resolve(dir, FILES.gazetteer), "utf8");
+      return dir;
+    } catch {
+    }
+  }
+  throw new Error(
+    `map data assets not found near ${baseDir} (looked in ${CANDIDATE_DIRS.join(", ")}). Run \`pnpm build:map-data\` and \`pnpm build\`.`
+  );
+}
+function validate(data) {
+  const topoOk = (t) => !!t && t.type === "Topology" && !!t.objects;
+  if (!topoOk(data.worldCoarse) || !topoOk(data.worldDetail) || !topoOk(data.usStates) || !data.gazetteer || !Array.isArray(data.gazetteer.cities) || !data.gazetteer.byName) {
+    throw new Error("map data assets are malformed (failed shape validation)");
+  }
+  return data;
+}
+function moduleBaseDir(nb) {
+  try {
+    const url = import_meta.url;
+    if (url) return nb.dirname(nb.fileURLToPath(url));
+  } catch {
+  }
+  if (typeof __dirname !== "undefined") return __dirname;
+  return process.cwd();
+}
+function loadMapData() {
+  cache ??= (async () => {
+    const nb = await loadNodeBuiltins();
+    const dir = await firstExistingDir(nb, moduleBaseDir(nb));
+    const [
+      worldCoarse,
+      worldDetail,
+      usStates,
+      lakes,
+      rivers,
+      mountainRanges,
+      naLand,
+      naLakes,
+      waterBodies,
+      gazetteer
+    ] = await Promise.all([
+      // worldCoarse (110m) is LOAD-BEARING but NOT a render source: the world
+      // basemap renders from worldDetail (50m) at all scales (resolver pins
+      // basemaps.world = 'detail'). Coarse stays as the authoritative region
+      // name index + dominant-landmass bbox source in resolver.ts. Do not drop it.
+      readJson(nb, dir, FILES.worldCoarse),
+      readJson(nb, dir, FILES.worldDetail),
+      readJson(nb, dir, FILES.usStates),
+      // Lakes/rivers/mountain/NA/water assets are optional — older bundles may predate them.
+      readJson(nb, dir, FILES.lakes).catch(() => void 0),
+      readJson(nb, dir, FILES.rivers).catch(() => void 0),
+      readJson(nb, dir, FILES.mountainRanges).catch(
+        () => void 0
+      ),
+      readJson(nb, dir, FILES.naLand).catch(() => void 0),
+      readJson(nb, dir, FILES.naLakes).catch(() => void 0),
+      readJson(nb, dir, FILES.waterBodies).catch(() => void 0),
+      readJson(nb, dir, FILES.gazetteer)
+    ]);
+    return validate({
+      worldCoarse,
+      worldDetail,
+      usStates,
+      gazetteer,
+      ...lakes && { lakes },
+      ...rivers && { rivers },
+      ...mountainRanges && { mountainRanges },
+      ...naLand && { naLand },
+      ...naLakes && { naLakes },
+      ...waterBodies && { waterBodies }
+    });
+  })().catch((e) => {
+    cache = void 0;
+    throw e;
+  });
+  return cache;
+}
+var import_meta, FILES, CANDIDATE_DIRS, cache;
+var init_load_data = __esm({
+  "src/map/load-data.ts"() {
+    "use strict";
+    import_meta = {};
+    FILES = {
+      worldCoarse: "world-coarse.json",
+      worldDetail: "world-detail.json",
+      usStates: "us-states.json",
+      lakes: "lakes.json",
+      rivers: "rivers.json",
+      mountainRanges: "mountain-ranges.json",
+      naLand: "na-land.json",
+      naLakes: "na-lakes.json",
+      waterBodies: "water-bodies.json",
+      gazetteer: "gazetteer.json"
+    };
+    CANDIDATE_DIRS = [
+      "./data",
+      "./map-data",
+      "../map-data",
+      "../src/map/data"
+    ];
+  }
+});
+
 // src/pyramid/renderer.ts
 var renderer_exports17 = {};
 __export(renderer_exports17, {
@@ -49510,8 +51227,8 @@ function renderSequenceDiagram(container, parsed, palette, isDark, _onNavigateTo
     const lines = splitParticipantLabel(p.label, LABEL_MAX_CHARS);
     if (lines.length === 0) continue;
     const widest = Math.max(...lines.map((l) => l.length));
-    const labelWidth = widest * LABEL_CHAR_WIDTH + 10;
-    uniformBoxWidth = Math.max(uniformBoxWidth, labelWidth);
+    const labelWidth2 = widest * LABEL_CHAR_WIDTH + 10;
+    uniformBoxWidth = Math.max(uniformBoxWidth, labelWidth2);
   }
   uniformBoxWidth = Math.min(MAX_BOX_WIDTH, uniformBoxWidth);
   const effectiveGap = Math.max(PARTICIPANT_GAP, uniformBoxWidth + 30);
@@ -52206,15 +53923,15 @@ function renderArcDiagram(container, parsed, palette, _isDark, onClickItem, expo
     textColor,
     onClickItem
   );
-  const neighbors = /* @__PURE__ */ new Map();
-  for (const node of nodes) neighbors.set(node, /* @__PURE__ */ new Set());
+  const neighbors2 = /* @__PURE__ */ new Map();
+  for (const node of nodes) neighbors2.set(node, /* @__PURE__ */ new Set());
   for (const link of links) {
-    neighbors.get(link.source).add(link.target);
-    neighbors.get(link.target).add(link.source);
+    neighbors2.get(link.source).add(link.target);
+    neighbors2.get(link.target).add(link.source);
   }
   const FADE_OPACITY3 = 0.1;
   function handleMouseEnter(hovered) {
-    const connected = neighbors.get(hovered);
+    const connected = neighbors2.get(hovered);
     g.selectAll(".arc-link").each(function() {
       const el = d3Selection23.select(this);
       const src = el.attr("data-source");
@@ -54149,7 +55866,7 @@ function renderVenn(container, parsed, palette, _isDark, onClickItem, exportDims
     8,
     Math.floor(OVERLAP_WRAP_TARGET_W / OVERLAP_CH_W)
   );
-  function wrapLabel2(text, maxChars) {
+  function wrapLabel3(text, maxChars) {
     const words = text.split(/\s+/).filter(Boolean);
     const lines = [];
     let cur = "";
@@ -54195,7 +55912,7 @@ function renderVenn(container, parsed, palette, _isDark, onClickItem, exportDims
     if (!ov.label) continue;
     const idxs = ov.sets.map((s) => vennSets.findIndex((vs) => vs.name === s));
     if (idxs.some((idx) => idx < 0)) continue;
-    const lines = wrapLabel2(ov.label, MAX_WRAP_CHARS);
+    const lines = wrapLabel3(ov.label, MAX_WRAP_CHARS);
     wrappedOverlapLabels.set(ov, lines);
     const dir = predictOverlapDirRaw(idxs);
     const longest = lines.reduce((m, l) => Math.max(m, l.length), 0);
@@ -55632,25 +57349,29 @@ async function renderForExport(content, theme, palette, viewState, options) {
   if (detectedType === "map") {
     const { parseMap: parseMap2 } = await Promise.resolve().then(() => (init_parser12(), parser_exports11));
     const { resolveMap: resolveMap2 } = await Promise.resolve().then(() => (init_resolver2(), resolver_exports));
-    const { loadMapData: loadMapData2 } = await Promise.resolve().then(() => (init_load_data(), load_data_exports));
     const { renderMapForExport: renderMapForExport2 } = await Promise.resolve().then(() => (init_renderer16(), renderer_exports16));
+    const { mapExportDimensions: mapExportDimensions2 } = await Promise.resolve().then(() => (init_dimensions(), dimensions_exports));
     const effectivePalette2 = await resolveExportPalette(theme, palette);
     const mapParsed = parseMap2(content);
-    let mapData;
-    try {
-      mapData = await loadMapData2();
-    } catch {
-      return "";
+    let mapData = options?.mapData;
+    if (!mapData) {
+      const { loadMapData: loadMapData2 } = await Promise.resolve().then(() => (init_load_data(), load_data_exports));
+      try {
+        mapData = await loadMapData2();
+      } catch {
+        return "";
+      }
     }
     const mapResolved = resolveMap2(mapParsed, mapData);
-    const container2 = createExportContainer(EXPORT_WIDTH, EXPORT_HEIGHT);
+    const dims2 = mapExportDimensions2(mapResolved, mapData, EXPORT_WIDTH);
+    const container2 = createExportContainer(dims2.width, dims2.height);
     renderMapForExport2(
       container2,
       mapResolved,
       mapData,
       effectivePalette2,
       theme === "dark",
-      { width: EXPORT_WIDTH, height: EXPORT_HEIGHT }
+      dims2
     );
     return finalizeSvgExport(container2, theme, effectivePalette2);
   }
@@ -56514,7 +58235,8 @@ async function render(content, options) {
     ...options?.c4Container !== void 0 && {
       c4Container: options.c4Container
     },
-    ...options?.tagGroup !== void 0 && { tagGroup: options.tagGroup }
+    ...options?.tagGroup !== void 0 && { tagGroup: options.tagGroup },
+    ...options?.mapData !== void 0 && { mapData: options.mapData }
   });
   if (chartType === "map") {
     try {
@@ -56525,7 +58247,7 @@ async function render(content, options) {
           Promise.resolve().then(() => (init_load_data(), load_data_exports))
         ]
       );
-      const data = await loadMapData2();
+      const data = options?.mapData ?? await loadMapData2();
       diagnostics = [...resolveMap2(parseMap2(content), data).diagnostics];
     } catch {
     }