@diagrammo/dgmo 0.36.0 → 0.38.0

package/src/infra/parser.ts

@@ -78,16 +78,20 @@ const TAG_VALUE_RE = /^(\w[\w\s]+?)\s*$/;
 
 // Component line. Accepts either a quoted name ("name with | : reserved chars")
 // or a bare name (multi-word allowed; must start with letter/underscore so digit-
-// only or sigil-led lines fall through to other branches). Pipe metadata follows
-// after a `|` separator.
+// only or sigil-led lines fall through to other branches). Metadata follows
+// after a `|` separator (legacy) or as same-line `key: value` (§1.4).
 //
-// Captures:
-//   1: quoted-name content (without the surrounding quotes), or undefined
-//   2: bare-name (trimmed at the call site), or undefined
-//   3: metadata block — legacy `| ...` form OR new same-line
-//      `<word>: <value>...` form (§1.4), or undefined
+// Named captures: qname (quoted content), uname (bare name), alias (`as <x>`
+// postfix), meta (the metadata tail). qname/uname are mutually exclusive.
+//
+// A component declaration: a quoted display name OR a bare name, an OPTIONAL
+// `as <alias>` postfix (alias mirrors peelAlias: letter-led, ≤12 chars), then
+// optional same-line metadata. The `as` capture is what makes a quoted name +
+// alias parse — `"Web App" as web` — which the bare-name path got for free by
+// sweeping the alias into the lazy name group and peeling it later, but the
+// quoted path could not reach past the closing quote.
 const COMPONENT_RE =
-  /^(?:"([^"]+)"|([a-zA-Z_][\w -]*?))\s*((?:\|.*)|(?:[a-zA-Z_]\w*\s*:.*))?$/;
+  /^(?:"(?<qname>[^"]+)"|(?<uname>[a-zA-Z_][\w -]*?))(?:\s+as\s+(?<alias>[A-Za-z][A-Za-z0-9_]{0,11}))?\s*(?<meta>(?:\|.*)|(?:[a-zA-Z_]\w*\s*:.*))?$/;
 
 // Legacy pipe metadata: | key: value  or  | k1: v1, k2: v2  (comma-separated).
 // Kept for transitional back-compat extraction; new same-line metadata
@@ -302,6 +306,11 @@ export function parseInfra(content: string): ParsedInfra {
   let currentGroup: Writable<InfraGroup> | null = null;
   let currentTagGroup: Writable<InfraTagGroup> | null = null;
   let baseIndent = 0; // indent of the current component line
+  // The `infra [Title]` declaration is only legal on the first content line.
+  // parseFirstLine() must run ONCE, there — otherwise a later bare node line
+  // whose name is a chart-type keyword (e.g. an edge-block header `timeline`)
+  // is mis-read as a nested chart declaration and the parse aborts.
+  let firstLineConsumed = false;
 
   function finishCurrentNode() {
     if (!currentNode) return;
@@ -310,7 +319,12 @@ export function parseInfra(content: string): ParsedInfra {
     if (existing) {
       const incomingDisplay = displayName(currentNode.label);
       const existingDisplay = displayName(existing.label);
-      if (incomingDisplay !== existingDisplay) {
+      // A bare reference line that is a declared alias of `existing` (e.g. an
+      // edge-block header `web` for a node `"Web App" as web`) is an intentional
+      // pointer, not a near-duplicate name — don't flag it as a case/whitespace
+      // typo. Genuine collisions (no matching alias) still warn.
+      const isAliasRef = nameAliasMap.get(currentNode.label) === key;
+      if (incomingDisplay !== existingDisplay && !isAliasRef) {
         result.diagnostics.push(
           makeDgmoError(
             currentNode.lineNumber,
@@ -400,20 +414,25 @@ export function parseInfra(content: string): ParsedInfra {
         finishCurrentNode();
       }
 
-      // First line: `infra [Title]` or legacy `chart: infra`
-      const firstLineResult = parseFirstLine(trimmed);
-      if (firstLineResult) {
-        if (firstLineResult.chartType !== 'infra') {
-          setError(
-            lineNumber,
-            `Expected chart type 'infra', got '${firstLineResult.chartType}'`
-          );
-        }
-        if (firstLineResult.title) {
-          result.title = firstLineResult.title;
-          result.titleLineNumber = lineNumber;
+      // First line: `infra [Title]` or legacy `chart: infra` — only ever
+      // attempted on the first content line (see firstLineConsumed). A node or
+      // alias named like a chart type elsewhere is a normal node, not a redecl.
+      if (!firstLineConsumed) {
+        firstLineConsumed = true;
+        const firstLineResult = parseFirstLine(trimmed);
+        if (firstLineResult) {
+          if (firstLineResult.chartType !== 'infra') {
+            setError(
+              lineNumber,
+              `Expected chart type 'infra', got '${firstLineResult.chartType}'`
+            );
+          }
+          if (firstLineResult.title) {
+            result.title = firstLineResult.title;
+            result.titleLineNumber = lineNumber;
+          }
+          continue;
         }
-        continue;
       }
 
       // direction-tb — bare boolean to switch to top-to-bottom (default is LR)
@@ -496,18 +515,26 @@ export function parseInfra(content: string): ParsedInfra {
         finishCurrentNode();
         finishCurrentTagGroup();
 
-        const rawName = (compMatch[1] ?? compMatch[2] ?? '').trim();
+        const { qname, uname, alias: asAlias, meta } = compMatch.groups!;
+        const rawName = (qname ?? uname ?? '').trim();
         const peeled = peelInfraDecorations(rawName, lineNumber);
         const name = peeled.label;
-        const rest = compMatch[3] || '';
+        // Explicit `as` capture wins; fall back to an alias the peeler split out
+        // of a bare name (and the quoted-literal `"Foo as bar"` legacy case).
+        const alias = asAlias ?? peeled.alias;
+        const rest = meta ?? '';
         const { tags } = extractPipeMetadata(rest);
         warnUnknownMetaKeys(
           tags,
           withTagAliases(INFRA_REGISTRY, tagAliasSet),
           (msg) => warn(lineNumber, msg)
         );
-        const id = nodeId(name);
-        if (peeled.alias) nameAliasMap.set(peeled.alias, id);
+        // A bare reference line may be an alias for an already-declared node
+        // (its label-slug differs from the alias, e.g. "Web App" as web). Resolve
+        // through the alias map first so an edge-source/reference merges into
+        // that node instead of spawning a duplicate stub.
+        const id = nameAliasMap.get(name) ?? nodeId(name);
+        if (alias) nameAliasMap.set(alias, id);
         const isEdge = EDGE_NODE_NAMES.has(id.toLowerCase());
 
         currentNode = {
@@ -609,18 +636,24 @@ export function parseInfra(content: string): ParsedInfra {
       const compMatch = trimmed.match(COMPONENT_RE);
       if (compMatch) {
         finishCurrentTagGroup();
-        const rawName = (compMatch[1] ?? compMatch[2] ?? '').trim();
+        const { qname, uname, alias: asAlias, meta } = compMatch.groups!;
+        const rawName = (qname ?? uname ?? '').trim();
         const peeled = peelInfraDecorations(rawName, lineNumber);
         const name = peeled.label;
-        const rest = compMatch[3] || '';
+        const alias = asAlias ?? peeled.alias;
+        const rest = meta ?? '';
         const { tags: nodeTags } = extractPipeMetadata(rest);
         warnUnknownMetaKeys(
           nodeTags,
           withTagAliases(INFRA_REGISTRY, tagAliasSet),
           (msg) => warn(lineNumber, msg)
         );
-        const id = nodeId(name);
-        if (peeled.alias) nameAliasMap.set(peeled.alias, id);
+        // A bare reference line may be an alias for an already-declared node
+        // (its label-slug differs from the alias, e.g. "Web App" as web). Resolve
+        // through the alias map first so an edge-source/reference merges into
+        // that node instead of spawning a duplicate stub.
+        const id = nameAliasMap.get(name) ?? nodeId(name);
+        if (alias) nameAliasMap.set(alias, id);
         // Cascade group metadata into node tags; node-level metadata overrides
         const tags: Record<string, string> = currentGroup.metadata
           ? { ...currentGroup.metadata, ...nodeTags }
@@ -859,6 +892,18 @@ export function parseInfra(content: string): ParsedInfra {
           continue;
         }
 
+        // Indented tag assignment — `t: Edge` on its own line, the indented twin
+        // of same-line `Name t: Edge`. A tag alias is neither a behavior property
+        // nor 'description', so without this it falls through to the unknown-key
+        // path and is mis-collected as description text, silently dropping the
+        // node's tier. currentNode.tags is the same object held in
+        // nodeMutableTags, so a direct assign is enough.
+        if (currentNode && tagAliasSet.has(normalizeName(key))) {
+          const mut = nodeMutableTags.get(currentNode.id);
+          if (mut) mut[tagAttrKey(key)] = rawVal;
+          continue;
+        }
+
         // Unknown keys: decide between property typo warning vs description collection.
         // Heuristic: if the key looks like a plausible property (alphanumeric-hyphen, close
         // match to a known key, or the value looks numeric/percentage), warn as typo.
@@ -947,18 +992,24 @@ export function parseInfra(content: string): ParsedInfra {
 
       const compMatch = trimmed.match(COMPONENT_RE);
       if (compMatch) {
-        const rawName = (compMatch[1] ?? compMatch[2] ?? '').trim();
+        const { qname, uname, alias: asAlias, meta } = compMatch.groups!;
+        const rawName = (qname ?? uname ?? '').trim();
         const peeled = peelInfraDecorations(rawName, lineNumber);
         const name = peeled.label;
-        const rest = compMatch[3] || '';
+        const alias = asAlias ?? peeled.alias;
+        const rest = meta ?? '';
         const { tags: nodeTags } = extractPipeMetadata(rest);
         warnUnknownMetaKeys(
           nodeTags,
           withTagAliases(INFRA_REGISTRY, tagAliasSet),
           (msg) => warn(lineNumber, msg)
         );
-        const id = nodeId(name);
-        if (peeled.alias) nameAliasMap.set(peeled.alias, id);
+        // A bare reference line may be an alias for an already-declared node
+        // (its label-slug differs from the alias, e.g. "Web App" as web). Resolve
+        // through the alias map first so an edge-source/reference merges into
+        // that node instead of spawning a duplicate stub.
+        const id = nameAliasMap.get(name) ?? nodeId(name);
+        if (alias) nameAliasMap.set(alias, id);
         const tags: Record<string, string> = currentGroup.metadata
           ? { ...currentGroup.metadata, ...nodeTags }
           : nodeTags;
@@ -986,18 +1037,24 @@ export function parseInfra(content: string): ParsedInfra {
         finishCurrentTagGroup();
         currentGroup = null;
 
-        const rawName = (compMatch[1] ?? compMatch[2] ?? '').trim();
+        const { qname, uname, alias: asAlias, meta } = compMatch.groups!;
+        const rawName = (qname ?? uname ?? '').trim();
         const peeled = peelInfraDecorations(rawName, lineNumber);
         const name = peeled.label;
-        const rest = compMatch[3] || '';
+        const alias = asAlias ?? peeled.alias;
+        const rest = meta ?? '';
         const { tags } = extractPipeMetadata(rest);
         warnUnknownMetaKeys(
           tags,
           withTagAliases(INFRA_REGISTRY, tagAliasSet),
           (msg) => warn(lineNumber, msg)
         );
-        const id = nodeId(name);
-        if (peeled.alias) nameAliasMap.set(peeled.alias, id);
+        // A bare reference line may be an alias for an already-declared node
+        // (its label-slug differs from the alias, e.g. "Web App" as web). Resolve
+        // through the alias map first so an edge-source/reference merges into
+        // that node instead of spawning a duplicate stub.
+        const id = nameAliasMap.get(name) ?? nodeId(name);
+        if (alias) nameAliasMap.set(alias, id);
 
         currentNode = {
           id,

package/src/map/dimensions.ts

@@ -32,6 +32,13 @@ const TITLE_GAP = 16;
 //                       width:100% in a narrow note column stays sane.
 const ASPECT_MAX = 3.0;
 const ASPECT_MIN = 0.9;
+// Deliberate vertical boost for GLOBAL (whole-world) extents only. An honest
+// whole-world projection is ~2.4:1, which reads as a flat letterbox band. We emit
+// a canvas this fraction taller and let the global stretch-fill (layout.ts) fill
+// the extra height — the projected land stretches ~12% taller while POI radii and
+// label fonts (applied in the renderer, not here) stay un-squashed. US, regional,
+// and non-global extents are untouched (they keep their true projected aspect).
+const GLOBAL_HEIGHT_BOOST = 1.12;
 // Minimum px of actual map area (below the chrome band) — keeps a short canvas
 // (very wide extent) from being crowded out by the title/caption.
 const MIN_MAP_BAND = 200;
@@ -96,11 +103,21 @@ export function mapExportDimensions(
     Number.isFinite(aspectOverride) &&
     aspectOverride > 0;
   const raw = useOverride ? aspectOverride : mapContentAspect(resolved, data);
+  // Whole-world extents get the vertical boost (a taller canvas the global
+  // stretch-fill then fills). `fitIsGlobal` is the SAME classification the layout
+  // uses to decide stretch-fill vs contain, so the two always agree. The override
+  // path (app WYSIWYG) and non-global extents pass through at their true aspect.
+  const isGlobal =
+    !useOverride && buildMapProjection(resolved, data).fitIsGlobal;
+  // The target the renderer should hit BEFORE the pathological clamp: the boosted
+  // aspect for global views, the raw aspect otherwise. preferContain compares the
+  // clamp against THIS (not raw) so the deliberate boost never trips the letterbox.
+  const target = isGlobal ? raw / GLOBAL_HEIGHT_BOOST : raw;
   // The override is the user's on-screen aspect — honour it as-is (no clamp);
   // only the intrinsic path guards against pathological extents.
   const clamped = useOverride
     ? raw
-    : Math.max(ASPECT_MIN, Math.min(ASPECT_MAX, raw));
+    : Math.max(ASPECT_MIN, Math.min(ASPECT_MAX, target));
   const width = baseWidth;
   let height = Math.round(width / clamped);
 
@@ -128,6 +145,6 @@ export function mapExportDimensions(
   // contain-fit (letterbox) rather than stretch-distort. The WYSIWYG override is
   // exempt: it stretch-fills (mirroring the preview pane) unless the MIN_MAP_BAND
   // floor had to grow the canvas off-aspect.
-  const preferContain = useOverride ? floored : clamped !== raw || floored;
+  const preferContain = useOverride ? floored : clamped !== target || floored;
   return { width, height, preferContain };
 }

package/src/map/layout.ts

@@ -442,6 +442,10 @@ export interface MapLayoutLeg {
    *  (§24B.6). Omitted when the leg carries no tag. */
   readonly tags?: Readonly<Record<string, string>>;
   readonly label?: string;
+  /** The leg's numeric weight (the `value:` metadata) when present and positive.
+   *  Drives {@link width}, but kept here verbatim so the renderer can surface it
+   *  on hover (a `<title>` tooltip) — the width alone is lossy. */
+  readonly value?: number;
   readonly labelX?: number;
   readonly labelY?: number;
   /** Text colour for the label — contrast-picked against the background fill the
@@ -3027,13 +3031,15 @@ export function layoutMap(
         leg.label !== undefined
           ? labelOnFill(fillAt(bow.labelX, bow.labelY))
           : undefined;
+      const routeVal = Number(leg.value);
       legs.push({
         d: legPath(a, b, bow.curved, bow.offset),
-        width: routeWidthFor(Number(leg.value)),
+        width: routeWidthFor(routeVal),
         color: lineColor(leg.tags) ?? mix(palette.text, palette.bg, 72),
         arrow: true,
         fromId: leg.fromId,
         toId: leg.toId,
+        ...(Number.isFinite(routeVal) && routeVal > 0 && { value: routeVal }),
         ...(Object.keys(leg.tags).length > 0 && { tags: leg.tags }),
         lineNumber: leg.lineNumber,
         ...(leg.label !== undefined && {
@@ -3087,6 +3093,7 @@ export function layoutMap(
         e.label !== undefined
           ? labelOnFill(fillAt(bow.labelX, bow.labelY))
           : undefined;
+      const edgeVal = Number(e.meta['value']);
       legs.push({
         d: legPath(a, b, bow.curved, bow.offset),
         width: widthFor(e),
@@ -3094,6 +3101,7 @@ export function layoutMap(
         arrow: e.directed,
         fromId: e.fromId,
         toId: e.toId,
+        ...(Number.isFinite(edgeVal) && edgeVal > 0 && { value: edgeVal }),
         ...(Object.keys(e.tags).length > 0 && { tags: e.tags }),
         lineNumber: e.lineNumber,
         ...(e.label !== undefined && {
@@ -3436,6 +3444,49 @@ export function layoutMap(
     const SHORT_HOP_MAX = Math.max(46, Math.min(width, height) * 0.11);
     const STEP = 4; // px probe granularity walking out of the region
     const HOP_GAP = 9; // px clearance between region edge and chip
+    // How OPEN is the space a chip projects into? Measured on the chip's OUTWARD
+    // hemisphere (the side facing away from its region): cast a fan of rays and
+    // return the distance to the nearest land or canvas edge. A chip wedged in a
+    // crowded inlet (the Gulf of Mexico, hemmed by Florida + the Caribbean)
+    // scores low; one sitting in open water (the empty Pacific off Mexico's west
+    // coast) saturates the cap. Callout scoring MAXIMISES this, using leader
+    // length only as a tie-break — so a region leaders toward the open sea, not
+    // into whichever coast happens to be the shortest hop away. We only probe the
+    // outward hemisphere because the inward side always hits the region's own
+    // fill immediately (the chip hugs its border), which would flatten every spot.
+    const CLEAR_STEP = 6; // px granularity of the openness probe
+    const CLEAR_MAX = SHORT_HOP_MAX * 3; // saturation — beyond this it's "open"
+    const CLEAR_TOL = CLEAR_STEP; // openness within a probe step counts as a tie
+    const clearanceAt = (
+      px: number,
+      py: number,
+      ox: number, // outward unit dir (away from the region)
+      oy: number
+    ): number => {
+      const baseAng = Math.atan2(oy, ox);
+      let minClear = CLEAR_MAX;
+      // 5 rays spanning the outward hemisphere (baseAng ± 90° in 45° steps).
+      for (let k = -2; k <= 2; k++) {
+        const a = baseAng + (k * Math.PI) / 4;
+        const rx = Math.cos(a);
+        const ry = Math.sin(a);
+        let d = CLEAR_STEP;
+        for (; d <= CLEAR_MAX; d += CLEAR_STEP) {
+          const qx = px + rx * d;
+          const qy = py + ry * d;
+          if (
+            qx < FIT_PAD ||
+            qy < topPad ||
+            qx > width - FIT_PAD ||
+            qy > height - FIT_PAD
+          )
+            break; // ran into the frame — that edge bounds the openness
+          if (fillAt(qx, qy) !== water) break; // hit land of any kind
+        }
+        if (d < minClear) minClear = d;
+      }
+      return minClear;
+    };
     // Try to seat `name`(+`value`) as a short-hop chip for a region centred at
     // (cx,cy) on fill `fill`. Returns the placement (chip rect + leader) or null.
     const tryShortHopCallout = (
@@ -3455,11 +3506,19 @@ export function layoutMap(
     } | null => {
       const chipW = stackW(name, value, font);
       const chipH = stackH(value !== undefined, font);
+      // Unit vectors — 4 cardinals + 4 diagonals. Diagonals matter: open water
+      // often sits off-axis (Mexico's empty sea is WSW), and a pure-cardinal
+      // scheme can only aim due-N/S/E/W. Magnitude 1 keeps each walk step = STEP px.
+      const D = Math.SQRT1_2; // 0.7071…
       const dirs: Array<[number, number]> = [
-        [0, -1], // north (over Canada)
-        [0, 1], // south (over Mexico / Gulf)
-        [1, 0], // east (Atlantic)
-        [-1, 0], // west (Pacific)
+        [0, -1], // north
+        [0, 1], // south
+        [1, 0], // east
+        [-1, 0], // west
+        [D, -D], // NE
+        [D, D], // SE
+        [-D, -D], // NW
+        [-D, D], // SW
       ];
       let best: {
         x: number;
@@ -3467,6 +3526,7 @@ export function layoutMap(
         rect: LabelRect;
         leader: [number, number, number, number];
         len: number;
+        clear: number;
       } | null = null;
       for (const [dx, dy] of dirs) {
         // Walk from the centroid outward until we leave the region's own fill —
@@ -3533,13 +3593,23 @@ export function layoutMap(
           )
         )
           continue;
-        if (best === null || len < best.len)
+        // Prefer the MOST OPEN spot; fall back to the shortest leader only when
+        // two candidates are about equally open (e.g. several open-water spots
+        // that all saturate the clearance cap). This is what redirects a label
+        // away from a cramped-but-close coast toward the empty sea.
+        const clear = clearanceAt(ccx, ccy, dx, dy);
+        const better =
+          best === null ||
+          clear > best.clear + CLEAR_TOL ||
+          (clear >= best.clear - CLEAR_TOL && len < best.len);
+        if (better)
           best = {
             x: ccx,
             y: ccy,
             rect,
             leader: [cx, cy, innerX, innerY],
             len,
+            clear,
           };
       }
       return best
@@ -4599,6 +4669,20 @@ export function layoutMap(
       const nx = -dy / len;
       const ny = dx / len; // unit normal to the chord
       const perp = labelH + 2;
+      // A label rides ON its line by default (off=0 first) — a hairline under
+      // the text reads fine and looks intentional. But a HEAVY weighted leg
+      // (value→width up to W_MAX) draws a thick dark stroke, and text centred on
+      // it is unreadable (dark-on-dark, no contrast). For those, lead with a
+      // perpendicular hop that clears the stroke's half-width + the label's own
+      // half-height + a gap, so the text sits just BESIDE the line on open
+      // ground (both sides tried; the first clean one — typically the open-water
+      // side — wins). Thin legs keep the ride-on default untouched.
+      const stroke = lg.width ?? W_MIN;
+      const clearW = stroke / 2 + labelH / 2 + 3;
+      const offList =
+        stroke >= 4
+          ? [clearW, -clearW, clearW + perp, -(clearW + perp), 0]
+          : [0, perp, -perp, 2 * perp, -2 * perp];
       // Walk the ACTUAL DRAWN PATH, not the chord: parse the leg's `d` (the
       // trimmed `M…Q…` arc or `M…L…` line) and sample the curve at each t, so a
       // label rides its own bowed line instead of floating at the chord midpoint
@@ -4627,7 +4711,7 @@ export function layoutMap(
       // hop — growing — so a label on a SHORT leg between two close dots (where
       // every on-line slot straddles an endpoint) can still escape above or below.
       const candidates: Array<[number, number]> = [];
-      for (const off of [0, perp, -perp, 2 * perp, -2 * perp])
+      for (const off of offList)
         for (const t of T_LIST) {
           const [bx, by] = pointAt(t);
           candidates.push([bx + nx * off, by + ny * off - 4]);

package/src/map/parser.ts

@@ -186,8 +186,8 @@ export function parseMap(content: string, palette?: PaletteColors): ParsedMap {
     }
     // (1a) Indented child of an open route → a leg (an edge from the prev stop).
     if (open.route && indent > open.route.indent) {
-      const leg = parseLeg(trimmed, lineNumber, open.route.route.style);
-      (open.route.route.legs as MapRouteLeg[]).push(leg);
+      const leg = parseLeg(trimmed, lineNumber);
+      if (leg) (open.route.route.legs as MapRouteLeg[]).push(leg);
       continue;
     }
     // (1b) Indented child of an open POI → hub edge or extra metadata.
@@ -217,6 +217,18 @@ export function parseMap(content: string, palette?: PaletteColors): ParsedMap {
         Object.assign(open.poi.poi.meta as Record<string, string>, split.meta);
         continue;
       }
+      // A named child line with no arrow is a hub edge missing its glyph (the
+      // POI-hub mirror of a malformed route leg). Error here rather than letting
+      // it fall through and be silently reinterpreted as a top-level region.
+      if (split.name) {
+        const src =
+          open.poi.poi.alias ?? poiName(open.poi.poi.pos) ?? 'the poi';
+        pushError(
+          lineNumber,
+          `Malformed hub edge: "${trimmed}" — an indented line under a poi is an edge from "${src}" and needs an arrow glyph (\`-> dest\`, \`~> dest\`, or labeled \`-label-> dest\`). For a standalone place, declare it at the top level. (§24B.5)`
+        );
+        continue;
+      }
       // not a recognized child → fall through after closing the POI
     }
 
@@ -510,17 +522,20 @@ export function parseMap(content: string, palette?: PaletteColors): ParsedMap {
     const { tags, meta } = partitionMeta(split.meta, tagGroupNames());
     const originLabel = meta['label'];
     const originValue = meta['value'];
-    // Leg shape comes only from `style: arc` / arrow style (surface parsing
-    // removed — a leg no longer bows just because it crosses water).
-    const style: 'straight' | 'arc' =
-      meta['style'] === 'arc' ? 'arc' : 'straight';
+    // `style: arc` on the route header was removed (§24B.6): leg shape comes
+    // solely from each leg's own arrow glyph (`-…->` straight, `~…~>` arc).
+    if (meta['style'] !== undefined) {
+      pushError(
+        line,
+        'route header no longer takes `style:` — set leg shape with the arrow glyph instead (`~…~>` for an arc leg, `-…->` for a straight one). (§24B.6)'
+      );
+    }
     const route: Writable<MapRoute> = {
       origin: pos,
       ...(split.alias !== undefined && { originAlias: split.alias }),
       ...(originLabel !== undefined && { originLabel }),
       ...(originValue !== undefined && { originValue }),
       originTags: tags,
-      style,
       legs: [],
       lineNumber: line,
     };
@@ -528,25 +543,34 @@ export function parseMap(content: string, palette?: PaletteColors): ParsedMap {
     open.route = { route, indent };
   }
 
-  /** Parse one route body line into a leg: `[-label->] <destination> [keys]`.
-   *  The arrow (if any) gives the leg label + shape; `value:` is leg thickness;
-   *  a tag colours the LINE (§24B.6); `label:`/`as` name the destination stop.
-   *  Bare `<dest>` = plain leg. */
-  function parseLeg(
-    trimmed: string,
-    line: number,
-    headerStyle: 'straight' | 'arc'
-  ): MapRouteLeg {
-    let arrowStyle: 'straight' | 'arc' = 'straight';
-    let label: string | undefined;
-    let rest = trimmed;
+  /** Parse one route body line into a leg: `<arrow> <destination> [keys]`. The
+   *  arrow is REQUIRED and gives the leg label + shape (`-…->` straight, `~…~>`
+   *  arc); `value:` is leg thickness; a tag colours the LINE (§24B.6);
+   *  `label:`/`as` name the destination stop. A bare destination with no arrow,
+   *  or an undirected (`--`/`~~`) glyph, is a parse error — a voyage always flows
+   *  from the previous stop to the next (§24B.6). */
+  function parseLeg(trimmed: string, line: number): MapRouteLeg | null {
     const m = trimmed.match(LEG_ARROW_RE);
-    if (m) {
-      const arr = classifyArrow(m[1]!, line);
-      arrowStyle = arr.style;
-      label = arr.label;
-      rest = m[2]!;
+    if (!m) {
+      pushError(
+        line,
+        `Malformed route leg: "${trimmed}" — a leg needs an arrow glyph (\`-> dest\`, \`~> dest\`, or labeled \`-label-> dest\` / \`~label~> dest\`). (§24B.6)`
+      );
+      return null;
+    }
+    const arr = classifyArrow(m[1]!, line);
+    // A route leg is always directional (prev stop → next), so the undirected
+    // `--`/`~~` glyphs are meaningless here (they stay valid on free-form edges).
+    if (!arr.directed) {
+      pushError(
+        line,
+        `A route leg is directional — "${trimmed}" uses an undirected glyph; use \`-> \` (straight) or \`~> \` (arc). (§24B.6)`
+      );
+      return null;
     }
+    const arrowStyle: 'straight' | 'arc' = arr.style;
+    const label: string | undefined = arr.label;
+    const rest = m[2]!;
     const split = splitNameAndMeta(
       rest,
       registry(),
@@ -562,13 +586,11 @@ export function parseMap(content: string, palette?: PaletteColors): ParsedMap {
     const { tags, meta } = partitionMeta(split.meta, tagGroupNames());
     const value = meta['value'];
     const destLabel = meta['label'];
-    // Leg shape comes only from the arrow style or the route header `style: arc`
-    // (surface parsing removed — no implied bow).
-    const style: 'straight' | 'arc' =
-      arrowStyle === 'arc' || headerStyle === 'arc' ? 'arc' : 'straight';
+    // Leg shape comes solely from the leg's own arrow glyph (§24B.6) — the route
+    // header `style:` was removed.
     return {
       ...(label !== undefined && { label }),
-      style,
+      style: arrowStyle,
       ...(value !== undefined && { value }),
       dest: pos,
       ...(split.alias !== undefined && { destAlias: split.alias }),

package/src/map/renderer.ts

@@ -973,6 +973,16 @@ export function renderMap(
     // A 0-width invisible leg path is hard to hit; pointer-events on the visible
     // stroke is enough for the line widths legs use.
     wireSync(p, leg.lineNumber);
+    // Surface the leg's weight on hover. A native <title> gives a tooltip on the
+    // visible stroke in every surface (app, exported SVG, Obsidian, web) with no
+    // viewer code; `data-value` is also emitted so an app overlay can style it
+    // later. The label (when any) prefixes the number for context ("fiber: 28").
+    if (leg.value !== undefined) {
+      p.attr('data-value', leg.value);
+      p.append('title').text(
+        leg.label !== undefined ? `${leg.label}: ${leg.value}` : `${leg.value}`
+      );
+    }
     if (arrowTri) {
       // Filled arrowhead at the true endpoint — a flat triangle whose base sits
       // where the trimmed stroke ends, so the line meets it cleanly with no

package/src/map/types.ts

@@ -110,12 +110,13 @@ export interface MapPoi {
 }
 
 /** 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. A tag on the leg line colours
- *  the LINE (§24B.6); `label:`/`as` still name the DESTINATION stop. */
+ *  the indented edge arrow idiom (same as sitemap) — in-arrow text = leg label,
+ *  `value:` = leg thickness, the arrow glyph = shape (`-…->` straight, `~…~>`
+ *  arc). A tag on the leg line colours the LINE (§24B.6); `label:`/`as` still
+ *  name the DESTINATION stop. The arrow is required — a bare destination errors. */
 export interface MapRouteLeg {
   readonly label?: string; // in-arrow leg label
-  readonly style: 'straight' | 'arc';
+  readonly style: 'straight' | 'arc'; // from the leg's own arrow glyph
   readonly value?: string; // leg thickness (numeric string, like an edge)
   readonly dest: PoiPos;
   readonly destAlias?: string;
@@ -126,16 +127,16 @@ export interface MapRouteLeg {
   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. */
+/** An ordered, auto-numbered route (§24B.6): `route <origin>` + a sequence of
+ *  indented arrow legs, each continuing from the previous stop. Leg shape is
+ *  per-leg (the arrow glyph) — there is no header-level shape option. Repeat the
+ *  origin as a leg's destination to close a loop. */
 export interface MapRoute {
   readonly origin: PoiPos;
   readonly originAlias?: string;
   readonly originLabel?: string;
   readonly originValue?: string; // header value → origin marker size
   readonly originTags: Readonly<Record<string, string>>;
-  readonly style: 'straight' | 'arc'; // header default leg shape
   readonly legs: readonly MapRouteLeg[];
   readonly lineNumber: number;
 }