@diagrammo/dgmo 0.21.0 → 0.22.0

package/dist/internal.d.cts

@@ -2,6 +2,7 @@ import { EChartsOption } from 'echarts';
 import * as d3Selection from 'd3-selection';
 import { Selection } from 'd3-selection';
 import * as d3Scale from 'd3-scale';
+import { GeoProjection } from 'd3-geo';
 
 type DgmoSeverity = 'error' | 'warning';
 interface DgmoError {
@@ -78,6 +79,380 @@ interface ParseInArrowLabelResult {
  */
 declare function parseInArrowLabel(rawLabel: string, lineNumber: number): ParseInArrowLabelResult;
 
+/** A single entry inside a tag group: `Value color` */
+interface TagEntry {
+    readonly value: string;
+    readonly color: string;
+    readonly lineNumber: number;
+}
+/**
+ * A tag group block: heading + entries.
+ *
+ * Parser internals build via `Writable<TagGroup>` from `utils/brand.ts`;
+ * once returned to a chart-type parser, consumers see the readonly view.
+ */
+interface TagGroup {
+    readonly name: string;
+    readonly alias?: string;
+    readonly entries: readonly TagEntry[];
+    /** Default value for nodes without explicit metadata. First entry unless another is marked `default`. */
+    readonly defaultValue?: string;
+    readonly lineNumber: number;
+}
+
+/** A POI / route-stop position: gazetteer name (+ optional ISO scope) or coords. */
+type PoiPos = {
+    readonly kind: 'coords';
+    readonly lat: number;
+    readonly lon: number;
+} | {
+    readonly kind: 'name';
+    readonly name: string;
+    readonly scope?: string;
+};
+/** One-shot directives (§24B.2/.7). Values are raw strings unless typed.
+ *
+ *  COSMETIC DEFAULTS ARE ON. Every basemap feature renders by default; the only
+ *  control is a bare `no-*` opt-out flag that sets the matching `noXxx` boolean.
+ *  Absent (undefined) = feature ON — so render gates test `!== true`, never
+ *  `=== true`. There are NO positive opt-in cosmetic flags (§24B.2). */
+interface MapDirectives {
+    /** Legend label for the region value ramp (`region-metric <label>`). */
+    regionMetric?: string;
+    /** Recognized color NAME for the choropleth ramp hue, peeled off the
+     *  `region-metric` trailing token (§24B.3). Defaults to red when absent. */
+    regionMetricColor?: string;
+    /** Legend label for the POI value (marker size) channel (`poi-metric`). */
+    poiMetric?: string;
+    /** Legend label for the edge/leg value (thickness) channel (`flow-metric`). */
+    flowMetric?: string;
+    /** Default ISO scope for bare-name resolution (§24B.8): a 3166-1 country
+     *  (`locale US`) or 3166-2 subdivision (`locale US-GA`). The country part
+     *  biases ambiguous bare cities to that nation; the subdivision part further
+     *  prefers that state. Inferred from content; explicit only to steer a guess. */
+    locale?: string;
+    activeTag?: string;
+    caption?: string;
+    /** `no-legend` — suppress the legend (default-on). */
+    noLegend?: boolean;
+    /** `no-coastline` — suppress the faint nautical-chart water-lines along
+     *  coasts/shorelines (default-on; geometry derived from drawn region paths). */
+    noCoastline?: boolean;
+    /** `no-relief` — suppress mountain-range relief hachures. Relief is default-on
+     *  but auto-gated to dataless reference maps at continent/world zoom (§24B.2). */
+    noRelief?: boolean;
+    /** `no-context-labels` — suppress the orientation backdrop (water-body names +
+     *  unreferenced notable country names), distinct from `region-labels`. */
+    noContextLabels?: boolean;
+    /** `no-region-labels` — suppress region labels (default-on, full→abbrev→hide). */
+    noRegionLabels?: boolean;
+    /** `no-poi-labels` — suppress POI labels (default-on, collision-managed auto). */
+    noPoiLabels?: boolean;
+    /** `no-colorize` — force the plain green-land reference dress even when regions
+     *  are referenced (regions are auto-coloured by default; §24B colorize). A
+     *  no-op under data — the basemap is already gray there. */
+    noColorize?: boolean;
+}
+/** A region-fill: a subdivision name with an optional score and/or tag values
+ *  (§24B.3/.4 — BOTH may be present; bivariate seam). */
+interface MapRegion {
+    readonly name: string;
+    /** Optional trailing ISO scope qualifier (§24B.8) — a 3166-1 country code
+     *  (`Georgia US` → US context) or 3166-2 subdivision (`Georgia US-GA`).
+     *  Forces the country-vs-state interpretation and silences the ambiguity warning. */
+    readonly scope?: string;
+    /** Numeric value → choropleth shade (§24B.3). Lifted out of `meta`. */
+    readonly value?: number;
+    /** §1.5 trailing-token color NAME → flat categorical override fill (§24B.4);
+     *  painted regardless of the active colouring dimension, no legend entry. */
+    readonly color?: string;
+    /** Tag values keyed by lowercased tag GROUP name (alias is resolved away). */
+    readonly tags: Readonly<Record<string, string>>;
+    /** Any remaining reserved keys captured verbatim (`label`/`style`/…). */
+    readonly meta: Readonly<Record<string, string>>;
+    readonly lineNumber: number;
+}
+/** A point of interest (§24B.5). `meta` holds the numeric `value` (→ marker
+ *  size) and `style` verbatim; `label` is lifted out. */
+interface MapPoi {
+    readonly pos: PoiPos;
+    readonly alias?: string;
+    readonly label?: string;
+    /** §1.5 trailing-token color NAME → flat marker fill (§24B.5); wins over a
+     *  tag color and the default orange. */
+    readonly color?: string;
+    readonly tags: Readonly<Record<string, string>>;
+    readonly meta: Readonly<Record<string, string>>;
+    readonly lineNumber: number;
+}
+/** One leg of a route (§24B.6): an edge from the previous stop to `dest`. Reuses
+ *  the edge arrow idiom — in-arrow text = leg label, `value:` = leg thickness,
+ *  `->`/`~>` (or the header `style: arc`) = shape. Stop-targeted keys on the leg
+ *  line (`tag`, `label:`) decorate the DESTINATION point. */
+interface MapRouteLeg {
+    readonly label?: string;
+    readonly style: 'straight' | 'arc';
+    readonly value?: string;
+    readonly dest: PoiPos;
+    readonly destAlias?: string;
+    readonly destLabel?: string;
+    readonly destTags: Readonly<Record<string, string>>;
+    readonly lineNumber: number;
+}
+/** An ordered, auto-numbered route (§24B.6): `route <origin> [style: arc]` + a
+ *  sequence of indented arrow legs, each continuing from the previous stop.
+ *  Repeat the origin as a leg's destination to close a loop. */
+interface MapRoute {
+    readonly origin: PoiPos;
+    readonly originAlias?: string;
+    readonly originLabel?: string;
+    readonly originValue?: string;
+    readonly originTags: Readonly<Record<string, string>>;
+    readonly style: 'straight' | 'arc';
+    readonly legs: readonly MapRouteLeg[];
+    readonly lineNumber: number;
+}
+/** A connector (§24B.6). Endpoints are RAW identifier strings (name or alias);
+ *  binding to POIs/regions is the resolver's job. `~>`→arc; `--`→directed:false. */
+interface MapEdge {
+    readonly from: string;
+    readonly to: string;
+    readonly label?: string;
+    readonly directed: boolean;
+    readonly style: 'straight' | 'arc';
+    readonly meta: Readonly<Record<string, string>>;
+    readonly lineNumber: number;
+}
+interface ParsedMap {
+    readonly title: string | null;
+    readonly titleLineNumber: number | null;
+    readonly directives: MapDirectives;
+    readonly tagGroups: readonly TagGroup[];
+    readonly regions: readonly MapRegion[];
+    readonly pois: readonly MapPoi[];
+    readonly routes: readonly MapRoute[];
+    readonly edges: readonly MapEdge[];
+    readonly options: Readonly<Record<string, string>>;
+    readonly diagnostics: readonly DgmoError[];
+    readonly error: string | null;
+}
+
+/** A TopoJSON topology (world-coarse/world-detail keyed by ISO 3166-1 alpha-2;
+ *  us-states keyed by ISO 3166-2). Geometry feature `id` is the ISO code;
+ *  `properties.name` is the display string. Kept loose to avoid a topojson dep. */
+interface BoundaryTopology {
+    type: 'Topology';
+    objects: Record<string, {
+        type: string;
+        geometries: BoundaryGeometry[];
+    }>;
+    arcs: number[][][];
+    transform?: {
+        scale: [number, number];
+        translate: [number, number];
+    };
+    bbox?: number[];
+}
+interface BoundaryGeometry {
+    type: string;
+    /** ISO code: alpha-2 (countries) or 3166-2 `US-XX` (states). */
+    id: string;
+    properties: {
+        name: string;
+    };
+    arcs?: unknown;
+}
+/**
+ * A gazetteer city entry: `[lat, lon, iso, pop, name, sub?]`.
+ * - `lat`/`lon` — rounded to 3 decimals.
+ * - `iso` — ISO 3166-1 alpha-2 country code.
+ * - `pop` — population.
+ * - `name` — canonical display name (case/accents preserved).
+ * - `sub` — ISO 3166-2 subdivision (US cities only in v1, e.g. `US-OR`); absent otherwise.
+ */
+type GazetteerEntry = [
+    lat: number,
+    lon: number,
+    iso: string,
+    pop: number,
+    name: string,
+    sub?: string
+];
+interface Gazetteer {
+    /** Every city, stored once. `byName`/`alt` reference cities by array index
+     *  (normalized — no tuple duplication; geonameid is a build-time-only linker). */
+    cities: GazetteerEntry[];
+    /** Folded (NFD, diacritic-stripped, lowercased) name → indices into `cities`.
+     *  Always an array; length > 1 for same-named cities (Portland US-OR / US-ME). */
+    byName: Record<string, number[]>;
+    /** Folded alias → index into `cities`. Never collides with a `byName` key. */
+    alt: Record<string, number>;
+}
+/** Water-feature class (Natural Earth `featurecla`, rivers/reefs excluded). */
+type WaterKind = 'ocean' | 'sea' | 'gulf' | 'bay' | 'strait' | 'channel' | 'sound';
+/**
+ * A water-body label entry: `[lat, lon, name, tier, kind, alt?]`.
+ * - `lat`/`lon` — label anchor (Natural Earth inner point), rounded to 3 decimals.
+ * - `name` — full display name (no abbreviation exists for water bodies).
+ * - `tier` — Natural Earth `scalerank` (0 = most prominent → orientation priority).
+ * - `kind` — feature class (drives styling/priority bucketing).
+ * - `alt` — optional extra anchor points `[lat, lon][]`; the layout picks the
+ *   one nearest the viewport center (Decision 5 multi-anchor seam). Absent today.
+ */
+type WaterBodyEntry = [
+    lat: number,
+    lon: number,
+    name: string,
+    tier: number,
+    kind: WaterKind,
+    alt?: ReadonlyArray<readonly [number, number]>
+];
+interface WaterBodies {
+    /** Deterministically ordered (tier, then name). Generated from Natural Earth
+     *  marine polys by scripts/build-map-data.mjs into `water-bodies.json`. */
+    readonly entries: readonly WaterBodyEntry[];
+}
+/** A fill-able region (country or US state) — the display name + its ISO id +
+ *  layer. Powers region-name autocomplete (completion-only; the renderer derives
+ *  names from the topology directly). Extracted from the topologies by
+ *  scripts/build-map-data.mjs into `region-names.json`. */
+interface RegionName {
+    /** Display name (original casing), e.g. `California` / `Germany`. */
+    readonly name: string;
+    /** ISO 3166-1 alpha-2 (country) or 3166-2 `US-XX` (state). */
+    readonly iso: string;
+    readonly layer: 'country' | 'us-state';
+}
+interface RegionNames {
+    /** Deterministically ordered (layer, then name). */
+    readonly regions: readonly RegionName[];
+}
+
+/** The four static assets, injected into the pure resolver (DI). */
+interface MapData {
+    worldCoarse: BoundaryTopology;
+    worldDetail: BoundaryTopology;
+    usStates: BoundaryTopology;
+    /** Major lakes (Natural Earth 110m) drawn as water over land — e.g. the Great
+     *  Lakes. Optional so hand-built test fixtures need not supply it. */
+    lakes?: BoundaryTopology;
+    /** Major river centerlines (Natural Earth 110m) drawn as thin water lines over
+     *  land — e.g. the Amazon, Nile, Mississippi. Optional, like `lakes`. */
+    rivers?: BoundaryTopology;
+    /** Notable mountain-range polygons (Natural Earth 50m geography regions) drawn
+     *  as a subtle gradient relief cue over base land when the `relief` directive
+     *  is on — e.g. the Rockies, Andes, Himalayas. Optional, like `lakes`. */
+    mountainRanges?: BoundaryTopology;
+    /** North-America-clipped 10m country land, used as crisp neighbour context
+     *  under the albers-usa US view so Canada/Mexico match the 10m states instead
+     *  of the coarser world tiers. Optional, like `lakes`. */
+    naLand?: BoundaryTopology;
+    /** North-America-clipped 10m major lakes (Great Lakes etc.), used in place of
+     *  the coarse `lakes` under the albers-usa US view. Optional. */
+    naLakes?: BoundaryTopology;
+    /** Water-body orientation labels (Natural Earth marine polys) drawn when the
+     *  `context-labels` directive is on — oceans/seas/gulfs/bays/etc. Optional, so
+     *  hand-built test fixtures and older bundles need not supply it. */
+    waterBodies?: WaterBodies;
+    gazetteer: Gazetteer;
+}
+type ProjectionFamily = 'equal-earth' | 'natural-earth' | 'equirectangular' | 'albers-usa' | 'mercator';
+/** Which geometry layers the renderer draws. */
+interface Basemaps {
+    /** World country tier: coarse (world-scale) | detail (regional/zoom). */
+    world: 'coarse' | 'detail';
+    /** Loaded subdivision layers (v1: only 'us-states'). */
+    subdivisions: Array<'us-states'>;
+}
+interface ResolvedRegion {
+    /** ISO code: alpha-2 (country) or 3166-2 `US-XX` (state) — the geometry id. */
+    readonly iso: string;
+    readonly name: string;
+    readonly layer: 'country' | 'us-state';
+    readonly value?: number;
+    /** §1.5 trailing-token color NAME → flat override fill (§24B.4). */
+    readonly color?: string;
+    readonly tags: Readonly<Record<string, string>>;
+    readonly meta: Readonly<Record<string, string>>;
+    readonly lineNumber: number;
+}
+interface ResolvedPoi {
+    /** Folded registry id (alias|name folded, or `@lat,lon` for coord POIs). */
+    readonly id: string;
+    /** Display name (original casing): the city/place name, alias, or endpoint
+     *  string. The on-map label falls back to this when `label` is absent (the
+     *  folded `id` is for binding, not display). */
+    readonly name?: string;
+    readonly lat: number;
+    readonly lon: number;
+    readonly label?: string;
+    /** §1.5 trailing-token color NAME → flat marker fill (§24B.5). */
+    readonly color?: string;
+    readonly tags: Readonly<Record<string, string>>;
+    readonly meta: Readonly<Record<string, string>>;
+    readonly lineNumber: number;
+    /** True when created from an undeclared edge/route endpoint (§24B.10). */
+    readonly implicit?: boolean;
+}
+interface ResolvedEdge {
+    readonly fromId: string;
+    readonly toId: string;
+    readonly label?: string;
+    readonly directed: boolean;
+    readonly style: 'straight' | 'arc';
+    readonly meta: Readonly<Record<string, string>>;
+    readonly lineNumber: number;
+}
+interface ResolvedRouteLeg {
+    readonly fromId: string;
+    readonly toId: string;
+    readonly label?: string;
+    readonly style: 'straight' | 'arc';
+    readonly value?: string;
+    readonly lineNumber: number;
+}
+interface ResolvedRoute {
+    /** Ordered UNIQUE stop ids (for numbering + the origin marker). A loop-closing
+     *  leg whose destination is an earlier stop adds a leg but no duplicate stop. */
+    readonly stopIds: readonly string[];
+    readonly legs: readonly ResolvedRouteLeg[];
+    readonly lineNumber: number;
+}
+/** Geographic bounding box `[[west, south], [east, north]]` in degrees.
+ *
+ *  WRAP CONVENTION (#12): for an antimeridian-crossing extent the resolver keeps
+ *  `west` in [−180, 180] and returns `east` UNWRAPPED in (180, 540] (i.e.
+ *  `east = west + span`, span ≤ 360). So `east > 180` signals a dateline-crossing
+ *  extent; the renderer (step 4) must mod `east` back into [−180, 180] (or shift
+ *  the projection's center) rather than assume `east ≤ 180`. `south`/`north` are
+ *  always plain degrees in [−90, 90]. */
+type GeoExtent = [[number, number], [number, number]];
+interface ResolvedMap {
+    readonly title: string | null;
+    /** DEAD — the `subtitle` directive was removed (2026-06-02 defaults-on review).
+     *  Never populated; the renderer's subtitle branch is now unreachable. Left for
+     *  a later cleanup pass. */
+    readonly subtitle?: string;
+    readonly caption?: string;
+    readonly tagGroups: readonly TagGroup[];
+    readonly directives: MapDirectives;
+    readonly basemaps: Basemaps;
+    readonly regions: readonly ResolvedRegion[];
+    readonly pois: readonly ResolvedPoi[];
+    readonly edges: readonly ResolvedEdge[];
+    readonly routes: readonly ResolvedRoute[];
+    readonly extent: GeoExtent;
+    readonly projection: ProjectionFamily;
+    /** POI-only region framing: the region(s) that CONTAIN the POIs — us-state ids
+     *  (`US-CA`) or country isos (`FR`). The frame is snapped to the union of their
+     *  bboxes, and the layout labels them prominently (vs. muted neighbours). Empty
+     *  for non-POI-only maps or when POIs fall outside every polygon. Optional so
+     *  older/foreign ResolvedMap literals need not supply it. */
+    readonly poiFrameContainers?: readonly string[];
+    readonly diagnostics: readonly DgmoError[];
+    readonly error: string | null;
+}
+
 /**
  * Compact view state schema (ADR-6).
  * All fields optional. Only non-default values are encoded.
@@ -192,6 +567,9 @@ declare function render(content: string, options?: {
     };
     /** View state for export — controls interactive state (collapse, swimlanes, etc.) */
     viewState?: CompactViewState;
+    /** Bundled map data for `map` charts in the browser, where the Node fs
+     *  `loadMapData()` seam can't run. CLI/SSR omit this and fall back to fs. */
+    mapData?: MapData;
 }): Promise<{
     svg: string;
     diagnostics: DgmoError[];
@@ -496,7 +874,9 @@ declare function shapeFill(palette: PaletteColors, intent: string, isDark: boole
 /** Derive the 8-color series rotation from a palette's named colors. */
 declare function getSeriesColors(palette: PaletteColors): string[];
 
-declare const boldPalette: PaletteConfig;
+declare const atlasPalette: PaletteConfig;
+
+declare const blueprintPalette: PaletteConfig;
 
 declare const catppuccinPalette: PaletteConfig;
 
@@ -508,8 +888,12 @@ declare const oneDarkPalette: PaletteConfig;
 
 declare const rosePinePalette: PaletteConfig;
 
+declare const slatePalette: PaletteConfig;
+
 declare const solarizedPalette: PaletteConfig;
 
+declare const tidewaterPalette: PaletteConfig;
+
 declare const tokyoNightPalette: PaletteConfig;
 
 declare const draculaPalette: PaletteConfig;
@@ -526,6 +910,10 @@ declare const monokaiPalette: PaletteConfig;
  * used by share URLs and the CLI `--palette` flag.
  */
 declare const palettes: {
+    readonly atlas: PaletteConfig;
+    readonly blueprint: PaletteConfig;
+    readonly slate: PaletteConfig;
+    readonly tidewater: PaletteConfig;
     readonly nord: PaletteConfig;
     readonly catppuccin: PaletteConfig;
     readonly solarized: PaletteConfig;
@@ -535,7 +923,6 @@ declare const palettes: {
     readonly rosePine: PaletteConfig;
     readonly dracula: PaletteConfig;
     readonly monokai: PaletteConfig;
-    readonly bold: PaletteConfig;
 };
 
 type ChartType$1 = 'bar' | 'line' | 'pie' | 'doughnut' | 'area' | 'polar-area' | 'radar' | 'bar-stacked';
@@ -704,6 +1091,13 @@ interface LegendConfig {
      *  group). Lets the user click a sibling to switch the active group. Default
      *  false (legacy: when one group is active the others are hidden). */
     showInactivePills?: boolean;
+    /** Where the controlsGroup is hosted. Default (undefined / 'inline') renders
+     *  the in-SVG gear exactly as before — every non-app consumer (Obsidian,
+     *  site, remark-family, CLI) is unaffected. When 'app', the controlsGroup is
+     *  dropped entirely (no gear, no reserved row): the app overlay strip owns the
+     *  controls, pinned to the top edge of the preview. App preview only; never
+     *  set on the export path. */
+    controlsHost?: 'app' | 'inline';
 }
 interface LegendPalette {
     bg: string;
@@ -983,6 +1377,11 @@ declare function renderExtendedChartForExport(content: string, theme: 'light' |
 interface D3ExportDimensions {
     width?: number;
     height?: number;
+    /** Map-only: when true, the map renderer suppresses its global stretch-fill and
+     *  contain-fits (letterbox) instead. Set by `mapExportDimensions` when the export
+     *  canvas was clamped/floored away from the map's content aspect, so the
+     *  off-aspect canvas doesn't re-distort. Ignored by all non-map renderers. */
+    preferContain?: boolean;
 }
 
 type TimelineSort = 'time' | 'group' | 'tag';
@@ -1019,27 +1418,6 @@ type TimelineDurationUnit = 'd' | 'w' | 'm' | 'y' | 'h' | 'min';
 declare function addDurationToDate(startDate: string, amount: number, unit: TimelineDurationUnit): string;
 declare function parseTimelineDate(s: string): number;
 
-/** A single entry inside a tag group: `Value color` */
-interface TagEntry {
-    readonly value: string;
-    readonly color: string;
-    readonly lineNumber: number;
-}
-/**
- * A tag group block: heading + entries.
- *
- * Parser internals build via `Writable<TagGroup>` from `utils/brand.ts`;
- * once returned to a chart-type parser, consumers see the readonly view.
- */
-interface TagGroup {
-    readonly name: string;
-    readonly alias?: string;
-    readonly entries: readonly TagEntry[];
-    /** Default value for nodes without explicit metadata. First entry unless another is marked `default`. */
-    readonly defaultValue?: string;
-    readonly lineNumber: number;
-}
-
 type VisualizationType = 'slope' | 'wordcloud' | 'arc' | 'timeline' | 'venn' | 'quadrant' | 'sequence' | 'tech-radar' | 'cycle' | 'pyramid' | 'ring';
 interface D3DataItem {
     label: string;
@@ -1189,6 +1567,7 @@ declare function renderForExport(content: string, theme: 'light' | 'dark' | 'tra
     c4Container?: string;
     tagGroup?: string;
     exportMode?: boolean;
+    mapData?: MapData;
 }): Promise<string>;
 
 /**
@@ -2217,6 +2596,9 @@ interface BLRenderOptions {
     onToggleDescriptions?: (active: boolean) => void;
     onToggleControlsExpand?: () => void;
     exportMode?: boolean;
+    /** When 'app', the description toggle is hosted by the app overlay strip
+     *  (inline gear suppressed, controls row + anchor reserved). */
+    controlsHost?: 'app' | 'inline';
 }
 declare function renderBoxesAndLines(container: HTMLDivElement, parsed: ParsedBoxesAndLines, layout: BLLayoutResult, palette: PaletteColors, isDark: boolean, options?: BLRenderOptions): void;
 declare function renderBoxesAndLinesForExport(container: HTMLDivElement, parsed: ParsedBoxesAndLines, layout: BLLayoutResult, palette: PaletteColors, isDark: boolean, options?: {
@@ -2644,7 +3026,10 @@ interface InfraPlaybackState {
     speed: number;
     speedOptions: readonly number[];
 }
-declare function renderInfra(container: HTMLDivElement, layout: InfraLayoutResult, palette: PaletteColors, isDark: boolean, title: string | null, titleLineNumber: number | null, tagGroups?: readonly InfraTagGroup[], activeGroup?: string | null, animate?: boolean, playback?: InfraPlaybackState | null, expandedNodeIds?: Set<string> | null, exportMode?: boolean, collapsedNodes?: Set<string> | null): void;
+declare function renderInfra(container: HTMLDivElement, layout: InfraLayoutResult, palette: PaletteColors, isDark: boolean, title: string | null, titleLineNumber: number | null, tagGroups?: readonly InfraTagGroup[], activeGroup?: string | null, animate?: boolean, playback?: InfraPlaybackState | null, expandedNodeIds?: Set<string> | null, exportMode?: boolean, collapsedNodes?: Set<string> | null, 
+/** When 'app', the playback pill is suppressed and a controls row + anchor are
+ *  reserved for the app overlay strip (play/pause + speed live there). */
+controlsHost?: 'app' | 'inline'): void;
 declare function parseAndLayoutInfra(content: string): {
     parsed: ParsedInfra;
     computed: null;
@@ -3697,6 +4082,9 @@ declare function renderMindmap(container: HTMLDivElement, parsed: ParsedMindmap,
     controlsExpanded?: boolean;
     onToggleControlsExpand?: () => void;
     exportMode?: boolean;
+    /** When 'app', controls (Descriptions / Depth Colors) are hosted by the app
+     *  overlay strip — inline gear suppressed, controls row + anchor reserved. */
+    controlsHost?: 'app' | 'inline';
 }): void;
 declare function renderMindmapForExport(content: string, theme: 'light' | 'dark' | 'transparent', palette: PaletteColors): string;
 
@@ -3886,6 +4274,9 @@ interface TechRadarRenderOptions {
     activeLine?: number | null;
     /** True when rendering for export (PNG/SVG/PDF) — controls whether collapsed legend pills and cog are stripped. */
     exportMode?: boolean;
+    /** When 'app', the Blip Legend toggle is hosted by the app overlay strip
+     *  (inline gear suppressed, controls row + anchor reserved). */
+    controlsHost?: 'app' | 'inline';
 }
 
 declare function parseTechRadar(content: string): ParsedTechRadar;
@@ -4002,547 +4393,260 @@ interface CycleLayoutResult {
 
 /**
  * Parse a `.dgmo` cycle diagram document.
- *
- * Syntax (§1.4 unified metadata grammar):
- * ```
- * cycle Title
- *
- * direction-counterclockwise
- *
- * NodeLabel color: blue, span: 3
- *   Description line (indented under node)
- *   -Label-> color: red, width: 6
- *     Edge description (indented under edge)
- * ```
- */
-declare function parseCycle(content: string): ParsedCycle;
-
-/**
- * Compute cycle diagram layout: positions nodes equidistant (or span-weighted)
- * on a circle, and generates curved edge paths between consecutive nodes.
- */
-declare function computeCycleLayout(parsed: ParsedCycle, options?: {
-    width?: number;
-    height?: number;
-    hideDescriptions?: boolean;
-}): CycleLayoutResult;
-
-interface CycleRenderOptions {
-    onClickItem?: (lineNumber: number) => void;
-    exportDims?: D3ExportDimensions;
-    viewState?: CompactViewState;
-    hideDescriptions?: boolean;
-    controlsExpanded?: boolean;
-    onToggleDescriptions?: (active: boolean) => void;
-    onToggleControlsExpand?: () => void;
-    exportMode?: boolean;
-}
-/**
- * Render a cycle diagram into the given container.
- */
-declare function renderCycle(container: HTMLDivElement, parsed: ParsedCycle, palette: PaletteColors, isDark: boolean, onClickItem?: (lineNumber: number) => void, exportDims?: D3ExportDimensions, viewState?: CompactViewState, renderOptions?: CycleRenderOptions): void;
-/**
- * Render for CLI/export (no click handlers).
- */
-declare function renderCycleForExport(container: HTMLDivElement, parsed: ParsedCycle, palette: PaletteColors, isDark: boolean, exportDims?: D3ExportDimensions, viewState?: CompactViewState, exportMode?: boolean): void;
-
-interface JourneyMapAnnotation {
-    readonly type: 'pain' | 'opportunity' | 'thought';
-    readonly text: string;
-}
-interface JourneyMapStep {
-    readonly id: string;
-    readonly title: string;
-    readonly score?: number;
-    readonly emotionLabel?: string;
-    readonly tags: Readonly<Record<string, string>>;
-    readonly annotations: readonly JourneyMapAnnotation[];
-    readonly description?: string;
-    readonly lineNumber: number;
-    readonly endLineNumber: number;
-}
-interface JourneyMapPhase {
-    readonly id: string;
-    readonly name: string;
-    readonly steps: readonly JourneyMapStep[];
-    readonly lineNumber: number;
-}
-interface JourneyMapPersona {
-    readonly name: string;
-    readonly description?: string;
-    readonly color?: string;
-    readonly lineNumber: number;
-}
-interface ParsedJourneyMap {
-    readonly type: 'journey-map';
-    readonly title?: string;
-    readonly titleLineNumber?: number;
-    readonly persona?: JourneyMapPersona;
-    readonly phases: readonly JourneyMapPhase[];
-    /** Flat-mode steps (not inside any phase) */
-    readonly steps: readonly JourneyMapStep[];
-    readonly tagGroups: readonly TagGroup[];
-    readonly options: Readonly<Record<string, string>>;
-    readonly diagnostics: readonly DgmoError[];
-    readonly error: string | null;
-}
-
-declare function parseJourneyMap(content: string, palette?: PaletteColors): ParsedJourneyMap;
-
-interface CurvePoint {
-    x: number;
-    y: number;
-    score: number;
-    emotionLabel?: string;
-    stepIndex: number;
-}
-interface StepLayout {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-    step: JourneyMapStep;
-    color: string;
-}
-interface PhaseLayout {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-    phase: JourneyMapPhase;
-    headerColor: string;
-    stepLayouts: StepLayout[];
-}
-interface JourneyMapLayout {
-    phases: PhaseLayout[];
-    flatStepLayouts: StepLayout[];
-    curvePoints: CurvePoint[];
-    totalWidth: number;
-    totalHeight: number;
-    curveAreaTop: number;
-    curveAreaBottom: number;
-    cardAreaTop: number;
-    personaHeight: number;
-    titleHeight: number;
-    /** Whether any step has thought annotations */
-    hasThoughts: boolean;
-}
-declare function layoutJourneyMap(parsed: ParsedJourneyMap, palette: PaletteColors, options?: {
-    exportDims?: {
-        width: number;
-        height: number;
-    };
-    collapsedPhases?: Set<string>;
-    isDark?: boolean;
-}): JourneyMapLayout;
-
-interface JourneyMapInteractiveOptions {
-    onNavigateToLine?: (line: number) => void;
-    exportDims?: {
-        width: number;
-        height: number;
-    };
-    activeTagGroup?: string | null;
-    onActiveTagGroupChange?: (group: string | null) => void;
-    /** Current editor cursor line — highlights the matching face + card, dims the rest */
-    currentLine?: number | null;
-    /** Set of collapsed phase names */
-    collapsedPhases?: Set<string>;
-    /** Called when a phase is toggled */
-    onPhaseToggle?: (phaseName: string) => void;
-    exportMode?: boolean;
-}
-declare function renderJourneyMap(container: HTMLElement, parsed: ParsedJourneyMap, palette: PaletteColors, isDark: boolean, options?: JourneyMapInteractiveOptions): void;
-declare function renderJourneyMapForExport(content: string, theme: 'light' | 'dark' | 'transparent', palette: PaletteColors): string;
-
-interface PyramidLayer {
-    readonly label: string;
-    readonly lineNumber: number;
-    /** Optional palette color name (red/green/blue/…). */
-    readonly color?: string;
-    /** Description lines — from bare pipe shorthand or indented body. */
-    readonly description: readonly string[];
-    /** Unconsumed pipe metadata (reserved for future use). */
-    readonly metadata: Readonly<Record<string, string>>;
-}
-interface ParsedPyramid {
-    readonly type: 'pyramid';
-    readonly title: string;
-    readonly titleLineNumber: number;
-    readonly layers: readonly PyramidLayer[];
-    /** When true, apex points down instead of up. */
-    readonly inverted: boolean;
-    readonly options: Readonly<Record<string, string>>;
-    readonly diagnostics: readonly DgmoError[];
-    readonly error: string | null;
-}
-
-/**
- * Parse a `.dgmo` pyramid diagram document.
- *
- * Top of file = apex of pyramid (reads top-down).
- *
- * Syntax:
- * ```
- * pyramid Maslow's Hierarchy of Needs
- *
- * inverted                               // optional — flips apex to bottom
- *
- * Self-Actualization                     // indented body = description
- *   Achieving one's full potential.
- *
- * Esteem | Respect, recognition          // bare pipe shorthand = description
- *
- * Love & Belonging | color: blue         // structured metadata
- *   Friendship, intimacy, family.
- *
- * Physiological | Food, water, rest
- * ```
- */
-declare function parsePyramid(content: string): ParsedPyramid;
-
-/**
- * Render a pyramid diagram into the given container.
- */
-declare function renderPyramid(container: HTMLDivElement, parsed: ParsedPyramid, palette: PaletteColors, isDark: boolean, onClickItem?: (lineNumber: number) => void, exportDims?: D3ExportDimensions): void;
-/**
- * Render for CLI/export (no click handlers).
- */
-declare function renderPyramidForExport(container: HTMLDivElement, parsed: ParsedPyramid, palette: PaletteColors, isDark: boolean, exportDims?: D3ExportDimensions): void;
-
-interface RingLayer {
-    readonly label: string;
-    readonly lineNumber: number;
-    /** Optional palette color name (red/green/blue/…). */
-    readonly color?: string;
-    /** Description lines — from bare pipe shorthand or indented body. */
-    readonly description: readonly string[];
-    /** Unconsumed pipe metadata (reserved for future use). */
-    readonly metadata: Readonly<Record<string, string>>;
-}
-interface ParsedRing {
-    readonly type: 'ring';
-    readonly title: string;
-    readonly titleLineNumber: number;
-    /** Source order: layers[0] = innermost (filled disc); last = outermost ring. */
-    readonly layers: readonly RingLayer[];
-    readonly options: Readonly<Record<string, string>>;
-    readonly diagnostics: readonly DgmoError[];
-    readonly error: string | null;
-}
+ *
+ * Syntax (§1.4 unified metadata grammar):
+ * ```
+ * cycle Title
+ *
+ * direction-counterclockwise
+ *
+ * NodeLabel color: blue, span: 3
+ *   Description line (indented under node)
+ *   -Label-> color: red, width: 6
+ *     Edge description (indented under edge)
+ * ```
+ */
+declare function parseCycle(content: string): ParsedCycle;
 
 /**
- * Parse a `.dgmo` ring diagram document.
- *
- * Top of file = innermost ring (rendered as a filled disc).
- * Last layer in source = outermost ring.
+ * Compute cycle diagram layout: positions nodes equidistant (or span-weighted)
+ * on a circle, and generates curved edge paths between consecutive nodes.
  */
-declare function parseRing(content: string): ParsedRing;
+declare function computeCycleLayout(parsed: ParsedCycle, options?: {
+    width?: number;
+    height?: number;
+    hideDescriptions?: boolean;
+}): CycleLayoutResult;
 
+interface CycleRenderOptions {
+    onClickItem?: (lineNumber: number) => void;
+    exportDims?: D3ExportDimensions;
+    viewState?: CompactViewState;
+    hideDescriptions?: boolean;
+    controlsExpanded?: boolean;
+    onToggleDescriptions?: (active: boolean) => void;
+    onToggleControlsExpand?: () => void;
+    exportMode?: boolean;
+    /** When 'app', the description toggle is hosted by the app overlay strip:
+     *  the inline gear is suppressed and a controls row + anchor are reserved.
+     *  Default (inline) renders the gear as before. */
+    controlsHost?: 'app' | 'inline';
+}
 /**
- * Render a ring diagram into the given container.
+ * Render a cycle diagram into the given container.
  */
-declare function renderRing(container: HTMLDivElement, parsed: ParsedRing, palette: PaletteColors, isDark: boolean, onClickItem?: (lineNumber: number) => void, exportDims?: D3ExportDimensions): void;
+declare function renderCycle(container: HTMLDivElement, parsed: ParsedCycle, palette: PaletteColors, isDark: boolean, onClickItem?: (lineNumber: number) => void, exportDims?: D3ExportDimensions, viewState?: CompactViewState, renderOptions?: CycleRenderOptions): void;
 /**
  * Render for CLI/export (no click handlers).
  */
-declare function renderRingForExport(container: HTMLDivElement, parsed: ParsedRing, palette: PaletteColors, isDark: boolean, exportDims?: D3ExportDimensions): void;
+declare function renderCycleForExport(container: HTMLDivElement, parsed: ParsedCycle, palette: PaletteColors, isDark: boolean, exportDims?: D3ExportDimensions, viewState?: CompactViewState, exportMode?: boolean): void;
 
-/** A POI / route-stop position: gazetteer name (+ optional ISO scope) or coords. */
-type PoiPos = {
-    readonly kind: 'coords';
-    readonly lat: number;
-    readonly lon: number;
-} | {
-    readonly kind: 'name';
-    readonly name: string;
-    readonly scope?: string;
-};
-/** `scale <min> <max> [center <n>]` (center reserved for the diverging seam, §24B.12). */
-interface MapScale {
-    readonly min: number;
-    readonly max: number;
-    readonly center?: number;
-}
-/** One-shot directives (§24B.2/.7). Values are raw strings unless typed. */
-interface MapDirectives {
-    region?: string;
-    projection?: string;
-    /** Legend label for the region value ramp (`region-metric <label>`). */
-    regionMetric?: string;
-    /** Legend label for the POI value (marker size) channel (`poi-metric`). */
-    poiMetric?: string;
-    /** Legend label for the edge/leg value (thickness) channel (`flow-metric`). */
-    flowMetric?: string;
-    scale?: MapScale;
-    regionLabels?: string;
-    poiLabels?: string;
-    defaultCountry?: string;
-    defaultState?: string;
-    activeTag?: string;
-    noLegend?: boolean;
-    subtitle?: string;
-    caption?: string;
-    /** Basemap dress override (bare flags `muted` / `natural`). Forces the
-     *  land/water styling regardless of whether a colouring dimension is active —
-     *  `muted` recedes to neutral grays, `natural` keeps the green/blue reference
-     *  dress. Absent → auto (muted iff a score/tag dimension is active). Lets two
-     *  maps in one deck share a look. */
-    basemapStyle?: 'muted' | 'natural';
-}
-/** A region-fill: a subdivision name with an optional score and/or tag values
- *  (§24B.3/.4 — BOTH may be present; bivariate seam). */
-interface MapRegion {
-    readonly name: string;
-    /** Optional trailing ISO scope qualifier (§24B.8) — a 3166-1 country code
-     *  (`Georgia US` → US context) or 3166-2 subdivision (`Georgia US-GA`).
-     *  Forces the country-vs-state interpretation and silences the ambiguity warning. */
-    readonly scope?: string;
-    /** Numeric value → choropleth shade (§24B.3). Lifted out of `meta`. */
-    readonly value?: number;
-    /** Tag values keyed by lowercased tag GROUP name (alias is resolved away). */
-    readonly tags: Readonly<Record<string, string>>;
-    /** Any remaining reserved keys captured verbatim (`label`/`style`/…). */
-    readonly meta: Readonly<Record<string, string>>;
-    readonly lineNumber: number;
+interface JourneyMapAnnotation {
+    readonly type: 'pain' | 'opportunity' | 'thought';
+    readonly text: string;
 }
-/** A point of interest (§24B.5). `meta` holds the numeric `value` (→ marker
- *  size) and `style` verbatim; `label` is lifted out. */
-interface MapPoi {
-    readonly pos: PoiPos;
-    readonly alias?: string;
-    readonly label?: string;
+interface JourneyMapStep {
+    readonly id: string;
+    readonly title: string;
+    readonly score?: number;
+    readonly emotionLabel?: string;
     readonly tags: Readonly<Record<string, string>>;
-    readonly meta: Readonly<Record<string, string>>;
-    readonly lineNumber: number;
-}
-/** One leg of a route (§24B.6): an edge from the previous stop to `dest`. Reuses
- *  the edge arrow idiom — in-arrow text = leg label, `value:` = leg thickness,
- *  `->`/`~>` (or the header `style: arc`) = shape. Stop-targeted keys on the leg
- *  line (`tag`, `label:`) decorate the DESTINATION point. */
-interface MapRouteLeg {
-    readonly label?: string;
-    readonly style: 'straight' | 'arc';
-    readonly value?: string;
-    readonly dest: PoiPos;
-    readonly destAlias?: string;
-    readonly destLabel?: string;
-    readonly destTags: Readonly<Record<string, string>>;
+    readonly annotations: readonly JourneyMapAnnotation[];
+    readonly description?: string;
     readonly lineNumber: number;
+    readonly endLineNumber: number;
 }
-/** An ordered, auto-numbered route (§24B.6): `route <origin> [style: arc]` + a
- *  sequence of indented arrow legs, each continuing from the previous stop.
- *  Repeat the origin as a leg's destination to close a loop. */
-interface MapRoute {
-    readonly origin: PoiPos;
-    readonly originAlias?: string;
-    readonly originLabel?: string;
-    readonly originValue?: string;
-    readonly originTags: Readonly<Record<string, string>>;
-    readonly style: 'straight' | 'arc';
-    readonly legs: readonly MapRouteLeg[];
+interface JourneyMapPhase {
+    readonly id: string;
+    readonly name: string;
+    readonly steps: readonly JourneyMapStep[];
     readonly lineNumber: number;
 }
-/** A connector (§24B.6). Endpoints are RAW identifier strings (name or alias);
- *  binding to POIs/regions is the resolver's job. `~>`→arc; `--`→directed:false. */
-interface MapEdge {
-    readonly from: string;
-    readonly to: string;
-    readonly label?: string;
-    readonly directed: boolean;
-    readonly style: 'straight' | 'arc';
-    readonly meta: Readonly<Record<string, string>>;
+interface JourneyMapPersona {
+    readonly name: string;
+    readonly description?: string;
+    readonly color?: string;
     readonly lineNumber: number;
 }
-interface ParsedMap {
-    readonly title: string | null;
-    readonly titleLineNumber: number | null;
-    readonly directives: MapDirectives;
+interface ParsedJourneyMap {
+    readonly type: 'journey-map';
+    readonly title?: string;
+    readonly titleLineNumber?: number;
+    readonly persona?: JourneyMapPersona;
+    readonly phases: readonly JourneyMapPhase[];
+    /** Flat-mode steps (not inside any phase) */
+    readonly steps: readonly JourneyMapStep[];
     readonly tagGroups: readonly TagGroup[];
-    readonly regions: readonly MapRegion[];
-    readonly pois: readonly MapPoi[];
-    readonly routes: readonly MapRoute[];
-    readonly edges: readonly MapEdge[];
     readonly options: Readonly<Record<string, string>>;
     readonly diagnostics: readonly DgmoError[];
     readonly error: string | null;
 }
 
-/** True when the first non-blank/non-comment line declares `map`. */
-declare function looksLikeMap(content: string): boolean;
-declare function parseMap(content: string): ParsedMap;
+declare function parseJourneyMap(content: string, palette?: PaletteColors): ParsedJourneyMap;
 
-/** A TopoJSON topology (world-coarse/world-detail keyed by ISO 3166-1 alpha-2;
- *  us-states keyed by ISO 3166-2). Geometry feature `id` is the ISO code;
- *  `properties.name` is the display string. Kept loose to avoid a topojson dep. */
-interface BoundaryTopology {
-    type: 'Topology';
-    objects: Record<string, {
-        type: string;
-        geometries: BoundaryGeometry[];
-    }>;
-    arcs: number[][][];
-    transform?: {
-        scale: [number, number];
-        translate: [number, number];
-    };
-    bbox?: number[];
-}
-interface BoundaryGeometry {
-    type: string;
-    /** ISO code: alpha-2 (countries) or 3166-2 `US-XX` (states). */
-    id: string;
-    properties: {
-        name: string;
-    };
-    arcs?: unknown;
-}
-/**
- * A gazetteer city entry: `[lat, lon, iso, pop, name, sub?]`.
- * - `lat`/`lon` — rounded to 3 decimals.
- * - `iso` — ISO 3166-1 alpha-2 country code.
- * - `pop` — population.
- * - `name` — canonical display name (case/accents preserved).
- * - `sub` — ISO 3166-2 subdivision (US cities only in v1, e.g. `US-OR`); absent otherwise.
- */
-type GazetteerEntry = [
-    lat: number,
-    lon: number,
-    iso: string,
-    pop: number,
-    name: string,
-    sub?: string
-];
-interface Gazetteer {
-    /** Every city, stored once. `byName`/`alt` reference cities by array index
-     *  (normalized — no tuple duplication; geonameid is a build-time-only linker). */
-    cities: GazetteerEntry[];
-    /** Folded (NFD, diacritic-stripped, lowercased) name → indices into `cities`.
-     *  Always an array; length > 1 for same-named cities (Portland US-OR / US-ME). */
-    byName: Record<string, number[]>;
-    /** Folded alias → index into `cities`. Never collides with a `byName` key. */
-    alt: Record<string, number>;
-}
-/** A fill-able region (country or US state) — the display name + its ISO id +
- *  layer. Powers region-name autocomplete (completion-only; the renderer derives
- *  names from the topology directly). Extracted from the topologies by
- *  scripts/build-map-data.mjs into `region-names.json`. */
-interface RegionName {
-    /** Display name (original casing), e.g. `California` / `Germany`. */
-    readonly name: string;
-    /** ISO 3166-1 alpha-2 (country) or 3166-2 `US-XX` (state). */
-    readonly iso: string;
-    readonly layer: 'country' | 'us-state';
-}
-interface RegionNames {
-    /** Deterministically ordered (layer, then name). */
-    readonly regions: readonly RegionName[];
+interface CurvePoint {
+    x: number;
+    y: number;
+    score: number;
+    emotionLabel?: string;
+    stepIndex: number;
 }
-
-/** The four static assets, injected into the pure resolver (DI). */
-interface MapData {
-    worldCoarse: BoundaryTopology;
-    worldDetail: BoundaryTopology;
-    usStates: BoundaryTopology;
-    /** Major lakes (Natural Earth 110m) drawn as water over land — e.g. the Great
-     *  Lakes. Optional so hand-built test fixtures need not supply it. */
-    lakes?: BoundaryTopology;
-    /** Major river centerlines (Natural Earth 110m) drawn as thin water lines over
-     *  land — e.g. the Amazon, Nile, Mississippi. Optional, like `lakes`. */
-    rivers?: BoundaryTopology;
-    /** North-America-clipped 10m country land, used as crisp neighbour context
-     *  under the albers-usa US view so Canada/Mexico match the 10m states instead
-     *  of the coarser world tiers. Optional, like `lakes`. */
-    naLand?: BoundaryTopology;
-    /** North-America-clipped 10m major lakes (Great Lakes etc.), used in place of
-     *  the coarse `lakes` under the albers-usa US view. Optional. */
-    naLakes?: BoundaryTopology;
-    gazetteer: Gazetteer;
+interface StepLayout {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    step: JourneyMapStep;
+    color: string;
 }
-type ProjectionFamily = 'equirectangular' | 'natural-earth' | 'albers-usa' | 'mercator';
-/** Which geometry layers the renderer draws. */
-interface Basemaps {
-    /** World country tier: coarse (world-scale) | detail (regional/zoom). */
-    world: 'coarse' | 'detail';
-    /** Loaded subdivision layers (v1: only 'us-states'). */
-    subdivisions: Array<'us-states'>;
+interface PhaseLayout {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    phase: JourneyMapPhase;
+    headerColor: string;
+    stepLayouts: StepLayout[];
 }
-interface ResolvedRegion {
-    /** ISO code: alpha-2 (country) or 3166-2 `US-XX` (state) — the geometry id. */
-    readonly iso: string;
-    readonly name: string;
-    readonly layer: 'country' | 'us-state';
-    readonly value?: number;
-    readonly tags: Readonly<Record<string, string>>;
-    readonly meta: Readonly<Record<string, string>>;
-    readonly lineNumber: number;
+interface JourneyMapLayout {
+    phases: PhaseLayout[];
+    flatStepLayouts: StepLayout[];
+    curvePoints: CurvePoint[];
+    totalWidth: number;
+    totalHeight: number;
+    curveAreaTop: number;
+    curveAreaBottom: number;
+    cardAreaTop: number;
+    personaHeight: number;
+    titleHeight: number;
+    /** Whether any step has thought annotations */
+    hasThoughts: boolean;
 }
-interface ResolvedPoi {
-    /** Folded registry id (alias|name folded, or `@lat,lon` for coord POIs). */
-    readonly id: string;
-    /** Display name (original casing): the city/place name, alias, or endpoint
-     *  string. The on-map label falls back to this when `label` is absent (the
-     *  folded `id` is for binding, not display). */
-    readonly name?: string;
-    readonly lat: number;
-    readonly lon: number;
-    readonly label?: string;
-    readonly tags: Readonly<Record<string, string>>;
-    readonly meta: Readonly<Record<string, string>>;
-    readonly lineNumber: number;
-    /** True when created from an undeclared edge/route endpoint (§24B.10). */
-    readonly implicit?: boolean;
+declare function layoutJourneyMap(parsed: ParsedJourneyMap, palette: PaletteColors, options?: {
+    exportDims?: {
+        width: number;
+        height: number;
+    };
+    collapsedPhases?: Set<string>;
+    isDark?: boolean;
+}): JourneyMapLayout;
+
+interface JourneyMapInteractiveOptions {
+    onNavigateToLine?: (line: number) => void;
+    exportDims?: {
+        width: number;
+        height: number;
+    };
+    activeTagGroup?: string | null;
+    onActiveTagGroupChange?: (group: string | null) => void;
+    /** Current editor cursor line — highlights the matching face + card, dims the rest */
+    currentLine?: number | null;
+    /** Set of collapsed phase names */
+    collapsedPhases?: Set<string>;
+    /** Called when a phase is toggled */
+    onPhaseToggle?: (phaseName: string) => void;
+    exportMode?: boolean;
 }
-interface ResolvedEdge {
-    readonly fromId: string;
-    readonly toId: string;
-    readonly label?: string;
-    readonly directed: boolean;
-    readonly style: 'straight' | 'arc';
-    readonly meta: Readonly<Record<string, string>>;
+declare function renderJourneyMap(container: HTMLElement, parsed: ParsedJourneyMap, palette: PaletteColors, isDark: boolean, options?: JourneyMapInteractiveOptions): void;
+declare function renderJourneyMapForExport(content: string, theme: 'light' | 'dark' | 'transparent', palette: PaletteColors): string;
+
+interface PyramidLayer {
+    readonly label: string;
     readonly lineNumber: number;
+    /** Optional palette color name (red/green/blue/…). */
+    readonly color?: string;
+    /** Description lines — from bare pipe shorthand or indented body. */
+    readonly description: readonly string[];
+    /** Unconsumed pipe metadata (reserved for future use). */
+    readonly metadata: Readonly<Record<string, string>>;
 }
-interface ResolvedRouteLeg {
-    readonly fromId: string;
-    readonly toId: string;
-    readonly label?: string;
-    readonly style: 'straight' | 'arc';
-    readonly value?: string;
-    readonly lineNumber: number;
+interface ParsedPyramid {
+    readonly type: 'pyramid';
+    readonly title: string;
+    readonly titleLineNumber: number;
+    readonly layers: readonly PyramidLayer[];
+    /** When true, apex points down instead of up. */
+    readonly inverted: boolean;
+    readonly options: Readonly<Record<string, string>>;
+    readonly diagnostics: readonly DgmoError[];
+    readonly error: string | null;
 }
-interface ResolvedRoute {
-    /** Ordered UNIQUE stop ids (for numbering + the origin marker). A loop-closing
-     *  leg whose destination is an earlier stop adds a leg but no duplicate stop. */
-    readonly stopIds: readonly string[];
-    readonly legs: readonly ResolvedRouteLeg[];
+
+/**
+ * Parse a `.dgmo` pyramid diagram document.
+ *
+ * Top of file = apex of pyramid (reads top-down).
+ *
+ * Syntax:
+ * ```
+ * pyramid Maslow's Hierarchy of Needs
+ *
+ * inverted                               // optional — flips apex to bottom
+ *
+ * Self-Actualization                     // indented body = description
+ *   Achieving one's full potential.
+ *
+ * Esteem | Respect, recognition          // bare pipe shorthand = description
+ *
+ * Love & Belonging | color: blue         // structured metadata
+ *   Friendship, intimacy, family.
+ *
+ * Physiological | Food, water, rest
+ * ```
+ */
+declare function parsePyramid(content: string): ParsedPyramid;
+
+/**
+ * Render a pyramid diagram into the given container.
+ */
+declare function renderPyramid(container: HTMLDivElement, parsed: ParsedPyramid, palette: PaletteColors, isDark: boolean, onClickItem?: (lineNumber: number) => void, exportDims?: D3ExportDimensions): void;
+/**
+ * Render for CLI/export (no click handlers).
+ */
+declare function renderPyramidForExport(container: HTMLDivElement, parsed: ParsedPyramid, palette: PaletteColors, isDark: boolean, exportDims?: D3ExportDimensions): void;
+
+interface RingLayer {
+    readonly label: string;
     readonly lineNumber: number;
+    /** Optional palette color name (red/green/blue/…). */
+    readonly color?: string;
+    /** Description lines — from bare pipe shorthand or indented body. */
+    readonly description: readonly string[];
+    /** Unconsumed pipe metadata (reserved for future use). */
+    readonly metadata: Readonly<Record<string, string>>;
 }
-/** Geographic bounding box `[[west, south], [east, north]]` in degrees.
- *
- *  WRAP CONVENTION (#12): for an antimeridian-crossing extent the resolver keeps
- *  `west` in [−180, 180] and returns `east` UNWRAPPED in (180, 540] (i.e.
- *  `east = west + span`, span ≤ 360). So `east > 180` signals a dateline-crossing
- *  extent; the renderer (step 4) must mod `east` back into [−180, 180] (or shift
- *  the projection's center) rather than assume `east ≤ 180`. `south`/`north` are
- *  always plain degrees in [−90, 90]. */
-type GeoExtent = [[number, number], [number, number]];
-interface ResolvedMap {
-    readonly title: string | null;
-    readonly subtitle?: string;
-    readonly caption?: string;
-    readonly tagGroups: readonly TagGroup[];
-    readonly directives: MapDirectives;
-    readonly basemaps: Basemaps;
-    readonly regions: readonly ResolvedRegion[];
-    readonly pois: readonly ResolvedPoi[];
-    readonly edges: readonly ResolvedEdge[];
-    readonly routes: readonly ResolvedRoute[];
-    readonly extent: GeoExtent;
-    readonly projection: ProjectionFamily;
+interface ParsedRing {
+    readonly type: 'ring';
+    readonly title: string;
+    readonly titleLineNumber: number;
+    /** Source order: layers[0] = innermost (filled disc); last = outermost ring. */
+    readonly layers: readonly RingLayer[];
+    readonly options: Readonly<Record<string, string>>;
     readonly diagnostics: readonly DgmoError[];
     readonly error: string | null;
 }
 
+/**
+ * Parse a `.dgmo` ring diagram document.
+ *
+ * Top of file = innermost ring (rendered as a filled disc).
+ * Last layer in source = outermost ring.
+ */
+declare function parseRing(content: string): ParsedRing;
+
+/**
+ * Render a ring diagram into the given container.
+ */
+declare function renderRing(container: HTMLDivElement, parsed: ParsedRing, palette: PaletteColors, isDark: boolean, onClickItem?: (lineNumber: number) => void, exportDims?: D3ExportDimensions): void;
+/**
+ * Render for CLI/export (no click handlers).
+ */
+declare function renderRingForExport(container: HTMLDivElement, parsed: ParsedRing, palette: PaletteColors, isDark: boolean, exportDims?: D3ExportDimensions): void;
+
+/** True when the first non-blank/non-comment line declares `map`. */
+declare function looksLikeMap(content: string): boolean;
+declare function parseMap(content: string): ParsedMap;
+
 declare function resolveMap(parsed: ParsedMap, data: MapData): ResolvedMap;
 
 /** Load + memoize the four map assets (Node). Throws if none of the candidate
@@ -4556,6 +4660,9 @@ interface MapLayoutRegion {
     readonly d: string;
     readonly fill: string;
     readonly stroke: string;
+    /** Human-readable display name (e.g. "France", "California"). Set for EVERY
+     *  region — authored and base/context alike — and emitted as
+     *  `data-region-name` so the app can show it on hover. */
     readonly label?: string;
     readonly lineNumber: number;
     readonly layer: 'base' | 'country' | 'us-state';
@@ -4578,6 +4685,32 @@ interface MapLayoutInset {
     readonly w: number;
     readonly h: number;
     readonly points: ReadonlyArray<readonly [number, number]>;
+    /** The FITTED inset projection (fit to this frame's screen box inside
+     *  `placeInset`). Load-bearing for pixel↔lonLat over the AK/HI insets: the
+     *  un-fitted `alaskaProjection()`/`hawaiiProjection()` factories would invert
+     *  to garbage, so the geo-query inverts against THIS instance. */
+    readonly projection: GeoProjection;
+    /** Neighbour land (e.g. Canada beside Alaska) projected with this inset's
+     *  fitted projection and clipped to the box — drawn BEHIND the state so a land
+     *  border reads as land, not coast. Without it the state's outer ring buffers
+     *  outward over open box-ocean and the land border sprouts coastline rings.
+     *  `undefined` when no neighbour land falls inside the box. */
+    readonly contextLand?: {
+        readonly d: string;
+        readonly fill: string;
+    };
+}
+/** Post-projection non-uniform stretch applied to GLOBAL fits (fill-the-canvas).
+ *  `null` for regional fits. The geo-query applies the forward form when
+ *  projecting and the inverse before `projection.invert`. Mirrors the `stretch`
+ *  closure used for the path stream:  px = ox + (x - bx0) * sx. */
+interface MapLayoutStretch {
+    readonly sx: number;
+    readonly sy: number;
+    readonly ox: number;
+    readonly oy: number;
+    readonly bx0: number;
+    readonly by0: number;
 }
 interface MapLayoutPoi {
     readonly id: string;
@@ -4593,6 +4726,37 @@ interface MapLayoutPoi {
     /** Tag values keyed by lowercased group name — emitted as `data-tag-<group>`
      *  so the app can spotlight markers on legend-entry hover (mirrors regions). */
     readonly tags?: Readonly<Record<string, string>>;
+    /** Set when this marker is a member of a coincident stack (spiderfy). Its
+     *  `cx/cy` is the EXPANDED ring position (the source-of-truth used by export +
+     *  the no-JS default); the app collapses the stack to a single badge at rest
+     *  via `data-cluster-member`. */
+    readonly clusterId?: string;
+}
+/** A coincident POI stack (≥2 markers whose dots overlap). Laid out EXPANDED
+ *  (members fanned onto a ring/spiral with legs to the centroid) — that geometry
+ *  is the source of truth: a static export shows every member + label with no
+ *  special-casing. The renderer ALSO emits a collapsed `+N`-style badge (a neutral
+ *  dot ringed with the bare count) at the centroid, hidden by default; the app
+ *  collapses each stack at rest (hide members, show badge) and expands on click. */
+interface MapLayoutCluster {
+    /** Stable id (the first member's POI id). Mirrored on member dots/labels/legs as
+     *  `data-cluster-member` and on the badge as `data-cluster`. */
+    readonly id: string;
+    /** Centroid (collapsed badge position + spider-leg hub). */
+    readonly cx: number;
+    readonly cy: number;
+    /** Member count = badge text (bare `N`, RQ1). */
+    readonly count: number;
+    /** Radius of the transparent pointer hit-area centred on the centroid — covers
+     *  the collapsed badge AND the expanded dot ring so a hover/click anywhere over
+     *  the stack drives the spiderfy controller. */
+    readonly hitR: number;
+    /** Spider legs: centroid → each expanded member dot (member's own colour). */
+    readonly legs: ReadonlyArray<{
+        readonly x2: number;
+        readonly y2: number;
+        readonly color: string;
+    }>;
 }
 /** A drawn connector -- an edge or a route leg (same geometry contract). */
 interface MapLayoutLeg {
@@ -4603,6 +4767,17 @@ interface MapLayoutLeg {
     readonly label?: string;
     readonly labelX?: number;
     readonly labelY?: number;
+    /** Text colour for the label — contrast-picked against the background fill the
+     *  label sits on (the choropleth/tag region under it, or land/water), so a
+     *  freight tag over a dark scored country reads light, over pale land reads
+     *  dark. Absent ⇒ renderer falls back to the muted default. */
+    readonly labelColor?: string;
+    /** Whether the label needs a halo. Only set when the chosen text colour's
+     *  contrast against the underlying fill is marginal (mid-tone fills); clear
+     *  fills get no ghost. */
+    readonly labelHalo?: boolean;
+    /** Halo colour (opposite lightness of `labelColor`) when {@link labelHalo}. */
+    readonly labelHaloColor?: string;
     readonly lineNumber: number;
 }
 interface PlacedLabel {
@@ -4627,6 +4802,24 @@ interface PlacedLabel {
     /** The POI this label belongs to (POI labels only) — emitted as `data-poi` on
      *  the label + leader so the app can spotlight the dot on label hover. */
     readonly poiId?: string;
+    /** Cartographic italic (context-label water names, §24B). Default upright. */
+    readonly italic?: boolean;
+    /** Cartographic letter-spacing in px (context-label water names). Default 0. */
+    readonly letterSpacing?: number;
+    /** Pre-wrapped display lines (context-label water names — §24B). When present
+     *  the renderer stacks these as centred tspans instead of `text`; `text` keeps
+     *  the single-string form for hit-testing/measurement. Absent ⇒ single line. */
+    readonly lines?: readonly string[];
+    /** Hover-only label: emitted invisible (opacity 0 + `data-poi-hidden`) in the
+     *  preview and revealed on POI/label hover; OMITTED entirely from static
+     *  export. Set when a POI cluster can't place its labels cleanly (see the
+     *  extent/count/clean gate in the POI-label block). Default-undefined =
+     *  visible. Hidden labels are NOT pushed into `obstacles`. */
+    readonly hidden?: boolean;
+    /** Set when this label belongs to a coincident-stack member (spiderfy). Emitted
+     *  visible (export + expanded view) but tagged `data-cluster-member` so the app
+     *  hides it when the stack is collapsed to its badge. */
+    readonly clusterMember?: string;
     readonly lineNumber: number;
 }
 interface MapLayoutLegend {
@@ -4653,6 +4846,41 @@ interface MapLayoutRiver {
     readonly color: string;
     readonly width: number;
 }
+/** A drawn mountain-range relief shape — a projected polygon path. The renderer
+ *  unions these into one clip and rules horizontal hachure lines through them. */
+interface MapLayoutRelief {
+    readonly d: string;
+}
+/** The shared hachure style for the relief lines. `null` when relief is off or
+ *  no range survives the gates. */
+interface MapLayoutReliefHatch {
+    /** Line stroke — palette.text mixed into the land colour (so it's dark-on-
+     *  light and light-on-dark automatically as palette.text flips with theme). */
+    readonly color: string;
+    /** Vertical gap between lines in SCREEN px (constant density, zoom-stable). */
+    readonly spacing: number;
+    readonly width: number;
+}
+/** Style object for the opt-in coastline water-lines (`coastline`, §24B.2).
+ *  `null` when the flag is off. Carries only STYLE — no geometry; the renderer
+ *  buffers the existing region paths (`layout.regions[].d`) and masks them to the
+ *  water side. `d`/`thickness` are absolute SCREEN px (already resolved from a
+ *  fraction of the fitted canvas, so they stay proportional across export sizes —
+ *  ADR-3). */
+interface MapLayoutCoastlineStyle {
+    /** Water-toned line colour (a touch more contrast than `lakeStroke`). */
+    readonly color: string;
+    /** The 2 coast-parallel lines, inner→outer. `d` = offshore distance,
+     *  `thickness` = ring width (both screen px), `opacity` fades seaward. */
+    readonly lines: ReadonlyArray<{
+        readonly d: number;
+        readonly thickness: number;
+        readonly opacity: number;
+    }>;
+    /** Per-subpath bbox-extent floor (screen px): rings smaller than this are
+     *  dropped (de-noise tiny islands, bound the stroke cost — R5/R11). */
+    readonly minExtent: number;
+}
 interface MapLayout {
     readonly width: number;
     readonly height: number;
@@ -4663,8 +4891,21 @@ interface MapLayout {
     readonly regions: readonly MapLayoutRegion[];
     /** Major river centerlines, drawn over land/lakes and under POIs/edges. */
     readonly rivers: readonly MapLayoutRiver[];
+    /** Mountain-range relief shapes (empty unless `relief` is on + the asset is
+     *  present); the renderer clips horizontal hachure lines to their union,
+     *  drawn over base land, under rivers/POIs/data fills. */
+    readonly relief: readonly MapLayoutRelief[];
+    /** Hachure style for the relief lines (null = relief off / none survived). */
+    readonly reliefHatch: MapLayoutReliefHatch | null;
+    /** Style for the opt-in coastline water-lines (null = `coastline` off). The
+     *  renderer buffers `regions[]`/`insetRegions[]` paths against this style and
+     *  masks them to the water side. */
+    readonly coastlineStyle: MapLayoutCoastlineStyle | null;
     readonly legs: readonly MapLayoutLeg[];
     readonly pois: readonly MapLayoutPoi[];
+    /** Coincident POI stacks (spiderfy). Empty when no ≥2-member overlap exists.
+     *  The renderer draws a collapsed badge per stack; the app collapses/expands. */
+    readonly clusters: readonly MapLayoutCluster[];
     readonly labels: readonly PlacedLabel[];
     readonly legend: MapLayoutLegend | null;
     /** Framed AK/HI inset cutouts (albers-usa only; empty otherwise). */
@@ -4672,6 +4913,16 @@ interface MapLayout {
     /** AK/HI region paths drawn inside the inset boxes (foreground, over an
      *  opaque ocean fill). Paired positionally with `insets`. */
     readonly insetRegions: readonly MapLayoutRegion[];
+    /** The fitted MAIN projection (the conus conic for albers-usa). Exposed for
+     *  the geo-query's pixel↔lonLat inversion — the app NEVER reconstructs it from
+     *  metadata; it binds to this exact instance. */
+    readonly projection: GeoProjection;
+    /** Non-uniform stretch applied for GLOBAL fits (null for regional fits). */
+    readonly stretch: MapLayoutStretch | null;
+    /** Generic layout-time diagnostics channel — currently has no producers, so it
+     *  is always empty. Kept wired up because callers merge it with the resolver's
+     *  diagnostics for the editor lint channel. */
+    readonly diagnostics: readonly DgmoError[];
 }
 interface LayoutOptions {
     readonly palette: PaletteColors;
@@ -4682,6 +4933,11 @@ interface LayoutOptions {
      *  selects the choropleth ramp, a tag-group name selects that group, `'none'`
      *  / `null` clears it. `undefined` = not provided (use the directive/default). */
     readonly activeGroup?: string | null;
+    /** Export-only: when true, suppress the global stretch-fill and contain-fit
+     *  (letterbox) instead. Set by `mapExportDimensions` when it clamps/floors the
+     *  canvas away from the content aspect, so the off-aspect canvas doesn't
+     *  re-distort. The in-app preview pane leaves this unset (keeps stretch-fill). */
+    readonly preferContain?: boolean;
 }
 interface Size {
     readonly width: number;
@@ -4689,16 +4945,19 @@ interface Size {
 }
 /** The map's water / backdrop colour for a palette — the single source of truth
  *  shared by the renderer's `<rect>` fill and any host wrapper that needs to
- *  match it (so letterbox gaps around the SVG don't show a stray band). When
- *  `dataActive` (a score ramp or tag group is colouring regions) the sea recedes
- *  to a pale neutral so blue/green data hues don't blend into it. */
-declare function mapBackgroundColor(palette: PaletteColors, isDark?: boolean, dataActive?: boolean): string;
+ *  match it (so letterbox gaps around the SVG don't show a stray band). Always a
+ *  VERY faded blue — uniform whether or not a colouring dimension is active — so
+ *  it reads as water without competing with saturated blue/green data hues.
+ *  `_dataActive` is retained for signature stability (the sea no longer changes
+ *  with data; only neighbour land recedes — see layout's `foreignFill`). */
+declare function mapBackgroundColor(palette: PaletteColors, isDark?: boolean, _dataActive?: boolean): string;
 /** The map's neutral (unscored/untagged) LAND colour — the base every region
  *  blends from. Exported so a host can DIM a region to plain land (rather than
  *  lowering opacity, which would let the water show through and make the shape
- *  read as ocean). Matches the layout's `neutralFill`. Green reference dress by
- *  default; neutral (page bg on light, lifted gray on dark) when `dataActive`. */
-declare function mapNeutralLandColor(palette: PaletteColors, isDark: boolean, dataActive?: boolean): string;
+ *  read as ocean). Matches the layout's `neutralFill`. Always a VERY faded green
+ *  — uniform whether or not data is active — so saturated tag/score tints read
+ *  clearly against it. `_dataActive` is retained for signature stability. */
+declare function mapNeutralLandColor(palette: PaletteColors, isDark: boolean, _dataActive?: boolean): string;
 declare function layoutMap(resolved: ResolvedMap, data: MapData, size: Size, opts: LayoutOptions): MapLayout;
 
 /** Render a resolved map into `container` (d3-selection appends an `<svg>`). */
@@ -4708,6 +4967,130 @@ activeGroupOverride?: string | null): void;
 /** Export wrapper (no click handler) — matches the structured-renderer contract. */
 declare function renderMapForExport(container: HTMLDivElement, resolved: ResolvedMap, data: MapData, palette: PaletteColors, isDark: boolean, exportDims?: D3ExportDimensions): void;
 
+/** The map's intrinsic projected aspect (width / height) for a resolved map.
+ *
+ *  Measured by fitting the projection + fit target (the SAME `buildMapProjection`
+ *  output the renderer draws with) into a square reference box and reading the
+ *  projected bounds of the fit target. `fitSize` scales uniformly, so the ratio is
+ *  independent of the box size (see the reference-box invariance test).
+ *
+ *  Returns {@link FALLBACK_ASPECT} (3:2) if the result is non-finite or ≤ 0 — the
+ *  helper never emits a NaN/0/Infinity aspect. */
+declare function mapContentAspect(resolved: ResolvedMap, data: MapData, 
+/** Square reference box for the measurement. Uniform `fitSize` scaling makes the
+ *  result invariant to this value; exposed only so tests can assert that. */
+ref?: number): number;
+/** Content-aware export dimensions for a map: `width` fixed at `baseWidth`,
+ *  `height` derived from the clamped intrinsic aspect, with a minimum-map-band
+ *  floor for very wide extents. `preferContain` is true when the clamp or floor
+ *  forced the canvas off the content aspect — the renderer then contain-fits
+ *  (letterbox) instead of stretching, so the off-aspect canvas doesn't re-distort. */
+interface MapExportDimensions {
+    readonly width: number;
+    readonly height: number;
+    readonly preferContain: boolean;
+}
+declare function mapExportDimensions(resolved: ResolvedMap, data: MapData, baseWidth?: number): MapExportDimensions;
+
+/** Nearest gazetteer city to a point: the real haversine distance, plus the
+ *  canonical name + ISO + (US-only) subdivision for token shaping. `lon`/`lat`
+ *  are the city's own gazetteer coordinates (so callers can mark it on the map,
+ *  distinct from the inspected point). */
+interface NearestCity {
+    readonly name: string;
+    readonly iso: string;
+    readonly sub?: string;
+    readonly distanceKm: number;
+    readonly lon: number;
+    readonly lat: number;
+}
+/** A region declaration with its canonical/primary form plus bare alternates
+ *  (behind the card's "other forms" expander). */
+interface RegionToken {
+    /** Explicit scoped form, shown first (`Florida US-FL` / `France FR`). */
+    readonly primary: string;
+    /** Bare forms (bare ISO, bare code, bare name). */
+    readonly alternates: string[];
+}
+/** Paste-ready DGMO tokens for one inspected point — each round-trips through the
+ *  map parser with zero diagnostics (the app inserts verbatim, never synthesizes
+ *  syntax). */
+interface ResultTokens {
+    /** Positional POI line, e.g. `poi 40.7608 -111.891` (NEVER `@lat,lon`). */
+    readonly coordPoiLine: string;
+    /** US-state region tokens — null when the click isn't in a US state. */
+    readonly state: RegionToken | null;
+    /** Country region tokens — null over open ocean (no country). */
+    readonly country: RegionToken | null;
+    /** Scoped city token (`New York US-NY` / `Paris FR`), or a bare ambiguous name. */
+    readonly city: {
+        readonly token: string;
+        readonly ambiguous: boolean;
+    } | null;
+}
+/** The single unified Inspect result. */
+interface ResultCard {
+    readonly lonLat: [number, number];
+    readonly country: {
+        iso: string;
+        name: string;
+    } | null;
+    readonly state: {
+        iso: string;
+        name: string;
+    } | null;
+    readonly nearestCity: NearestCity | null;
+    readonly tokens: ResultTokens;
+}
+/** A gazetteer city projected to screen pixels for the all-cities overlay. */
+interface ProjectedCity {
+    readonly name: string;
+    readonly iso: string;
+    readonly sub?: string;
+    readonly lon: number;
+    readonly lat: number;
+    readonly px: number;
+    readonly py: number;
+    readonly pop: number;
+}
+interface MapGeoQuery {
+    /** Pixel → `[lon,lat]`, or null for an out-of-domain pixel. */
+    invert(px: number, py: number): [number, number] | null;
+    /** `[lon,lat]` → pixel, or null if it projects nowhere. */
+    project(lonLat: readonly [number, number]): [number, number] | null;
+    /** One click → the unified result card, or null if the pixel inverts to
+     *  nothing (graceful "no location"). */
+    locate(px: number, py: number): ResultCard | null;
+    /** Culled + projected cities for the all-cities layer (population-primary). */
+    cities(extent?: GeoExtent): ProjectedCity[];
+    /** Layout-time, dimension-dependent diagnostics. They live on the geo-query
+     *  (bound to the rendered layout) rather than the resolver. Callers merge them
+     *  with `resolved.diagnostics`. (No producers currently — always empty.) */
+    readonly diagnostics: readonly DgmoError[];
+}
+interface CreateMapGeoQueryOptions {
+    readonly content: string;
+    readonly width: number;
+    readonly height: number;
+    /** Injected map assets — same `MapData` the app passes to `renderMap`. */
+    readonly data: MapData;
+    /** Same palette/isDark the app renders with (geometry is palette-independent,
+     *  but `layoutMap` mandates them). */
+    readonly palette: PaletteColors;
+    readonly isDark: boolean;
+}
+/** Construct a geo-query handle bound to the layout for `(content, width,
+ *  height, data, palette, isDark)`. Deterministic: identical inputs ⇒ the same
+ *  fitted projection the rendered SVG used, so inverted clicks align.
+ *
+ *  INVARIANT: this is the PREVIEW path — it never passes `preferContain`, so its
+ *  layout matches the in-app preview (stretch-fill), where geo-query is used. It is
+ *  NOT valid against a content-aware EXPORT canvas (which may set `preferContain` →
+ *  contain-fit): the inverted positions would not match that export's pixels. If
+ *  geo-query is ever pointed at an export canvas, thread `preferContain` through
+ *  `CreateMapGeoQueryOptions` to keep the projection in sync. */
+declare function createMapGeoQuery(opts: CreateMapGeoQueryOptions): MapGeoQuery;
+
 interface MapPlaceCompletion {
     /** Canonical display name (original casing), e.g. `Portland`. */
     readonly name: string;
@@ -5328,4 +5711,4 @@ declare function migrateContent(source: string): ContentMigration;
  */
 declare function formatLineDiff(path: string, original: string, migrated: string): string;
 
-export { ALL_CHART_TYPES, AMBIGUITY_THRESHOLD, ARROW_DIAGNOSTIC_CODES, type Activation, type AncestorInfo, type ArcLink, type ArcNodeGroup, type BLCollapseResult, type BLEdge, type BLGroup, type BLLayoutEdge, type BLLayoutGroup, type BLLayoutNode, type BLLayoutResult, type BLNode, type BlipTrend, type BoundaryTopology, type C4ArrowType, type C4DeploymentNode, type C4Element, type C4ElementType, type C4Group, type C4LayoutBoundary, type C4LayoutEdge, type C4LayoutNode, type C4LayoutResult, type C4LegendEntry, type C4LegendGroup, type C4Relationship, type C4Shape, type C4TagEntry, type C4TagGroup, CHART_TYPES, CHART_TYPE_DESCRIPTIONS, COMPLETION_REGISTRY, type ChartDataPoint, type ChartEra, type ChartType$1 as ChartType, type Confidence as ChartTypeConfidence, type ChartTypeMeta, type ChartTypeScore, type SuggestionResult as ChartTypeSuggestionResult, type ClassLayoutEdge, type ClassLayoutNode, type ClassLayoutResult, type ClassMember, type ClassModifier, type ClassNode, type ClassRelationship, type CollapsedMindmapResult, type CollapsedOrgResult, type CollapsedSitemapResult, type CollapsedView, type CompactViewState, type ComputedInfraEdge, type ComputedInfraModel, type ComputedInfraNode, type ContentMigration, type ContextRelationship, type CycleEdge, type CycleLayoutEdge, type CycleLayoutNode, type CycleLayoutResult, type CycleNode, type CycleRenderOptions, type D3ExportDimensions, type DecodedDiagramUrl, type DgmoError, type DgmoSeverity, type DiagramSymbols, type DirectiveSpec, type DirectiveValueSpec, type Duration, type DurationUnit, ECHART_EXPORT_WIDTH, ENTITY_TYPES, type ERCardinality, type ERColumn, type ERConstraint, type ERLayoutEdge, type ERLayoutNode, type ERLayoutResult, type ERRelationship, type ERTable, type ElseIfBranch, type EncodeDiagramUrlOptions, type EncodeDiagramUrlResult, type ExpandedActivity, type ExtendedChartType, type ExtractFn, type FocusOrgResult, type GanttDependency, type GanttEra, type GanttGroup, type GroupRow as GanttGroupRow, type GanttHolidays, type GanttInteractiveOptions, type LaneHeaderRow as GanttLaneHeaderRow, type GanttMarker, type GanttNode, type GanttOptions, type Row as GanttRow, type GanttTask, type TaskRow as GanttTaskRow, type Gazetteer, type GazetteerEntry, type GeoExtent, type GetOrCreateNameResult, type GraphDirection, type GraphEdge, type GraphGroup, type GraphNode, type GraphShape, INFRA_BEHAVIOR_KEYS, type ImportSource, type InfraAvailabilityPercentiles, type InfraBehaviorKey, type InfraCbState, type InfraComputeParams, type InfraDiagnostic, type InfraEdge, type InfraGroup, type InfraLatencyPercentiles, type InfraLayoutEdge, type InfraLayoutGroup, type InfraLayoutNode, type InfraLayoutResult, type InfraLegendGroup, type InfraNode, type InfraPlaybackState, type InfraProperty, type InfraRole, type InfraTagGroup, type InlineSpan, type JourneyMapAnnotation, type JourneyMapInteractiveOptions, type JourneyMapLayout, type JourneyMapPersona, type JourneyMapPhase, type JourneyMapStep, type KanbanCard, type KanbanColumn, type KanbanTagEntry, type KanbanTagGroup, LEGEND_GEAR_PILL_W, LEGEND_HEIGHT, type LayoutEdge, type LayoutGroup, type LayoutNode, type LayoutOptions$1 as LayoutOptions, type LayoutResult$1 as LayoutResult, type LegendCallbacks, type LegendConfig, type LegendControl, type LegendGroupData, type LegendHandle, type LegendLayout, type LegendMode, type LegendPalette, type LegendPosition, type LegendState, METADATA_KEY_SET, MIN_PRIMARY_SCORE, type MapCompletionOptions, type MapData, type MapDirectives, type MapEdge, type MapLayout, type MapLayoutLeg, type MapLayoutLegend, type MapLayoutPoi, type MapLayoutRegion, type MapPlaceCompletion, type MapPoi, type MapRegion, type MapRegionCompletion, type MapRoute, type MemberVisibility, type MindmapLayoutEdge, type MindmapLayoutNode, type MindmapLayoutResult, type MindmapNode, type MonteCarloResult, type NameEntry, type NodeDetail, type OrgContainerBounds, type OrgLayoutEdge, type OrgLayoutNode, type OrgLayoutResult, type OrgNode, PERT_LEGEND_PILL_HEIGHT, PIPE_METADATA, type PaletteColors, type PaletteConfig, type ParseInArrowLabelResult, type ParsedBoxesAndLines, type ParsedC4, type ParsedChart, type ParsedClassDiagram, type ParsedCycle, type ParsedERDiagram, type ParsedExtendedChart, type ParsedGantt, type ParsedGraph, type ParsedInfra, type ParsedJourneyMap, type ParsedKanban, type ParsedMap, type ParsedMindmap, type ParsedOrg, type ParsedPert, type ParsedPyramid, type ParsedRaci, type ParsedRing, type ParsedSequenceDgmo, type ParsedSitemap, type ParsedTechRadar, type ParsedVisualization, type ParsedWireframe, type ParticipantType, type PertActivity, type Anchor as PertAnchor, type PertDirection, type PertEdge, type PertGroup, type PertLayoutEdge, type PertLayoutGroup, type PertLayoutNode, type LayoutOverrides as PertLayoutOverrides, type LayoutResult as PertLayoutResult, type PertMilestone, type PertOptions, type PertRenderOptions, type PipeKeySpec, type PlacedLabel, type PoiPos, type ProjectionFamily, type PyramidLayer, type QuadrantPosition, RACI_ERROR_CODES, VARIANTS as RACI_VARIANTS, RACI_WARNING_CODES, RECOGNIZED_COLOR_NAMES, RULE_COUNT, type RaciDragSource, type RaciInteractionHandlers, type RaciMarker, type RaciPhase, type RaciRoleAssignment, type RaciTask, type RaciVariant, type ReadFileFn, type RegionName, type RegionNames, type RelationshipType, type RenderCategory, type RenderStep, type ResolveImportsResult, type ResolvedActivity, type ResolvedEdge, type ResolvedGroup$1 as ResolvedGroup, type ResolvedMap, type ResolvedPert, type ResolvedGroup as ResolvedPertGroup, type ResolvedPoi, type ResolvedRegion, type ResolvedRoute, type ResolvedSchedule, type ResolvedTask, type RingLayer, ScaleContext, type ScatterLabelPoint, type SectionMessageGroup, type SequenceBlock, type SequenceElement, type SequenceGroup, type SequenceMessage, type SequenceNote, type SequenceParticipant, type SequenceRenderOptions, type SequenceSection, type SimulateOptions, type SitemapContainerBounds, type SitemapDirection, type SitemapEdge, type SitemapLayoutEdge, type SitemapLayoutNode, type SitemapLayoutResult, type SitemapLegendEntry, type SitemapLegendGroup, type SitemapNode, type StateCollapseResult, type TagEntry, type TagGroup, type TechRadarBlip, type TechRadarLayoutPoint, type TechRadarQuadrant, type TechRadarRing, type Theme, type TransformResult, type VisualizationType, type WireframeElement, type WireframeElementType, type WireframeFormFactor, type WireframeLayout, type WireframeLayoutNode, addDurationToDate, analyzePert, applyCollapseProjection, applyGroupOrdering, applyPositionOverrides, boldPalette, buildExtendedChartOption, buildNoteMessageMap, buildRenderSequence, buildSimpleChartOption, buildSimulationContext, buildTagLaneRowList, calculateSchedule, catppuccinPalette, confidence as chartTypeConfidence, chartTypeParsers, chartTypes, collapseBoxesAndLines, collapseMindmapTree, collapseOrgTree, collapseSitemapTree, collapseStateGroups, collectDiagramRoles, collectTasks, colorNames, completeMapPlaces, completeMapRegions, computeActivations, computeCardArchive, computeCardMove, computeCycleLayout, computeInfra, computeInfraLegendGroups, computeLegendLayout, computeRadarLayout, computeScatterLabelGraphics, computeTimeTicks, contrastText, controlsGroupCapsuleWidth, decodeDiagramUrl, decodeViewState, displayName, draculaPalette, encodeDiagramUrl, encodeViewState, extractDiagramSymbols, extractPertSymbols, extractTagDeclarations, findUnsafePipePositions, focusOrgTree, formatDateLabel, formatDgmoError, formatLineDiff, getAllChartTypes, getAvailablePalettes, getExtendedChartLegendGroups, getLegendReservedHeight, getOrCreateName, getPalette, getRadarGeometry, getRenderCategory, getSeriesColors, getSimpleChartLegendGroups, groupMessagesBySection, gruvboxPalette, hexToHSL, hexToHSLString, highlightPertCriticalPath, highlightPertSet, hslToHex, inferParticipantType, inferRoles, isArchiveColumn, isExtendedChartType, isLegacyMetadataLine, isRecognizedColorName, isSequenceBlock, isSequenceNote, isValidHex, knownChartTypeIds, layoutBoxesAndLines, layoutC4Components, layoutC4Containers, layoutC4Context, layoutC4Deployment, layoutClassDiagram, layoutERDiagram, layoutGraph, layoutInfra, layoutJourneyMap, layoutMap, layoutMindmap, layoutOrg, layoutPert, layoutSitemap, layoutWireframe, loadMapData, looksLikeClassDiagram, looksLikeERDiagram, looksLikeFlowchart, looksLikeMap, looksLikePert, looksLikeSequence, looksLikeSitemap, looksLikeState, makeDgmoError, mapBackgroundColor, mapNeutralLandColor, matchesContiguously, measurePertAnalysisBlock, migrateContent, mix, monokaiPalette, mulberry32, nord, nordPalette, normalize as normalizeChartTypePrompt, normalizeName, normalizePertSourceForShare, oneDarkPalette, orderArcNodes, palettes, parseAndLayoutInfra, parseBoxesAndLines, parseC4, parseChart, parseClassDiagram, parseCycle, parseDataRowValues, parseDgmo, parseDgmoChartType, parseERDiagram, parseExtendedChart, parseFirstLine, parseFlowchart, parseGantt, parseInArrowLabel, parseInfra, parseInlineMarkdown, parseJourneyMap, parseKanban, parseMap, parseMindmap, parseOrg, parsePert, parsePyramid, parseRaci, parseRing, parseSequenceDgmo, parseSequenceDgmo as parseSequenceDiagram, parseSitemap, parseState, parseTechRadar, parseTimelineDate, parseVisualization, parseWireframe, pertLegendBlockWidth, pertLegendEntries, cellAppendMarker as raciCellAppendMarker, cellCycle as raciCellCycle, cellRemove as raciCellRemove, cellReplace as raciCellReplace, registerExtractor, registerPalette, relayoutPert, render, renderArcDiagram, renderBoxesAndLines, renderBoxesAndLinesForExport, renderC4ComponentsForExport, renderC4Containers, renderC4ContainersForExport, renderC4Context, renderC4ContextForExport, renderC4Deployment, renderC4DeploymentForExport, renderClassDiagram, renderClassDiagramForExport, renderCycle, renderCycleForExport, renderERDiagram, renderERDiagramForExport, renderExtendedChartForExport, renderFlowchart, renderFlowchartForExport, renderForExport, renderGantt, renderInfra, renderJourneyMap, renderJourneyMapForExport, renderKanban, renderKanbanForExport, renderLegendD3, renderLegendSvg, renderLegendSvgFromConfig, renderMap, renderMapForExport, renderMindmap, renderMindmapForExport, renderOrg, renderOrgForExport, renderPert, renderPertAnalysisBlock, renderPertForExport, renderLegendBlock as renderPertLegendBlock, renderPyramid, renderPyramidForExport, renderQuadrant, renderQuadrantFocus, renderQuadrantFocusForExport, renderRaci, renderRaciForExport, renderRing, renderRingForExport, renderSequenceDiagram, renderSitemap, renderSitemapForExport, renderSlopeChart, renderState, renderStateForExport, renderTechRadar, renderTechRadarForExport, renderTimeline, renderVenn, renderWireframe, renderWordCloud, resetPertCriticalPath, resetPertHighlight, resolveColor, resolveColorWithDiagnostic, resolveMap, resolveOrgImports, resolveTaskName, rollUpContextRelationships, rosePinePalette, sampleBetaPert, scoreChartType, seriesColors, shade, shapeFill, simulateCanonical, simulateFast, solarizedPalette, suggestChartTypes, themes, tint, tokyoNightPalette, transformLine, truncateBareUrl, parseDgmo as validate, validateComputed, validateInfra, validateLabelCharacters };
+export { ALL_CHART_TYPES, AMBIGUITY_THRESHOLD, ARROW_DIAGNOSTIC_CODES, type Activation, type AncestorInfo, type ArcLink, type ArcNodeGroup, type BLCollapseResult, type BLEdge, type BLGroup, type BLLayoutEdge, type BLLayoutGroup, type BLLayoutNode, type BLLayoutResult, type BLNode, type BlipTrend, type BoundaryTopology, type C4ArrowType, type C4DeploymentNode, type C4Element, type C4ElementType, type C4Group, type C4LayoutBoundary, type C4LayoutEdge, type C4LayoutNode, type C4LayoutResult, type C4LegendEntry, type C4LegendGroup, type C4Relationship, type C4Shape, type C4TagEntry, type C4TagGroup, CHART_TYPES, CHART_TYPE_DESCRIPTIONS, COMPLETION_REGISTRY, type ChartDataPoint, type ChartEra, type ChartType$1 as ChartType, type Confidence as ChartTypeConfidence, type ChartTypeMeta, type ChartTypeScore, type SuggestionResult as ChartTypeSuggestionResult, type ClassLayoutEdge, type ClassLayoutNode, type ClassLayoutResult, type ClassMember, type ClassModifier, type ClassNode, type ClassRelationship, type CollapsedMindmapResult, type CollapsedOrgResult, type CollapsedSitemapResult, type CollapsedView, type CompactViewState, type ComputedInfraEdge, type ComputedInfraModel, type ComputedInfraNode, type ContentMigration, type ContextRelationship, type CreateMapGeoQueryOptions, type CycleEdge, type CycleLayoutEdge, type CycleLayoutNode, type CycleLayoutResult, type CycleNode, type CycleRenderOptions, type D3ExportDimensions, type DecodedDiagramUrl, type DgmoError, type DgmoSeverity, type DiagramSymbols, type DirectiveSpec, type DirectiveValueSpec, type Duration, type DurationUnit, ECHART_EXPORT_WIDTH, ENTITY_TYPES, type ERCardinality, type ERColumn, type ERConstraint, type ERLayoutEdge, type ERLayoutNode, type ERLayoutResult, type ERRelationship, type ERTable, type ElseIfBranch, type EncodeDiagramUrlOptions, type EncodeDiagramUrlResult, type ExpandedActivity, type ExtendedChartType, type ExtractFn, type FocusOrgResult, type GanttDependency, type GanttEra, type GanttGroup, type GroupRow as GanttGroupRow, type GanttHolidays, type GanttInteractiveOptions, type LaneHeaderRow as GanttLaneHeaderRow, type GanttMarker, type GanttNode, type GanttOptions, type Row as GanttRow, type GanttTask, type TaskRow as GanttTaskRow, type Gazetteer, type GazetteerEntry, type GeoExtent, type GetOrCreateNameResult, type GraphDirection, type GraphEdge, type GraphGroup, type GraphNode, type GraphShape, INFRA_BEHAVIOR_KEYS, type ImportSource, type InfraAvailabilityPercentiles, type InfraBehaviorKey, type InfraCbState, type InfraComputeParams, type InfraDiagnostic, type InfraEdge, type InfraGroup, type InfraLatencyPercentiles, type InfraLayoutEdge, type InfraLayoutGroup, type InfraLayoutNode, type InfraLayoutResult, type InfraLegendGroup, type InfraNode, type InfraPlaybackState, type InfraProperty, type InfraRole, type InfraTagGroup, type InlineSpan, type JourneyMapAnnotation, type JourneyMapInteractiveOptions, type JourneyMapLayout, type JourneyMapPersona, type JourneyMapPhase, type JourneyMapStep, type KanbanCard, type KanbanColumn, type KanbanTagEntry, type KanbanTagGroup, LEGEND_GEAR_PILL_W, LEGEND_HEIGHT, type LayoutEdge, type LayoutGroup, type LayoutNode, type LayoutOptions$1 as LayoutOptions, type LayoutResult$1 as LayoutResult, type LegendCallbacks, type LegendConfig, type LegendControl, type LegendGroupData, type LegendHandle, type LegendLayout, type LegendMode, type LegendPalette, type LegendPosition, type LegendState, METADATA_KEY_SET, MIN_PRIMARY_SCORE, type MapCompletionOptions, type MapData, type MapDirectives, type MapEdge, type MapExportDimensions, type MapGeoQuery, type MapLayout, type MapLayoutInset, type MapLayoutLeg, type MapLayoutLegend, type MapLayoutPoi, type MapLayoutRegion, type MapLayoutStretch, type MapPlaceCompletion, type MapPoi, type MapRegion, type MapRegionCompletion, type MapRoute, type MemberVisibility, type MindmapLayoutEdge, type MindmapLayoutNode, type MindmapLayoutResult, type MindmapNode, type MonteCarloResult, type NameEntry, type NearestCity, type NodeDetail, type OrgContainerBounds, type OrgLayoutEdge, type OrgLayoutNode, type OrgLayoutResult, type OrgNode, PERT_LEGEND_PILL_HEIGHT, PIPE_METADATA, type PaletteColors, type PaletteConfig, type ParseInArrowLabelResult, type ParsedBoxesAndLines, type ParsedC4, type ParsedChart, type ParsedClassDiagram, type ParsedCycle, type ParsedERDiagram, type ParsedExtendedChart, type ParsedGantt, type ParsedGraph, type ParsedInfra, type ParsedJourneyMap, type ParsedKanban, type ParsedMap, type ParsedMindmap, type ParsedOrg, type ParsedPert, type ParsedPyramid, type ParsedRaci, type ParsedRing, type ParsedSequenceDgmo, type ParsedSitemap, type ParsedTechRadar, type ParsedVisualization, type ParsedWireframe, type ParticipantType, type PertActivity, type Anchor as PertAnchor, type PertDirection, type PertEdge, type PertGroup, type PertLayoutEdge, type PertLayoutGroup, type PertLayoutNode, type LayoutOverrides as PertLayoutOverrides, type LayoutResult as PertLayoutResult, type PertMilestone, type PertOptions, type PertRenderOptions, type PipeKeySpec, type PlacedLabel, type PoiPos, type ProjectedCity, type ProjectionFamily, type PyramidLayer, type QuadrantPosition, RACI_ERROR_CODES, VARIANTS as RACI_VARIANTS, RACI_WARNING_CODES, RECOGNIZED_COLOR_NAMES, RULE_COUNT, type RaciDragSource, type RaciInteractionHandlers, type RaciMarker, type RaciPhase, type RaciRoleAssignment, type RaciTask, type RaciVariant, type ReadFileFn, type RegionName, type RegionNames, type RegionToken, type RelationshipType, type RenderCategory, type RenderStep, type ResolveImportsResult, type ResolvedActivity, type ResolvedEdge, type ResolvedGroup$1 as ResolvedGroup, type ResolvedMap, type ResolvedPert, type ResolvedGroup as ResolvedPertGroup, type ResolvedPoi, type ResolvedRegion, type ResolvedRoute, type ResolvedSchedule, type ResolvedTask, type ResultCard, type ResultTokens, type RingLayer, ScaleContext, type ScatterLabelPoint, type SectionMessageGroup, type SequenceBlock, type SequenceElement, type SequenceGroup, type SequenceMessage, type SequenceNote, type SequenceParticipant, type SequenceRenderOptions, type SequenceSection, type SimulateOptions, type SitemapContainerBounds, type SitemapDirection, type SitemapEdge, type SitemapLayoutEdge, type SitemapLayoutNode, type SitemapLayoutResult, type SitemapLegendEntry, type SitemapLegendGroup, type SitemapNode, type StateCollapseResult, type TagEntry, type TagGroup, type TechRadarBlip, type TechRadarLayoutPoint, type TechRadarQuadrant, type TechRadarRing, type Theme, type TransformResult, type VisualizationType, type WireframeElement, type WireframeElementType, type WireframeFormFactor, type WireframeLayout, type WireframeLayoutNode, addDurationToDate, analyzePert, applyCollapseProjection, applyGroupOrdering, applyPositionOverrides, atlasPalette, blueprintPalette, buildExtendedChartOption, buildNoteMessageMap, buildRenderSequence, buildSimpleChartOption, buildSimulationContext, buildTagLaneRowList, calculateSchedule, catppuccinPalette, confidence as chartTypeConfidence, chartTypeParsers, chartTypes, collapseBoxesAndLines, collapseMindmapTree, collapseOrgTree, collapseSitemapTree, collapseStateGroups, collectDiagramRoles, collectTasks, colorNames, completeMapPlaces, completeMapRegions, computeActivations, computeCardArchive, computeCardMove, computeCycleLayout, computeInfra, computeInfraLegendGroups, computeLegendLayout, computeRadarLayout, computeScatterLabelGraphics, computeTimeTicks, contrastText, controlsGroupCapsuleWidth, createMapGeoQuery, decodeDiagramUrl, decodeViewState, displayName, draculaPalette, encodeDiagramUrl, encodeViewState, extractDiagramSymbols, extractPertSymbols, extractTagDeclarations, findUnsafePipePositions, focusOrgTree, formatDateLabel, formatDgmoError, formatLineDiff, getAllChartTypes, getAvailablePalettes, getExtendedChartLegendGroups, getLegendReservedHeight, getOrCreateName, getPalette, getRadarGeometry, getRenderCategory, getSeriesColors, getSimpleChartLegendGroups, groupMessagesBySection, gruvboxPalette, hexToHSL, hexToHSLString, highlightPertCriticalPath, highlightPertSet, hslToHex, inferParticipantType, inferRoles, isArchiveColumn, isExtendedChartType, isLegacyMetadataLine, isRecognizedColorName, isSequenceBlock, isSequenceNote, isValidHex, knownChartTypeIds, layoutBoxesAndLines, layoutC4Components, layoutC4Containers, layoutC4Context, layoutC4Deployment, layoutClassDiagram, layoutERDiagram, layoutGraph, layoutInfra, layoutJourneyMap, layoutMap, layoutMindmap, layoutOrg, layoutPert, layoutSitemap, layoutWireframe, loadMapData, looksLikeClassDiagram, looksLikeERDiagram, looksLikeFlowchart, looksLikeMap, looksLikePert, looksLikeSequence, looksLikeSitemap, looksLikeState, makeDgmoError, mapBackgroundColor, mapContentAspect, mapExportDimensions, mapNeutralLandColor, matchesContiguously, measurePertAnalysisBlock, migrateContent, mix, monokaiPalette, mulberry32, nord, nordPalette, normalize as normalizeChartTypePrompt, normalizeName, normalizePertSourceForShare, oneDarkPalette, orderArcNodes, palettes, parseAndLayoutInfra, parseBoxesAndLines, parseC4, parseChart, parseClassDiagram, parseCycle, parseDataRowValues, parseDgmo, parseDgmoChartType, parseERDiagram, parseExtendedChart, parseFirstLine, parseFlowchart, parseGantt, parseInArrowLabel, parseInfra, parseInlineMarkdown, parseJourneyMap, parseKanban, parseMap, parseMindmap, parseOrg, parsePert, parsePyramid, parseRaci, parseRing, parseSequenceDgmo, parseSequenceDgmo as parseSequenceDiagram, parseSitemap, parseState, parseTechRadar, parseTimelineDate, parseVisualization, parseWireframe, pertLegendBlockWidth, pertLegendEntries, cellAppendMarker as raciCellAppendMarker, cellCycle as raciCellCycle, cellRemove as raciCellRemove, cellReplace as raciCellReplace, registerExtractor, registerPalette, relayoutPert, render, renderArcDiagram, renderBoxesAndLines, renderBoxesAndLinesForExport, renderC4ComponentsForExport, renderC4Containers, renderC4ContainersForExport, renderC4Context, renderC4ContextForExport, renderC4Deployment, renderC4DeploymentForExport, renderClassDiagram, renderClassDiagramForExport, renderCycle, renderCycleForExport, renderERDiagram, renderERDiagramForExport, renderExtendedChartForExport, renderFlowchart, renderFlowchartForExport, renderForExport, renderGantt, renderInfra, renderJourneyMap, renderJourneyMapForExport, renderKanban, renderKanbanForExport, renderLegendD3, renderLegendSvg, renderLegendSvgFromConfig, renderMap, renderMapForExport, renderMindmap, renderMindmapForExport, renderOrg, renderOrgForExport, renderPert, renderPertAnalysisBlock, renderPertForExport, renderLegendBlock as renderPertLegendBlock, renderPyramid, renderPyramidForExport, renderQuadrant, renderQuadrantFocus, renderQuadrantFocusForExport, renderRaci, renderRaciForExport, renderRing, renderRingForExport, renderSequenceDiagram, renderSitemap, renderSitemapForExport, renderSlopeChart, renderState, renderStateForExport, renderTechRadar, renderTechRadarForExport, renderTimeline, renderVenn, renderWireframe, renderWordCloud, resetPertCriticalPath, resetPertHighlight, resolveColor, resolveColorWithDiagnostic, resolveMap, resolveOrgImports, resolveTaskName, rollUpContextRelationships, rosePinePalette, sampleBetaPert, scoreChartType, seriesColors, shade, shapeFill, simulateCanonical, simulateFast, slatePalette, solarizedPalette, suggestChartTypes, themes, tidewaterPalette, tint, tokyoNightPalette, transformLine, truncateBareUrl, parseDgmo as validate, validateComputed, validateInfra, validateLabelCharacters };