@miragon/wardley-dsl 0.2.0 → 0.2.1

package/dist/index.js

@@ -16,7 +16,65 @@ function parseCoords(line) {
 function stripCoords(line) {
   return line.replace(COORDS_RE, " ");
 }
-var PAREN_RE = /\(([^)]*)\)/g;
+function splitAtCoords(line) {
+  const m = COORDS_RE.exec(line);
+  if (!m) return null;
+  const a = Number(m[1]);
+  const b = Number(m[2]);
+  if (Number.isNaN(a) || Number.isNaN(b)) return null;
+  return {
+    name: line.slice(0, m.index).trim(),
+    coords: { a, b },
+    suffix: line.slice(m.index + m[0].length)
+  };
+}
+var COORDS4_RE = /\[\s*([-\d.]+)\s*,\s*([-\d.]+)\s*,\s*([-\d.]+)\s*,\s*([-\d.]+)\s*\]/;
+function parseCoords4(line) {
+  const m = COORDS4_RE.exec(line);
+  if (!m) return null;
+  const vals = [m[1], m[2], m[3], m[4]].map(Number);
+  if (vals.some(Number.isNaN)) return null;
+  return { a: vals[0], b: vals[1], c: vals[2], d: vals[3] };
+}
+var MULTI_COORDS_RE = /\[\s{0,8}(\[[^[\]]*\](?:\s{0,8},\s{0,8}\[[^[\]]*\])+)\s{0,8}\]/;
+function parseMultiCoords(line) {
+  const m = MULTI_COORDS_RE.exec(line);
+  if (!m) return null;
+  const tuples = [];
+  const inner = /\[\s{0,8}([-\d.]+)\s{0,8},\s{0,8}([-\d.]+)\s{0,8}\]/g;
+  let t;
+  while (t = inner.exec(m[1])) {
+    const a = Number(t[1]);
+    const b = Number(t[2]);
+    if (!Number.isNaN(a) && !Number.isNaN(b)) tuples.push({ a, b });
+  }
+  if (!tuples.length) return null;
+  return { tuples, rest: line.replace(MULTI_COORDS_RE, " ") };
+}
+function splitLineComment(line) {
+  let inQuote = false;
+  for (let i = 0; i < line.length - 1; i++) {
+    const ch = line[i];
+    if (ch === "'") inQuote = !inQuote;
+    else if (!inQuote && ch === "/" && line[i + 1] === "/" && line[i - 1] !== ":") {
+      return { code: line.slice(0, i), comment: line.slice(i) };
+    }
+  }
+  return { code: line, comment: null };
+}
+function indexOfOutsideQuotes(line, needle) {
+  let inQuote = false;
+  for (let i = 0; i + needle.length <= line.length; i++) {
+    const ch = line[i];
+    if (ch === "'") {
+      inQuote = !inQuote;
+      continue;
+    }
+    if (!inQuote && line.startsWith(needle, i)) return i;
+  }
+  return -1;
+}
+var PAREN_RE = /\(([^()]*)\)/g;
 var METHODS = /* @__PURE__ */ new Set(["build", "buy", "outsource"]);
 function parseDecorators(line) {
   const dec = {};
@@ -53,17 +111,47 @@ function parseLabelOffset(line) {
   if (Number.isNaN(dx) || Number.isNaN(dy)) return { labelOffset: null, rest };
   return { labelOffset: { dx, dy }, rest };
 }
+var URL_REF_RE = /\burl\s{0,8}\(([^()]*)\)/i;
+function parseUrlRef(line) {
+  const m = URL_REF_RE.exec(line);
+  if (!m) return { urlRef: null, rest: line };
+  return { urlRef: m[1].trim() || null, rest: line.replace(URL_REF_RE, " ") };
+}
 function keywordOf(line) {
   const m = /^\s*([A-Za-z][\w-]*)/.exec(line);
   return m ? m[1].toLowerCase() : "";
 }
 function slug(label) {
-  return label.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "") || "x";
+  return label.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_/, "").replace(/_$/, "") || "x";
 }
 
 // src/parser.ts
-var DEP_RE = /^(.+?)\s*->\s*(.+)$/;
-var FLOW_RE = /^(.+?)\s*\+(?:'([^']*)')?(<>|>|<)\s*(.+)$/;
+function splitDependency(core) {
+  const arrow = core.indexOf("->");
+  if (arrow <= 0) return null;
+  const left = core.slice(0, arrow).trim();
+  const right = core.slice(arrow + 2).trim();
+  return left && right ? { left, right } : null;
+}
+function splitFlow(core) {
+  for (let i = 1; i < core.length; i++) {
+    if (core[i] !== "+") continue;
+    let j = i + 1;
+    let value;
+    if (core[j] === "'") {
+      const end = core.indexOf("'", j + 1);
+      if (end < 0) continue;
+      value = core.slice(j + 1, end);
+      j = end + 1;
+    }
+    const op = core.startsWith("<>", j) ? "<>" : core[j] === ">" || core[j] === "<" ? core[j] : null;
+    if (!op) continue;
+    const left = core.slice(0, i).trim();
+    const right = core.slice(j + op.length).trim();
+    if (left && right) return { left, right, op, ...value ? { value } : {} };
+  }
+  return null;
+}
 var NON_LINK_KEYWORDS = /* @__PURE__ */ new Set([
   "title",
   "style",
@@ -72,7 +160,8 @@ var NON_LINK_KEYWORDS = /* @__PURE__ */ new Set([
   "y-axis",
   "annotations",
   "annotation",
-  "evolve"
+  "evolve",
+  "line"
 ]);
 var KNOWN_STYLES = /* @__PURE__ */ new Set(["wardley", "handwritten", "colour", "dark"]);
 function compact(obj) {
@@ -92,6 +181,10 @@ var IdAllocator = class {
   }
 };
 function parseDSL(text) {
+  return parseDSLWithDiagnostics(text).map;
+}
+function parseDSLWithDiagnostics(text) {
+  const diagnostics = [];
   const ids = new IdAllocator();
   const nameToId = /* @__PURE__ */ new Map();
   const elements = [];
@@ -99,49 +192,130 @@ function parseDSL(text) {
   const pendingLinks = [];
   const pendingEvolve = [];
   const pendingPipeline = [];
+  const pendingMethod = [];
   let config = { title: "Untitled Map" };
   let annoCounter = 0;
+  let inBlockComment = false;
+  const urlDefs = /* @__PURE__ */ new Map();
+  const pendingUrlRefs = [];
+  let lastPipeline = null;
+  let blockPipeline = null;
   const register = (name, id) => {
     if (!nameToId.has(name)) nameToId.set(name, id);
   };
-  const pushLink = (line, raw) => {
+  let lineNo = 0;
+  let currentLine = "";
+  const pushLink = (line) => {
     const semi = line.indexOf(";");
     const core = semi >= 0 ? line.slice(0, semi).trim() : line;
     const linkLabel = semi >= 0 ? line.slice(semi + 1).trim() : "";
-    const dep = DEP_RE.exec(core);
-    const flow = dep ? null : FLOW_RE.exec(core);
+    const dep = splitDependency(core);
+    const flow = dep ? null : splitFlow(core);
     if (dep) {
       pendingLinks.push({
-        left: dep[1].trim(),
-        right: dep[2].trim(),
+        left: dep.left,
+        right: dep.right,
         kind: "dependency",
         ...linkLabel ? { label: linkLabel } : {},
-        raw
+        raw: line,
+        lineNo
       });
       return true;
     }
     if (flow) {
-      const op = flow[3];
       pendingLinks.push({
-        left: flow[1].trim(),
-        right: flow[4].trim(),
+        left: flow.left,
+        right: flow.right,
         kind: "flow",
-        bidirectional: op === "<>",
-        reverse: op === "<",
-        ...flow[2] ? { flowValue: flow[2] } : {},
+        bidirectional: flow.op === "<>",
+        reverse: flow.op === "<",
+        ...flow.value ? { flowValue: flow.value } : {},
         ...linkLabel ? { label: linkLabel } : {},
-        raw
+        raw: line,
+        lineNo
       });
       return true;
     }
     return false;
   };
-  for (const raw of text.split(/\r?\n/)) {
-    const line = raw.trim();
+  const diag = (message, atLine = lineNo, text_ = currentLine) => diagnostics.push({ line: atLine, message, text: text_ });
+  const failed = (l) => {
+    rawPassthrough.push(l);
+    diag("Line could not be interpreted (kept losslessly in rawPassthrough)");
+  };
+  const clampDiag = (n) => {
+    if (n < 0 || n > 1) diag(`Coordinate ${n} is outside [0,1] and was clamped`);
+    return n < 0 ? 0 : n > 1 ? 1 : n;
+  };
+  const pos = (visibility, evolution) => ({
+    visibility: clampDiag(visibility),
+    evolution: clampDiag(evolution)
+  });
+  const sourceLines = text.split(/\r?\n/);
+  for (let i = 0; i < sourceLines.length; i++) {
+    const raw = sourceLines[i];
+    lineNo = i + 1;
+    currentLine = raw.trim();
+    let working = raw;
+    if (inBlockComment) {
+      const close = working.indexOf("*/");
+      if (close < 0) {
+        rawPassthrough.push(raw);
+        continue;
+      }
+      rawPassthrough.push(working.slice(0, close + 2));
+      working = working.slice(close + 2);
+      inBlockComment = false;
+    }
+    if (keywordOf(working) !== "url") {
+      let open = indexOfOutsideQuotes(working, "/*");
+      while (open >= 0) {
+        const close = working.indexOf("*/", open + 2);
+        if (close < 0) {
+          rawPassthrough.push(working.slice(open));
+          working = working.slice(0, open);
+          inBlockComment = true;
+          break;
+        }
+        rawPassthrough.push(working.slice(open, close + 2));
+        working = `${working.slice(0, open)} ${working.slice(close + 2)}`;
+        open = indexOfOutsideQuotes(working, "/*");
+      }
+      const { code, comment } = splitLineComment(working);
+      if (comment !== null) rawPassthrough.push(comment);
+      working = code;
+    }
+    const line = working.trim();
     if (!line) continue;
+    if (blockPipeline) {
+      if (line === "}") {
+        blockPipeline = null;
+        continue;
+      }
+      const childKw = keywordOf(line);
+      if (childKw === "component") {
+        const child = parseBlockChild(line.slice(childKw.length).trim());
+        if (child) {
+          blockPipeline.children.push(child);
+          continue;
+        }
+      }
+      rawPassthrough.push(line);
+      continue;
+    }
+    if (line.startsWith("{")) {
+      if (lastPipeline) {
+        blockPipeline = lastPipeline;
+        lastPipeline = null;
+        continue;
+      }
+      rawPassthrough.push(line);
+      continue;
+    }
     const kw = keywordOf(line);
     const after = line.slice(kw.length).trim();
-    if (!NON_LINK_KEYWORDS.has(kw) && !parseCoords(line) && pushLink(line, raw)) {
+    if (kw !== "pipeline") lastPipeline = null;
+    if (!NON_LINK_KEYWORDS.has(kw) && !parseCoords(line) && pushLink(line)) {
       continue;
     }
     switch (kw) {
@@ -151,7 +325,7 @@ function parseDSL(text) {
       case "anchor": {
         const node = parseNode(after);
         if (!node) {
-          rawPassthrough.push(raw);
+          failed(line);
           break;
         }
         const id = ids.alloc("anchor", node.name);
@@ -159,8 +333,9 @@ function parseDSL(text) {
           id,
           elementType: "anchor",
           label: node.name,
-          position: { visibility: node.coords.a, evolution: node.coords.b },
-          labelOffset: node.labelOffset
+          position: pos(node.coords.a, node.coords.b),
+          labelOffset: node.labelOffset,
+          color: node.color
         });
         elements.push(anchor);
         register(node.name, id);
@@ -171,7 +346,7 @@ function parseDSL(text) {
       case "ecosystem": {
         const node = parseNode(after);
         if (!node) {
-          rawPassthrough.push(raw);
+          failed(line);
           break;
         }
         const decorators = mergeLegacy(kw, node.decorators);
@@ -180,11 +355,13 @@ function parseDSL(text) {
           id,
           elementType: "component",
           label: node.name,
-          position: { visibility: node.coords.a, evolution: node.coords.b },
+          position: pos(node.coords.a, node.coords.b),
           labelOffset: node.labelOffset,
-          decorators: Object.keys(decorators).length ? decorators : void 0
+          decorators: Object.keys(decorators).length ? decorators : void 0,
+          color: node.color
         });
         elements.push(component);
+        if (node.urlRef) pendingUrlRefs.push({ index: elements.length - 1, ref: node.urlRef });
         register(node.name, id);
         break;
       }
@@ -193,7 +370,7 @@ function parseDSL(text) {
         const coords = parseCoords(rest);
         const textPart = stripCoords(rest).trim().replace(/\\n/g, "\n");
         if (!coords) {
-          rawPassthrough.push(raw);
+          failed(line);
           break;
         }
         const id = ids.alloc("note", textPart || "note");
@@ -201,41 +378,60 @@ function parseDSL(text) {
           id,
           elementType: "note",
           label: textPart,
-          position: { visibility: coords.a, evolution: coords.b },
+          position: pos(coords.a, coords.b),
           color
         });
         elements.push(note);
         break;
       }
       case "pipeline": {
-        const coords = parseCoords(after);
-        const name = stripCoords(after).trim();
-        if (!coords || !name) {
-          rawPassthrough.push(raw);
+        let body = after;
+        let opensBlock = false;
+        if (body.endsWith("{")) {
+          opensBlock = true;
+          body = body.slice(0, -1).trim();
+        }
+        const col = parseColor(body);
+        const yMatch = /\(\s{0,8}y\s{1,8}([\d.]+)\s{0,8}\)/.exec(col.rest);
+        const bodyRest = yMatch ? col.rest.replace(yMatch[0], " ") : col.rest;
+        const coords = parseCoords(bodyRest);
+        const name = stripCoords(bodyRest).trim();
+        if (!name) {
+          failed(line);
           break;
         }
-        pendingPipeline.push({ name, start: coords.a, end: coords.b, raw });
+        const pending = {
+          name,
+          ...coords ? { start: coords.a, end: coords.b } : {},
+          ...yMatch ? { visibility: clamp01(Number(yMatch[1])) } : {},
+          ...col.color ? { color: col.color } : {},
+          raw: line,
+          children: []
+        };
+        pendingPipeline.push(pending);
+        if (opensBlock) blockPipeline = pending;
+        else lastPipeline = pending;
         break;
       }
       case "evolve": {
         const ev = parseEvolve(after);
         if (!ev) {
-          rawPassthrough.push(raw);
+          failed(line);
           break;
         }
-        pendingEvolve.push({ ...ev, raw });
+        pendingEvolve.push({ ...ev, target: clampDiag(ev.target), raw: line, lineNo });
         break;
       }
       case "style": {
         const s = after.toLowerCase();
         if (KNOWN_STYLES.has(s)) config = { ...config, style: s };
-        else rawPassthrough.push(raw);
+        else failed(line);
         break;
       }
       case "size": {
         const coords = parseCoords(after);
         if (coords) config = { ...config, size: { width: coords.a, height: coords.b } };
-        else rawPassthrough.push(raw);
+        else failed(line);
         break;
       }
       case "evolution": {
@@ -247,8 +443,13 @@ function parseDSL(text) {
       }
       case "y-axis": {
         const parts = after.split("->").map((s) => s.trim()).filter(Boolean);
-        if (parts.length) config = { ...config, yAxisLabel: parts[0] };
-        else rawPassthrough.push(raw);
+        if (parts.length) {
+          config = {
+            ...config,
+            yAxisLabel: parts[0],
+            ...parts.length >= 3 ? { yAxisEndLabels: [parts[1], parts[2]] } : {}
+          };
+        } else failed(line);
         break;
       }
       case "annotations": {
@@ -256,61 +457,122 @@ function parseDSL(text) {
         if (coords) {
           config = {
             ...config,
-            annotationsBoxPosition: { visibility: coords.a, evolution: coords.b }
+            annotationsBoxPosition: pos(coords.a, coords.b)
           };
         } else rawPassthrough.push(raw);
         break;
       }
       case "annotation": {
-        const coords = parseCoords(after);
-        if (!coords) {
-          rawPassthrough.push(raw);
-          break;
-        }
         const numMatch = /^\s*(\d+)/.exec(after);
         const number = numMatch ? Number(numMatch[1]) : ++annoCounter;
-        const text2 = stripCoords(after.replace(/^\s*\d+\s*/, "")).trim();
-        const position = { visibility: coords.a, evolution: coords.b };
+        const colA = parseColor(after.replace(/^\s*\d+\s*/, ""));
+        const afterNum = colA.rest;
+        const multi = parseMultiCoords(afterNum);
+        let positions;
+        let text2;
+        if (multi) {
+          positions = multi.tuples.map((t) => pos(t.a, t.b));
+          text2 = multi.rest.trim();
+        } else {
+          const coords = parseCoords(afterNum);
+          if (!coords) {
+            rawPassthrough.push(line);
+            break;
+          }
+          positions = [pos(coords.a, coords.b)];
+          text2 = stripCoords(afterNum).trim();
+        }
         const annotation = {
           id: ids.alloc("anno", String(number)),
           elementType: "annotation",
           label: text2,
-          position,
+          position: positions[0],
           number,
-          positions: [position],
-          text: text2
+          positions,
+          text: text2,
+          ...colA.color ? { color: colA.color } : {}
         };
         elements.push(annotation);
         break;
       }
+      case "line": {
+        const col = parseColor(after);
+        const multi = parseMultiCoords(col.rest);
+        if (!multi || multi.tuples.length < 2) {
+          failed(line);
+          break;
+        }
+        const flags = multi.rest.toLowerCase();
+        const strokeStyle = flags.includes("(dashed)") ? "dashed" : flags.includes("(dotted)") ? "dotted" : void 0;
+        const points = multi.tuples.map((t) => pos(t.a, t.b));
+        const drawing = {
+          id: ids.alloc("draw", "line"),
+          elementType: "drawing",
+          label: "",
+          position: points[0],
+          points,
+          ...flags.includes("(closed)") ? { closed: true } : {},
+          ...strokeStyle ? { strokeStyle } : {},
+          ...col.color ? { color: col.color } : {}
+        };
+        elements.push(drawing);
+        break;
+      }
       case "pioneers":
       case "settlers":
       case "townplanners": {
-        const coords = parseCoords(after);
-        const trailing = stripCoords(after).trim().split(/\s+/).filter(Boolean);
-        const width = Number(trailing[0]);
-        const height = Number(trailing[1]);
-        if (!coords || Number.isNaN(width) || Number.isNaN(height)) {
-          rawPassthrough.push(raw);
+        const col = parseColor(after);
+        const four = parseCoords4(col.rest);
+        if (!four) {
+          failed(line);
           break;
         }
-        const attitude = {
-          id: ids.alloc("attitude", kw),
-          elementType: "attitude",
-          kind: kw,
-          label: "",
-          position: { visibility: coords.a, evolution: coords.b },
-          width,
-          height
-        };
-        elements.push(attitude);
+        elements.push(
+          makeAttitude(ids, kw, four.a, four.b, four.c, four.d, col.color)
+        );
+        break;
+      }
+      case "url": {
+        const open = after.indexOf("[");
+        const close = after.lastIndexOf("]");
+        const name = open > 0 ? after.slice(0, open).trim() : "";
+        const address = open > 0 && close > open ? after.slice(open + 1, close).trim() : "";
+        if (!name || !address || after.slice(close + 1).trim() !== "") {
+          failed(line);
+          break;
+        }
+        urlDefs.set(name, address);
+        break;
+      }
+      case "build":
+      case "buy":
+      case "outsource": {
+        const node = parseNode(after);
+        if (node) {
+          const id = ids.alloc("cmp", node.name);
+          const component = compact({
+            id,
+            elementType: "component",
+            label: node.name,
+            position: pos(node.coords.a, node.coords.b),
+            labelOffset: node.labelOffset,
+            decorators: { ...node.decorators, method: kw },
+            color: node.color
+          });
+          elements.push(component);
+          register(node.name, id);
+        } else if (after.trim()) {
+          pendingMethod.push({ name: after.trim(), method: kw, raw: line, lineNo });
+        } else {
+          rawPassthrough.push(line);
+        }
         break;
       }
       case "accelerator":
       case "deaccelerator": {
         const node = parseNode(after);
         if (!node) {
-          rawPassthrough.push(raw);
+          failed(line);
           break;
         }
         const id = ids.alloc("accel", node.name);
@@ -319,7 +581,8 @@ function parseDSL(text) {
           elementType: "accelerator",
           direction: kw === "deaccelerator" ? "deaccelerate" : "accelerate",
           label: node.name,
-          position: { visibility: node.coords.a, evolution: node.coords.b }
+          position: pos(node.coords.a, node.coords.b),
+          ...node.color ? { color: node.color } : {}
         };
         elements.push(accelerator);
         register(node.name, id);
@@ -328,7 +591,7 @@ function parseDSL(text) {
       case "submap": {
         const node = parseNode(after);
         if (!node) {
-          rawPassthrough.push(raw);
+          failed(line);
           break;
         }
         const id = ids.alloc("submap", node.name);
@@ -336,46 +599,107 @@ function parseDSL(text) {
           id,
           elementType: "submap",
           label: node.name,
-          position: { visibility: node.coords.a, evolution: node.coords.b }
+          position: pos(node.coords.a, node.coords.b),
+          ...node.color ? { color: node.color } : {}
         };
         elements.push(submap);
+        if (node.urlRef) pendingUrlRefs.push({ index: elements.length - 1, ref: node.urlRef });
         register(node.name, id);
         break;
       }
       default: {
-        if (!pushLink(line, raw)) rawPassthrough.push(raw);
+        if (!pushLink(line)) rawPassthrough.push(line);
       }
     }
   }
+  for (const p of pendingPipeline) {
+    const refId = nameToId.get(p.name);
+    const ref = elements.find((e) => e.id === refId);
+    const visibility = p.visibility ?? (ref ? ref.position.visibility : 0.5);
+    const id = ids.alloc("pipeline", p.name);
+    register(p.name, id);
+    const childIds = [];
+    const childElements = [];
+    for (const c of p.children) {
+      const cid = ids.alloc("cmp", c.name);
+      childElements.push(
+        compact({
+          id: cid,
+          elementType: "component",
+          label: c.name,
+          position: { visibility, evolution: clamp01(c.maturity) },
+          labelOffset: c.labelOffset,
+          decorators: Object.keys(c.decorators).length ? c.decorators : void 0,
+          pipelineId: id,
+          color: c.color
+        })
+      );
+      register(c.name, cid);
+      childIds.push(cid);
+    }
+    let start = p.start ?? (p.children.length ? Math.min(...p.children.map((c) => c.maturity)) : NaN);
+    let end = p.end ?? (p.children.length ? Math.max(...p.children.map((c) => c.maturity)) : NaN);
+    if (Number.isNaN(start) || Number.isNaN(end)) {
+      rawPassthrough.push(p.raw);
+      continue;
+    }
+    start = clamp01(start);
+    end = clamp01(end);
+    if (end <= start) end = Math.min(1, start + 0.05);
+    const pipeline = {
+      id,
+      elementType: "pipeline",
+      label: p.name,
+      position: { visibility, evolution: (start + end) / 2 },
+      evolutionStart: start,
+      evolutionEnd: end,
+      childIds,
+      ...p.color ? { color: p.color } : {}
+    };
+    elements.push(pipeline, ...childElements);
+  }
   for (const ev of pendingEvolve) {
     const id = nameToId.get(ev.name);
     const idx = elements.findIndex((e) => e.id === id);
     if (idx < 0 || elements[idx].elementType !== "component") {
       rawPassthrough.push(ev.raw);
+      diag(`evolve: component "${ev.name}" not found`, ev.lineNo, ev.raw);
       continue;
     }
     const movement = compact({
       targetEvolution: ev.target,
       newLabel: ev.newLabel,
-      method: ev.method
+      method: ev.method,
+      labelOffset: ev.labelOffset
     });
     elements[idx] = { ...elements[idx], movement };
   }
-  for (const p of pendingPipeline) {
-    const refId = nameToId.get(p.name);
-    const ref = elements.find((e) => e.id === refId);
-    const visibility = ref ? ref.position.visibility : 0.5;
-    const id = ids.alloc("pipeline", p.name);
-    const pipeline = {
-      id,
-      elementType: "pipeline",
-      label: p.name,
-      position: { visibility, evolution: (p.start + p.end) / 2 },
-      evolutionStart: p.start,
-      evolutionEnd: p.end,
-      childIds: []
-    };
-    elements.push(pipeline);
+  for (const pm of pendingMethod) {
+    const id = nameToId.get(pm.name);
+    const idx = elements.findIndex((e) => e.id === id);
+    const el = idx >= 0 ? elements[idx] : void 0;
+    if (!el || el.elementType !== "component") {
+      rawPassthrough.push(pm.raw);
+      diag(`${pm.method}: component "${pm.name}" not found`, pm.lineNo, pm.raw);
+      continue;
+    }
+    elements[idx] = { ...el, decorators: { ...el.decorators, method: pm.method } };
+  }
+  const usedUrlDefs = /* @__PURE__ */ new Set();
+  for (const { index, ref } of pendingUrlRefs) {
+    const fromDef = urlDefs.get(ref);
+    if (fromDef) usedUrlDefs.add(ref);
+    const address = fromDef ?? (/^[a-z][\w+.-]*:\/\//i.test(ref) ? ref : void 0);
+    if (!address) continue;
+    const el = elements[index];
+    if (el.elementType === "component") {
+      elements[index] = { ...el, url: address };
+    } else if (el.elementType === "submap") {
+      elements[index] = { ...el, urlRef: address };
+    }
+  }
+  for (const [name, address] of urlDefs) {
+    if (!usedUrlDefs.has(name)) rawPassthrough.push(`url ${name} [${address}]`);
   }
   let depN = 0;
   let flowN = 0;
@@ -385,6 +709,11 @@ function parseDSL(text) {
     const toId = nameToId.get(link.right);
     if (!fromId || !toId) {
       rawPassthrough.push(link.raw);
+      diag(
+        `Link: ${!fromId ? `"${link.left}"` : `"${link.right}"`} not found`,
+        link.lineNo,
+        link.raw
+      );
       continue;
     }
     if (link.kind === "dependency") {
@@ -419,22 +748,64 @@ function parseDSL(text) {
     edges,
     rawPassthrough: rawPassthrough.length ? rawPassthrough : void 0
   });
-  return validateMap(map);
+  return { map: validateMap(map), diagnostics };
 }
 function parseNode(after) {
-  const lo = parseLabelOffset(after);
+  const split = splitAtCoords(after);
+  if (!split || !split.name) return null;
+  const col = parseColor(split.suffix);
+  const url = parseUrlRef(col.rest);
+  const lo = parseLabelOffset(url.rest);
   const dec = parseDecorators(lo.rest);
-  const coords = parseCoords(dec.rest);
-  if (!coords) return null;
-  const name = stripCoords(dec.rest).trim();
+  return compact({
+    name: split.name,
+    coords: split.coords,
+    decorators: dec.decorators,
+    labelOffset: lo.labelOffset ?? void 0,
+    urlRef: url.urlRef ?? void 0,
+    color: col.color ?? void 0
+  });
+}
+function clamp01(n) {
+  return n < 0 ? 0 : n > 1 ? 1 : n;
+}
+var SINGLE_COORD_RE = /\[\s*([-\d.]+)\s*\]/;
+function parseBlockChild(after) {
+  const m = SINGLE_COORD_RE.exec(after);
+  if (!m) return null;
+  const maturity = Number(m[1]);
+  if (Number.isNaN(maturity)) return null;
+  const name = after.slice(0, m.index).trim();
   if (!name) return null;
+  const suffix = after.slice(m.index + m[0].length);
+  const col = parseColor(suffix);
+  const lo = parseLabelOffset(col.rest);
+  const dec = parseDecorators(lo.rest);
   return compact({
     name,
-    coords,
+    maturity,
     decorators: dec.decorators,
-    labelOffset: lo.labelOffset ?? void 0
+    labelOffset: lo.labelOffset ?? void 0,
+    color: col.color ?? void 0
   });
 }
+function makeAttitude(ids, kind, v1, m1, v2, m2, color) {
+  return {
+    id: ids.alloc("attitude", kind),
+    elementType: "attitude",
+    kind,
+    label: "",
+    ...color ? { color } : {},
+    position: {
+      visibility: clamp01(Math.max(v1, v2)),
+      evolution: clamp01(Math.min(m1, m2))
+    },
+    corner2: {
+      visibility: clamp01(Math.min(v1, v2)),
+      evolution: clamp01(Math.max(m1, m2))
+    }
+  };
+}
 function mergeLegacy(kw, dec) {
   const merged = { ...dec };
   if (kw === "market") merged["market"] = true;
@@ -442,7 +813,8 @@ function mergeLegacy(kw, dec) {
   return compact(merged);
 }
 function parseEvolve(after) {
-  const dec = parseDecorators(after);
+  const lo = parseLabelOffset(after);
+  const dec = parseDecorators(lo.rest);
   const tokens = dec.rest.trim().split(/\s+/);
   if (tokens.length < 2) return null;
   const last = tokens[tokens.length - 1];
@@ -457,11 +829,17 @@ function parseEvolve(after) {
     name,
     newLabel: newLabel || void 0,
     target,
-    method: dec.decorators.method
+    method: dec.decorators.method,
+    labelOffset: lo.labelOffset ?? void 0
   });
 }
 
 // src/serializer.ts
+function urlOf(el) {
+  if (el.elementType === "component") return el.url;
+  if (el.elementType === "submap") return el.urlRef;
+  return void 0;
+}
 function r(n) {
   return String(Math.round(n * 1e3) / 1e3);
 }
@@ -486,6 +864,9 @@ function uniqueNames(map) {
 function offsetSuffix(lo) {
   return lo ? ` label [${r(lo.dx)}, ${r(lo.dy)}]` : "";
 }
+function colorSuffix(el) {
+  return el.color ? ` (color ${el.color})` : "";
+}
 function decoratorSuffix(dec) {
   if (!dec) return "";
   const paren = [];
@@ -506,22 +887,75 @@ function serializeDSL(map) {
   if (map.config.size)
     lines.push(`size [${r(map.config.size.width)}, ${r(map.config.size.height)}]`);
   if (map.config.evolutionLabels) lines.push(`evolution ${map.config.evolutionLabels.join("->")}`);
-  if (map.config.yAxisLabel) lines.push(`y-axis ${map.config.yAxisLabel}`);
+  if (map.config.yAxisLabel) {
+    const ends = map.config.yAxisEndLabels;
+    lines.push(`y-axis ${map.config.yAxisLabel}${ends ? `->${ends[0]}->${ends[1]}` : ""}`);
+  }
   if (map.config.annotationsBoxPosition) {
     const b = map.config.annotationsBoxPosition;
     lines.push(`annotations [${r(b.visibility)}, ${r(b.evolution)}]`);
   }
+  const urlDefNames = /* @__PURE__ */ new Map();
+  for (const el of map.elements) {
+    const address = urlOf(el);
+    if (!address) continue;
+    const defName = `${nameOf(el)} URL`;
+    urlDefNames.set(el.id, defName);
+    lines.push(`url ${defName} [${address}]`);
+  }
+  const urlSuffix = (el) => {
+    const def = urlDefNames.get(el.id);
+    return def ? ` url(${def})` : "";
+  };
+  const pipelineIds = new Set(
+    map.elements.filter((e) => e.elementType === "pipeline").map((e) => e.id)
+  );
+  const childrenByPipeline = /* @__PURE__ */ new Map();
+  for (const el of map.elements) {
+    if (el.elementType !== "component" || !el.pipelineId || !pipelineIds.has(el.pipelineId)) {
+      continue;
+    }
+    const list = childrenByPipeline.get(el.pipelineId) ?? [];
+    list.push(el);
+    childrenByPipeline.set(el.pipelineId, list);
+  }
+  const isPipelineChild = (el) => el.elementType === "component" && !!el.pipelineId && pipelineIds.has(el.pipelineId);
   const evolveLines = [];
+  const componentVisByLabel = /* @__PURE__ */ new Map();
+  for (const el of map.elements) {
+    if (el.elementType === "component" && !componentVisByLabel.has(el.label)) {
+      componentVisByLabel.set(el.label, el.position.visibility);
+    }
+  }
+  const pipelineYSuffix = (el) => {
+    if (el.elementType !== "pipeline") return "";
+    const derived = componentVisByLabel.get(el.label) ?? 0.5;
+    return Math.abs(el.position.visibility - derived) > 5e-4 ? ` (y ${r(el.position.visibility)})` : "";
+  };
   for (const el of map.elements) {
-    lines.push(elementLine(el, nameOf(el)));
     if (el.elementType === "component" && el.movement) {
       evolveLines.push(evolveLine(el, nameOf(el)));
     }
+    if (isPipelineChild(el)) continue;
+    lines.push(elementLine(el, nameOf(el)) + pipelineYSuffix(el) + urlSuffix(el));
+    if (el.elementType === "pipeline") {
+      const kids = childrenByPipeline.get(el.id) ?? [];
+      if (kids.length) {
+        lines.push("{");
+        for (const k of kids) {
+          lines.push(
+            `  component ${nameOf(k)} [${r(k.position.evolution)}]${decoratorSuffix(k.decorators)}${colorSuffix(k)}${offsetSuffix(k.labelOffset)}`
+          );
+        }
+        lines.push("}");
+      }
+    }
   }
   for (const line of evolveLines) lines.push(line);
+  const labelsById = new Map(map.elements.map((el) => [el.id, el.label]));
   for (const edge of map.edges) {
-    const from = names.get(edge.from) ?? edge.from;
-    const to = names.get(edge.to) ?? edge.to;
+    const from = names.get(edge.from) ?? labelsById.get(edge.from) ?? edge.from;
+    const to = names.get(edge.to) ?? labelsById.get(edge.to) ?? edge.to;
     const annotation = edge.label ? `; ${edge.label}` : "";
     if (edge.edgeType === "dependency") {
       lines.push(`${from} -> ${to}${annotation}`);
@@ -545,30 +979,38 @@ function elementLine(el, name) {
   const p = el.position;
   switch (el.elementType) {
     case "anchor":
-      return `anchor ${name} [${r(p.visibility)}, ${r(p.evolution)}]${offsetSuffix(el.labelOffset)}`;
+      return `anchor ${name} [${r(p.visibility)}, ${r(p.evolution)}]${colorSuffix(el)}${offsetSuffix(el.labelOffset)}`;
     case "component":
-      return `component ${name} [${r(p.visibility)}, ${r(p.evolution)}]${decoratorSuffix(el.decorators)}${offsetSuffix(el.labelOffset)}`;
+      return `component ${name} [${r(p.visibility)}, ${r(p.evolution)}]${decoratorSuffix(el.decorators)}${colorSuffix(el)}${offsetSuffix(el.labelOffset)}`;
     case "note":
-      return `note ${name.replace(/\n/g, "\\n")} [${r(p.visibility)}, ${r(p.evolution)}]${el.color ? ` (color ${el.color})` : ""}`;
+      return `note ${name.replace(/\n/g, "\\n")} [${r(p.visibility)}, ${r(p.evolution)}]${colorSuffix(el)}`;
     case "pipeline":
-      return `pipeline ${name} [${r(el.evolutionStart)}, ${r(el.evolutionEnd)}]`;
+      return `pipeline ${name} [${r(el.evolutionStart)}, ${r(el.evolutionEnd)}]${colorSuffix(el)}`;
     case "submap":
-      return `submap ${name} [${r(p.visibility)}, ${r(p.evolution)}]`;
-    case "annotation":
-      return `annotation ${el.number} [${r(p.visibility)}, ${r(p.evolution)}] ${el.text}`;
+      return `submap ${name} [${r(p.visibility)}, ${r(p.evolution)}]${colorSuffix(el)}`;
+    case "annotation": {
+      const pos = el.positions.length > 1 ? `[${el.positions.map((q) => `[${r(q.visibility)}, ${r(q.evolution)}]`).join(", ")}]` : `[${r(p.visibility)}, ${r(p.evolution)}]`;
+      return `annotation ${el.number} ${pos}${colorSuffix(el)} ${el.text}`;
+    }
     case "accelerator":
-      return `${el.direction === "deaccelerate" ? "deaccelerator" : "accelerator"} ${name} [${r(p.visibility)}, ${r(p.evolution)}]`;
+      return `${el.direction === "deaccelerate" ? "deaccelerator" : "accelerator"} ${name} [${r(p.visibility)}, ${r(p.evolution)}]${colorSuffix(el)}`;
     case "attitude":
-      return `${el.kind} [${r(p.visibility)}, ${r(p.evolution)}] ${r(el.width)} ${r(el.height)}`;
+      return `${el.kind} [${r(p.visibility)}, ${r(p.evolution)}, ${r(el.corner2.visibility)}, ${r(el.corner2.evolution)}]${colorSuffix(el)}`;
+    case "drawing": {
+      const pts = el.points.map((q) => `[${r(q.visibility)}, ${r(q.evolution)}]`).join(", ");
+      const closed = el.closed ? " (closed)" : "";
+      const stroke = el.strokeStyle && el.strokeStyle !== "solid" ? ` (${el.strokeStyle})` : "";
+      return `line [${pts}]${closed}${stroke}${colorSuffix(el)}`;
+    }
   }
 }
 function evolveLine(el, name) {
   const mv = el.movement;
   const label = mv.newLabel ? `${name}->${mv.newLabel}` : name;
   const method = mv.method ? ` (${mv.method})` : "";
-  return `evolve ${label} ${r(mv.targetEvolution)}${method}`;
+  return `evolve ${label} ${r(mv.targetEvolution)}${method}${offsetSuffix(mv.labelOffset)}`;
 }
 
-export { keywordOf, parseCoords, parseDSL, parseDecorators, parseLabelOffset, serializeDSL, slug };
+export { keywordOf, parseCoords, parseDSL, parseDSLWithDiagnostics, parseDecorators, parseLabelOffset, serializeDSL, slug };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map