@miragon/wardley-dsl 0.5.1 → 0.5.3

package/dist/index.cjs

@@ -14,64 +14,165 @@ function parseCoords(line) {
   if (Number.isNaN(a) || Number.isNaN(b)) return null;
   return { a, b };
 }
-function stripCoords(line) {
-  return line.replace(COORDS_RE, " ");
-}
-function splitAtCoords(line) {
+function splitAtTuple(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)
+    before: line.slice(0, m.index).trim(),
+    tuple: m[0],
+    coords: Number.isNaN(a) || Number.isNaN(b) ? null : { a, b },
+    after: line.slice(m.index + m[0].length)
   };
 }
+function splitAtCoords(line) {
+  const split = splitAtTuple(line);
+  if (!split?.coords) return null;
+  return { name: split.before, coords: split.coords, suffix: split.after };
+}
 var COORDS4_RE = /\[\s*([-\d.]+)\s*,\s*([-\d.]+)\s*,\s*([-\d.]+)\s*,\s*([-\d.]+)\s*\]/;
-function parseCoords4(line) {
+function splitAtCoords4(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] };
+  return {
+    before: line.slice(0, m.index).trim(),
+    coords: { a: vals[0], b: vals[1], c: vals[2], d: vals[3] },
+    after: line.slice(m.index + m[0].length)
+  };
+}
+var TUPLE_LIST_RE = /\[\s{0,8}(\[[^[\]]*\](?:\s{0,8},\s{0,8}\[[^[\]]*\])*)\s{0,8}\]/;
+var LIST_ENTRY_RE = /\[[^[\]]*\]/g;
+var WHOLE_COORDS_RE = /^\[\s*([-\d.]+)\s*,\s*([-\d.]+)\s*\]$/;
+function readTupleList(line, list) {
+  const tuples = [];
+  const unreadable = [];
+  for (const [entry] of list[1].matchAll(LIST_ENTRY_RE)) {
+    const coords = WHOLE_COORDS_RE.exec(entry);
+    const a = Number(coords?.[1]);
+    const b = Number(coords?.[2]);
+    if (coords && !Number.isNaN(a) && !Number.isNaN(b)) tuples.push({ a, b });
+    else unreadable.push(entry);
+  }
+  return {
+    tuples,
+    unreadable,
+    before: line.slice(0, list.index).trim(),
+    after: line.slice(list.index + list[0].length)
+  };
 }
-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);
+  const list = TUPLE_LIST_RE.exec(line);
+  return list ? readTupleList(line, list) : null;
+}
+var FIRST_CHILD_TUPLE_RE = /\[\s*([-\d.]+)\s*(?:,\s*([-\d.]+)\s*)?\]/;
+function splitAtFirstChildTuple(line) {
+  const m = FIRST_CHILD_TUPLE_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;
+  return {
+    before: line.slice(0, m.index).trim(),
+    values: m[2] === void 0 ? [m[1]] : [m[1], m[2]],
+    after: line.slice(m.index + m[0].length)
+  };
+}
+function parsePositions(line) {
+  const single = COORDS_RE.exec(line);
+  const list = TUPLE_LIST_RE.exec(line);
+  if (list && (!single || list.index < single.index)) return readTupleList(line, list);
+  if (!single) return null;
+  const a = Number(single[1]);
+  const b = Number(single[2]);
+  const readable = !Number.isNaN(a) && !Number.isNaN(b);
+  return {
+    tuples: readable ? [{ a, b }] : [],
+    unreadable: readable ? [] : [single[0]],
+    before: line.slice(0, single.index).trim(),
+    after: line.slice(single.index + single[0].length)
+  };
+}
+function flowValueEnd(line, at) {
+  return line[at] === "'" && line[at - 1] === "+" ? line.indexOf("'", at + 1) : -1;
+}
+function rewriteOutsideFlowValues(text, rewrite) {
+  let rewritten = "";
+  let partStart = 0;
+  for (let i = 0; i < text.length; i++) {
+    const valueEnd = flowValueEnd(text, i);
+    if (valueEnd < 0) continue;
+    rewritten += rewrite(text.slice(partStart, i)) + text.slice(i, valueEnd + 1);
+    partStart = valueEnd + 1;
+    i = valueEnd;
+  }
+  return rewritten + rewrite(text.slice(partStart));
+}
+function indexOfLineComment(line) {
   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) };
-    }
+    const valueEnd = flowValueEnd(line, i);
+    if (valueEnd > 0) i = valueEnd;
+    else if (line[i] === "/" && line[i + 1] === "/" && line[i - 1] !== ":") return i;
   }
-  return { code: line, comment: null };
+  return -1;
 }
-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;
+function readUrlDefinition(after) {
+  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() !== "") return null;
+  return { name, address };
+}
+function isUrlDefinition(line) {
+  return keywordOf(line) === "url" && readUrlDefinition(line.trim().slice("url".length)) !== null;
+}
+var CommentStripper = class {
+  inBlockComment = false;
+  get insideBlockComment() {
+    return this.inBlockComment;
+  }
+  strip(raw) {
+    const comments = [];
+    let working = raw;
+    if (this.inBlockComment) {
+      const close = working.indexOf("*/");
+      if (close < 0) return { code: "", comments: [raw] };
+      comments.push(working.slice(0, close + 2));
+      working = working.slice(close + 2);
+      this.inBlockComment = false;
+    }
+    const code = isUrlDefinition(working) ? working : this.stripComments(working, comments);
+    return { code, comments };
+  }
+  /** Left to right, so a `/*` inside a `//` comment opens no block comment. */
+  stripComments(line, comments) {
+    let code = "";
+    let rest = line;
+    for (; ; ) {
+      const lineComment = indexOfLineComment(rest);
+      const open = indexOutsideFlowValues(rest, "/*");
+      if (lineComment >= 0 && (open < 0 || lineComment < open)) {
+        comments.push(rest.slice(lineComment));
+        return code + rest.slice(0, lineComment);
+      }
+      if (open < 0) return code + rest;
+      const close = rest.indexOf("*/", open + 2);
+      if (close < 0) {
+        comments.push(rest.slice(open));
+        this.inBlockComment = true;
+        return code + rest.slice(0, open);
+      }
+      comments.push(rest.slice(open, close + 2));
+      code += `${rest.slice(0, open)} `;
+      rest = rest.slice(close + 2);
     }
-    if (!inQuote && line.startsWith(needle, i)) return i;
+  }
+};
+function indexOutsideFlowValues(line, needle) {
+  for (let i = 0; i + needle.length <= line.length; i++) {
+    const valueEnd = flowValueEnd(line, i);
+    if (valueEnd > 0) i = valueEnd;
+    else if (line.startsWith(needle, i)) return i;
   }
   return -1;
 }
@@ -96,36 +197,168 @@ function parseDecorators(line) {
   });
   return { decorators: dec, rest };
 }
-var COLOR_RE = /\(\s*color\s+(#[0-9a-fA-F]{3,8}|[a-zA-Z][\w-]*)\s*\)/i;
-function parseColor(line) {
-  const m = COLOR_RE.exec(line);
-  if (!m || !m[1]) return { rest: line };
-  return { color: m[1], rest: line.replace(COLOR_RE, " ") };
+var COLOR_SOURCE = String.raw`\(\s*color\s+(#[0-9a-fA-F]{3,8}|[a-zA-Z][\w-]*)\s*\)`;
+var HEIGHT_SOURCE = String.raw`\(\s{0,8}y\s{1,8}([^\s()]+)\s{0,8}\)`;
+var LABEL_OFFSET_SOURCE = String.raw`label\s*\[\s*([-\d.]+)\s*,\s*([-\d.]+)\s*\]`;
+var COLOR_TOKEN_RE = new RegExp(COLOR_SOURCE, "iy");
+var HEIGHT_TOKEN_RE = new RegExp(HEIGHT_SOURCE, "y");
+var LABEL_TOKEN_RE = new RegExp(LABEL_OFFSET_SOURCE, "iy");
+var URL_TOKEN_RE = /url\s{0,8}\(([^()]*)\)/iy;
+var GROUP_TOKEN_RE = /\(([^()]*)\)/y;
+var INERTIA_TOKEN_RE = /inertia\b/iy;
+var WORD_TOKEN_RE = /\(?[^\s(]*/y;
+function matchAt(pattern, text, at) {
+  pattern.lastIndex = at;
+  return pattern.exec(text);
+}
+function groupItems(content, contentAt) {
+  const items = [];
+  let itemStart = 0;
+  for (const raw of content.split(",")) {
+    const leading = raw.length - raw.trimStart().length;
+    const text = raw.trim();
+    if (text) items.push({ at: contentAt + itemStart + leading, text });
+    itemStart += raw.length + 1;
+  }
+  return items;
+}
+function readSuffixToken(text, at) {
+  let m;
+  if (m = matchAt(COLOR_TOKEN_RE, text, at)) {
+    return { at, text: m[0], kind: "color", color: m[1] };
+  }
+  if (m = matchAt(HEIGHT_TOKEN_RE, text, at)) {
+    return { at, text: m[0], kind: "height", value: m[1] };
+  }
+  if (m = matchAt(LABEL_TOKEN_RE, text, at)) {
+    return { at, text: m[0], kind: "label", dx: m[1], dy: m[2] };
+  }
+  if (m = matchAt(URL_TOKEN_RE, text, at)) {
+    return { at, text: m[0], kind: "url", ref: m[1].trim() };
+  }
+  if (m = matchAt(GROUP_TOKEN_RE, text, at)) {
+    return { at, text: m[0], kind: "group", items: groupItems(m[1], at + 1) };
+  }
+  if (m = matchAt(INERTIA_TOKEN_RE, text, at)) return { at, text: m[0], kind: "inertia" };
+  return { at, text: matchAt(WORD_TOKEN_RE, text, at)[0], kind: "word" };
 }
-var LABEL_OFFSET_RE = /\blabel\s*\[\s*([-\d.]+)\s*,\s*([-\d.]+)\s*\]/i;
+function scanSuffix(text) {
+  const tokens = [];
+  let at = 0;
+  while (at < text.length) {
+    if (/\s/.test(text[at])) {
+      at++;
+      continue;
+    }
+    const token = readSuffixToken(text, at);
+    tokens.push(token);
+    at += token.text.length;
+  }
+  return tokens;
+}
+var WHOLE_COLOR_GROUP_RE = new RegExp(`^${COLOR_SOURCE}$`, "i");
+var WHOLE_HEIGHT_GROUP_RE = new RegExp(`^${HEIGHT_SOURCE}$`);
+function splitTrailingGroups(text, kinds) {
+  const groups = [];
+  let end = text.trimEnd().length;
+  while (text[end - 1] === ")") {
+    const open = text.lastIndexOf("(", end - 1);
+    const group = text.slice(Math.max(open, 0), end);
+    const wanted = kinds.color && WHOLE_COLOR_GROUP_RE.test(group) || kinds.height && WHOLE_HEIGHT_GROUP_RE.test(group);
+    if (open < 0 || !wanted) break;
+    groups.push(group);
+    end = open;
+    while (end > 0 && /\s/.test(text[end - 1])) end--;
+  }
+  return { rest: text.slice(0, end), groups: groups.reverse() };
+}
+function splitLeadingColor(text) {
+  const start = text.length - text.trimStart().length;
+  const m = matchAt(COLOR_TOKEN_RE, text, start);
+  if (!m) return { rest: text };
+  return { color: m[1], rest: text.slice(start + m[0].length) };
+}
+var MAX_UNCLAMPED_MAGNITUDE = 1e12;
+function isRoundTrippableNumber(value) {
+  return Number.isFinite(value) && Math.abs(value) <= MAX_UNCLAMPED_MAGNITUDE;
+}
+function readUnclampedNumber(text) {
+  const value = Number(text);
+  return isRoundTrippableNumber(value) ? value : null;
+}
+var LABEL_OFFSET_RE = new RegExp(String.raw`\b${LABEL_OFFSET_SOURCE}`, "i");
 function parseLabelOffset(line) {
   const m = LABEL_OFFSET_RE.exec(line);
   if (!m) return { labelOffset: null, rest: line };
-  const dx = Number(m[1]);
-  const dy = Number(m[2]);
+  const dx = readUnclampedNumber(m[1]);
+  const dy = readUnclampedNumber(m[2]);
   const rest = line.replace(LABEL_OFFSET_RE, " ");
-  if (Number.isNaN(dx) || Number.isNaN(dy)) return { labelOffset: null, rest };
+  if (dx === null || dy === null) return { labelOffset: null, rest, unreadable: m[0] };
   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, " ") };
-}
+var KEYWORD_RE = /^\s*([A-Za-z][\w-]*)(?![\w\p{L}\p{M}\p{N}-])/u;
 function keywordOf(line) {
-  const m = /^\s*([A-Za-z][\w-]*)/.exec(line);
+  const m = KEYWORD_RE.exec(line);
   return m ? m[1].toLowerCase() : "";
 }
 function slug(label) {
   return label.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_/, "").replace(/_$/, "") || "x";
 }
 
+// src/names.ts
+var NAMED_TYPES = /* @__PURE__ */ new Set([
+  "anchor",
+  "component",
+  "accelerator",
+  "submap"
+]);
+function defaultName(type) {
+  switch (type) {
+    case "anchor":
+      return "User";
+    case "accelerator":
+      return "Accelerator";
+    case "submap":
+      return "Submap";
+    case "pipeline":
+      return "Pipeline";
+    default:
+      return "Component";
+  }
+}
+function roundAsWritten(n) {
+  return Math.round(n * 1e3) / 1e3;
+}
+var DIVISION_SLASH = "\u2215";
+var FULLWIDTH_PLUS = "\uFF0B";
+var FULLWIDTH_LEFT_BRACE = "\uFF5B";
+function escapeCommentMarkers(text) {
+  return rewriteOutsideFlowValues(
+    text,
+    (part) => part.replace(/\/\*/g, `${DIVISION_SLASH}*`).replace(/(?<!:)\/\//g, DIVISION_SLASH.repeat(2))
+  );
+}
+function writtenText(text) {
+  return escapeCommentMarkers(text.replace(/\r?\n/g, " "));
+}
+function writtenNoteText(text) {
+  return escapeCommentMarkers(text).replace(/\r?\n/g, "\\n");
+}
+function writtenName(label, elementType) {
+  const name = label.replace(/\r?\n/g, " ").replace(/->/g, "\u2192").replace(/\+(?=['<>])/g, FULLWIDTH_PLUS).trim().replace(/^\{/, FULLWIDTH_LEFT_BRACE);
+  return escapeCommentMarkers(name) || defaultName(elementType);
+}
+var UniqueNames = class {
+  used = /* @__PURE__ */ new Set();
+  claim(base) {
+    let name = base;
+    let suffix = 2;
+    while (this.used.has(name)) name = `${base} ${suffix++}`;
+    this.used.add(name);
+    return name;
+  }
+};
+
 // src/parser.ts
 function splitDependency(core) {
   const arrow = core.indexOf("->");
@@ -153,7 +386,7 @@ function splitFlow(core) {
   }
   return null;
 }
-var NON_LINK_KEYWORDS = /* @__PURE__ */ new Set([
+var LINK_LIKE_STATEMENT_KEYWORDS = /* @__PURE__ */ new Set([
   "title",
   "style",
   "size",
@@ -164,12 +397,111 @@ var NON_LINK_KEYWORDS = /* @__PURE__ */ new Set([
   "evolve",
   "line"
 ]);
+var DECLARATION_KEYWORDS = /* @__PURE__ */ new Set([
+  "anchor",
+  "component",
+  "market",
+  "ecosystem",
+  "note",
+  "pioneers",
+  "settlers",
+  "townplanners",
+  "url",
+  "build",
+  "buy",
+  "outsource",
+  "accelerator",
+  "deaccelerator",
+  "submap"
+]);
 var KNOWN_STYLES = /* @__PURE__ */ new Set(["wardley", "handwritten", "colour", "dark"]);
 function compact(obj) {
   const out = {};
   for (const [k, v] of Object.entries(obj)) if (v !== void 0) out[k] = v;
   return out;
 }
+function linkCore(line) {
+  const semi = line.indexOf(";");
+  return semi >= 0 ? line.slice(0, semi) : line;
+}
+function readLink(line, lineNo, text) {
+  const semi = line.indexOf(";");
+  const core = (semi >= 0 ? line.slice(0, semi) : line).trim();
+  const label = semi >= 0 ? line.slice(semi + 1).trim() : "";
+  const common = { ...label ? { label } : {}, raw: line, lineNo, text };
+  const dependency = splitDependency(core);
+  if (dependency) return { ...dependency, kind: "dependency", ...common };
+  const flow = splitFlow(core);
+  if (!flow) return null;
+  return {
+    left: flow.left,
+    right: flow.right,
+    kind: "flow",
+    bidirectional: flow.op === "<>",
+    reverse: flow.op === "<",
+    ...flow.value ? { flowValue: flow.value } : {},
+    ...common
+  };
+}
+function couldBeStatement(line, keyword, after) {
+  return LINK_LIKE_STATEMENT_KEYWORDS.has(keyword) || DECLARATION_KEYWORDS.has(keyword) && parseCoords(line) !== null || keyword === "url" && readUrlDefinition(after) !== null;
+}
+function namesAsWritten(link) {
+  const keyword = keywordOf(link.left);
+  const nameAfterKeyword = link.left.slice(keyword.length).trim();
+  return {
+    left: [keyword, nameAfterKeyword].filter(Boolean).join(" "),
+    right: link.right.split("->").map((part) => part.trim()).join("->")
+  };
+}
+function leftNameIsDeclared(link, names) {
+  return names.has(link.left) || names.has(namesAsWritten(link).left);
+}
+function unknownStatementMessage(line) {
+  const core = linkCore(line);
+  if (/->|\+('[^']*')?(<>|>|<)/.test(core)) return "Link needs a name on both sides";
+  const flowValue = /\+'[^']*'/.exec(core);
+  if (flowValue) return `Flow ${flowValue[0]} has no direction \u2014 add ">", "<" or "<>"`;
+  return `Unknown statement "${line.split(/\s/)[0]}"`;
+}
+function buildEdges(links, idOfName, unresolved, labelOf) {
+  let dependencies = 0;
+  let flows = 0;
+  const edges = [];
+  for (const link of links) {
+    const fromId = idOfName(link.left) ?? idOfName(link.writtenNames?.left ?? link.left);
+    const toId = idOfName(link.right) ?? idOfName(link.writtenNames?.right ?? link.right);
+    if (!fromId || !toId) {
+      unresolved(link, fromId ? link.right : link.left);
+      continue;
+    }
+    if (link.kind === "dependency") {
+      edges.push(
+        compact({
+          id: `dep_${++dependencies}`,
+          edgeType: "dependency",
+          from: fromId,
+          to: toId,
+          label: labelOf(link)
+        })
+      );
+      continue;
+    }
+    const [from, to] = link.reverse ? [toId, fromId] : [fromId, toId];
+    edges.push(
+      compact({
+        id: `flow_${++flows}`,
+        edgeType: "flow",
+        from,
+        to,
+        bidirectional: link.bidirectional ? true : void 0,
+        flowValue: link.flowValue,
+        label: labelOf(link)
+      })
+    );
+  }
+  return edges;
+}
 var IdAllocator = class {
   used = /* @__PURE__ */ new Set();
   alloc(prefix, label) {
@@ -185,612 +517,1007 @@ function parseDSL(text) {
   return parseDSLWithDiagnostics(text).map;
 }
 function parseDSLWithDiagnostics(text) {
-  const diagnostics = [];
-  const ids = new IdAllocator();
-  const nameToId = /* @__PURE__ */ new Map();
-  const elements = [];
-  const rawPassthrough = [];
-  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);
-  };
-  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 = splitDependency(core);
-    const flow = dep ? null : splitFlow(core);
-    if (dep) {
-      pendingLinks.push({
-        left: dep.left,
-        right: dep.right,
-        kind: "dependency",
-        ...linkLabel ? { label: linkLabel } : {},
-        raw: line,
-        lineNo
-      });
+  const reading = new MapReader(/* @__PURE__ */ new Set()).read(text);
+  const needsDeclaredNames = reading.keywordLinks.some(
+    (link) => leftNameIsDeclared(link, reading.declaredNames)
+  );
+  return needsDeclaredNames ? new MapReader(reading.declaredNames).read(text).result : reading.result;
+}
+var MapReader = class {
+  constructor(linkNames) {
+    this.linkNames = linkNames;
+  }
+  linkNames;
+  diagnostics = [];
+  ids = new IdAllocator();
+  namesInUse = new UniqueNames();
+  /** The first element declared under a name wins it. */
+  idBySourceName = /* @__PURE__ */ new Map();
+  idByElementName = /* @__PURE__ */ new Map();
+  elements = [];
+  passthrough = [];
+  pendingLinks = [];
+  keywordLinks = [];
+  pendingEvolve = [];
+  pendingPipeline = [];
+  pendingMethod = [];
+  config = { title: "Untitled Map" };
+  lineThatSetConfig = /* @__PURE__ */ new Map();
+  unusedConfigLines = [];
+  annotationCounter = 0;
+  comments = new CommentStripper();
+  urlDefinitions = [];
+  pendingUrlRefs = [];
+  /** Candidate for a `{` block opening: a block binds only to the directly preceding pipeline line. */
+  lastPipeline = null;
+  blockPipeline = null;
+  blockOpening = { line: 0, text: "" };
+  lineNo = 0;
+  currentLine = "";
+  report = (message) => this.diag(message);
+  reportAt = (message, line, text) => this.diag(message, line, text);
+  diag(message, atLine = this.lineNo, text = this.currentLine) {
+    this.diagnostics.push({ line: atLine, message, text });
+  }
+  keepLine(statement, lineNo = this.lineNo, source = this.currentLine) {
+    this.passthrough.push({ text: statement, isComment: false, lineNo, source });
+  }
+  keep(statement, message) {
+    this.keepLine(statement);
+    this.diag(message);
+  }
+  /** For a line that looks like a known construct but cannot be parsed. */
+  failed(line) {
+    this.keep(line, "Line could not be interpreted (kept losslessly in rawPassthrough)");
+  }
+  // A reference binds to the name as written first, so `X 2` stays bound to an explicit "X 2" even
+  // when a duplicate "X" was renamed to "X 2"; the serializer then writes that reference by the
+  // element's new name, and the next parse binds it the same way.
+  idOfName(name) {
+    return this.idBySourceName.get(name) ?? this.idByElementName.get(name);
+  }
+  register(sourceName, elementName, id) {
+    if (!this.idBySourceName.has(sourceName)) this.idBySourceName.set(sourceName, id);
+    this.idByElementName.set(elementName, id);
+  }
+  setConfig(keyword, update) {
+    const earlier = this.lineThatSetConfig.get(keyword);
+    if (earlier !== void 0) {
+      this.diag(`Repeated "${keyword}" \u2014 replaces the one on line ${earlier}`);
+    }
+    this.lineThatSetConfig.set(keyword, this.lineNo);
+    this.config = update;
+  }
+  keepUnusedConfigLine(keyword, statement, reason) {
+    this.unusedConfigLines.push({
+      keyword,
+      reason,
+      index: this.passthrough.length,
+      line: this.lineNo,
+      text: this.currentLine
+    });
+    this.keepLine(statement);
+  }
+  /**
+   * Links are read before statements, as names may begin with a keyword (`Component -> X`); a link
+   * has no `[a, b]` tuple before its `;`. A line that could also be its keyword's statement is a
+   * link only when both names are declared.
+   */
+  readsAsLink(line, kw, after) {
+    const link = parseCoords(linkCore(line)) ? null : readLink(line, this.lineNo, this.currentLine);
+    if (!link) return false;
+    if (!couldBeStatement(line, kw, after)) {
+      this.pendingLinks.push(link);
       return true;
     }
-    if (flow) {
-      pendingLinks.push({
-        left: flow.left,
-        right: flow.right,
-        kind: "flow",
-        bidirectional: flow.op === "<>",
-        reverse: flow.op === "<",
-        ...flow.value ? { flowValue: flow.value } : {},
-        ...linkLabel ? { label: linkLabel } : {},
-        raw: line,
-        lineNo
-      });
+    const declared = this.linkNames;
+    const written = namesAsWritten(link);
+    const leftDeclared = declared.has(link.left) || declared.has(written.left);
+    if (leftDeclared && (declared.has(link.right) || declared.has(written.right))) {
+      this.pendingLinks.push({ ...link, writtenNames: written });
       return true;
     }
+    this.keywordLinks.push(link);
+    if (leftDeclared) this.diag(`Link: "${link.right}" not found \u2014 read as a "${kw}" statement`);
     return false;
-  };
-  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`);
+  }
+  /** Clamps a normalized value to [0,1] — with a diagnostic instead of a later validation crash. */
+  clamp(n, report = this.report) {
+    if (n < 0 || n > 1) report(`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;
+  }
+  position(visibility, evolution) {
+    return { visibility: this.clamp(visibility), evolution: this.clamp(evolution) };
+  }
+  reportTextBefore(before) {
+    if (before) this.diag(`Ignored text before the coordinates: "${before}"`);
+  }
+  /** A suffix written in front of the coordinates is part of the name or text (OWM). */
+  reportMisplacedSuffix(groups, where, fix) {
+    if (groups.length) this.diag(`"${groups.join(" ")}" ${where} \u2014 ${fix}`);
+  }
+  /**
+   * A text as the serializer writes it. Its comment markers are protected only by flow values
+   * `+'…'` within the text itself; one that other parts of the line protected is escaped now,
+   * not on the next parse.
+   */
+  readText(text, line = this.lineNo, source = this.currentLine) {
+    const written = escapeCommentMarkers(text);
+    if (written !== text) {
+      this.diag(
+        `"${text}" read as "${written}" \u2014 "//" or "/*" there would start a comment once saved`,
+        line,
+        source
+      );
     }
-    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;
+    return written;
+  }
+  /** Names an element the way the serializer writes it, so the next parse yields the same name. */
+  nameElement(sourceName, elementType, atLine = this.lineNo, atText = this.currentLine) {
+    const base = writtenName(sourceName, elementType);
+    const name = this.namesInUse.claim(base);
+    if (name !== base) {
+      this.diag(
+        `Duplicate name "${sourceName}" \u2014 renamed to "${name}"; links bind to the first "${sourceName}"`,
+        atLine,
+        atText
+      );
+    } else if (name !== sourceName) {
+      this.diag(renamedMessage(sourceName, name), atLine, atText);
     }
-    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;
-        }
+    return name;
+  }
+  openBlock() {
+    if (this.lastPipeline) {
+      this.blockPipeline = this.lastPipeline;
+      this.blockOpening = { line: this.lineNo, text: this.currentLine };
+    } else this.diag('Ignored "{" \u2014 a block must directly follow a pipeline line');
+    this.lastPipeline = null;
+  }
+  closeBlock() {
+    if (this.blockPipeline) this.blockPipeline = null;
+    else this.diag('Ignored "}" \u2014 no pipeline block is open');
+    this.lastPipeline = null;
+  }
+  endUnclosedBlock() {
+    if (!this.blockPipeline) return;
+    this.diag(
+      `Pipeline block of "${this.blockPipeline.name}" is never closed \u2014 add "}"`,
+      this.blockOpening.line,
+      this.blockOpening.text
+    );
+    this.blockPipeline = null;
+  }
+  /** A `url(Name)` reference on the element just pushed. */
+  addUrlRef(ref) {
+    this.pendingUrlRefs.push({
+      index: this.elements.length - 1,
+      ref,
+      line: this.lineNo,
+      text: this.currentLine
+    });
+  }
+  read(text) {
+    const sourceLines = text.split(/\r?\n/);
+    if (sourceLines.length > 1 && sourceLines[sourceLines.length - 1] === "") sourceLines.pop();
+    let blockCommentStart = null;
+    for (let i = 0; i < sourceLines.length; i++) {
+      const raw = withoutTrailingCarriageReturns(sourceLines[i]);
+      this.lineNo = i + 1;
+      this.currentLine = raw.trim();
+      const stripped = this.comments.strip(raw);
+      if (!this.comments.insideBlockComment) blockCommentStart = null;
+      else blockCommentStart ??= { line: this.lineNo, text: this.currentLine };
+      for (const fragment of stripped.comments) {
+        this.passthrough.push({
+          text: fragment,
+          isComment: true,
+          lineNo: this.lineNo,
+          source: this.currentLine
+        });
       }
-      rawPassthrough.push(line);
-      continue;
+      this.readCode(stripped.code.trim());
     }
-    if (line.startsWith("{")) {
-      if (lastPipeline) {
-        blockPipeline = lastPipeline;
-        lastPipeline = null;
-        continue;
-      }
-      rawPassthrough.push(line);
-      continue;
+    this.endUnclosedBlock();
+    if (blockCommentStart) {
+      const { line, text: startText } = blockCommentStart;
+      this.diag(
+        'Block comment "/*" is never closed \u2014 the rest of the file is a comment',
+        line,
+        startText
+      );
+    }
+    return this.finish();
+  }
+  /**
+   * Braces are structural tokens: `{` at the start of a line, and `}` there while a block is open
+   * or on its own; `}` also ends a block line. A name starting with `}` stays a name.
+   */
+  readCode(code) {
+    let statement = code;
+    for (; ; ) {
+      if (statement.startsWith("{")) this.openBlock();
+      else if (statement.startsWith("}") && (this.blockPipeline || statement === "}")) {
+        this.closeBlock();
+      } else break;
+      statement = statement.slice(1).trim();
     }
+    const closesBlock = this.blockPipeline !== null && statement.endsWith("}");
+    if (closesBlock) statement = statement.slice(0, -1).trim();
+    if (statement) this.readStatement(statement);
+    if (closesBlock) this.blockPipeline = null;
+  }
+  readStatement(line) {
     const kw = keywordOf(line);
     const after = line.slice(kw.length).trim();
-    if (kw !== "pipeline") lastPipeline = null;
-    if (!NON_LINK_KEYWORDS.has(kw) && !parseCoords(line) && pushLink(line)) {
-      continue;
-    }
+    if (this.blockPipeline && kw === "component" && this.readBlockChild(after)) return;
+    this.lastPipeline = null;
+    if (this.readsAsLink(line, kw, after)) return;
     switch (kw) {
       case "title":
-        config = { ...config, title: after };
-        break;
-      case "anchor": {
-        const node = parseNode(after);
-        if (!node) {
-          failed(line);
-          break;
-        }
-        const id = ids.alloc("anchor", node.name);
-        const anchor = compact({
-          id,
-          elementType: "anchor",
-          label: node.name,
-          position: pos(node.coords.a, node.coords.b),
-          labelOffset: node.labelOffset,
-          color: node.color
-        });
-        elements.push(anchor);
-        register(node.name, id);
-        break;
-      }
+        this.setConfig("title", { ...this.config, title: this.readText(after) });
+        return;
+      case "anchor":
+        return this.readAnchor(line, after);
       case "component":
       case "market":
-      case "ecosystem": {
-        const node = parseNode(after);
-        if (!node) {
-          failed(line);
-          break;
-        }
-        const decorators = mergeLegacy(kw, node.decorators);
-        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: 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;
-      }
-      case "note": {
-        const { color, rest } = parseColor(after);
-        const coords = parseCoords(rest);
-        const textPart = stripCoords(rest).trim().replace(/\\n/g, "\n");
-        if (!coords) {
-          failed(line);
-          break;
-        }
-        const id = ids.alloc("note", textPart || "note");
-        const note = compact({
-          id,
-          elementType: "note",
-          label: textPart,
-          position: pos(coords.a, coords.b),
-          color
-        });
-        elements.push(note);
-        break;
-      }
-      case "pipeline": {
-        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;
-        }
-        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) {
-          failed(line);
-          break;
-        }
-        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 failed(line);
-        break;
-      }
-      case "size": {
-        const coords = parseCoords(after);
-        if (coords) config = { ...config, size: { width: coords.a, height: coords.b } };
-        else failed(line);
-        break;
-      }
-      case "evolution": {
-        const parts = after.split("->").map((s) => s.trim());
-        if (parts.length === 4) {
-          config = { ...config, evolutionLabels: [parts[0], parts[1], parts[2], parts[3]] };
-        } else rawPassthrough.push(raw);
-        break;
-      }
-      case "y-axis": {
-        const parts = after.split("->").map((s) => s.trim()).filter(Boolean);
-        if (parts.length) {
-          config = {
-            ...config,
-            yAxisLabel: parts[0],
-            ...parts.length >= 3 ? { yAxisEndLabels: [parts[1], parts[2]] } : {}
-          };
-        } else failed(line);
-        break;
-      }
-      case "annotations": {
-        const coords = parseCoords(after);
-        if (coords) {
-          config = {
-            ...config,
-            annotationsBoxPosition: pos(coords.a, coords.b)
-          };
-        } else rawPassthrough.push(raw);
-        break;
-      }
-      case "annotation": {
-        const numMatch = /^\s*(\d+)/.exec(after);
-        const number = numMatch ? Number(numMatch[1]) : ++annoCounter;
-        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: positions[0],
-          number,
-          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 "ecosystem":
+        if (!this.pushComponent(after, kw)) this.failed(line);
+        return;
+      case "note":
+        return this.readNote(line, after);
+      case "pipeline":
+        return this.readPipeline(line, after);
+      case "evolve":
+        return this.readEvolve(line, after);
+      case "style":
+        return this.readStyle(line, after);
+      case "size":
+        return this.readSize(line, after);
+      case "evolution":
+        return this.readEvolution(line, after);
+      case "y-axis":
+        return this.readYAxis(line, after);
+      case "annotations":
+        return this.readAnnotationsBox(line, after);
+      case "annotation":
+        return this.readAnnotation(line, after);
+      case "line":
+        return this.readDrawing(line, after);
       case "pioneers":
       case "settlers":
-      case "townplanners": {
-        const col = parseColor(after);
-        const four = parseCoords4(col.rest);
-        if (!four) {
-          failed(line);
-          break;
-        }
-        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 "townplanners":
+        return this.readAttitude(line, after, kw);
+      case "url":
+        return this.readUrlDefinition(line, after);
       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 "outsource":
+        return this.readMethod(line, after, kw);
       case "accelerator":
-      case "deaccelerator": {
-        const node = parseNode(after);
-        if (!node) {
-          failed(line);
-          break;
-        }
-        const id = ids.alloc("accel", node.name);
-        const accelerator = {
-          id,
-          elementType: "accelerator",
-          direction: kw === "deaccelerator" ? "deaccelerate" : "accelerate",
-          label: node.name,
-          position: pos(node.coords.a, node.coords.b),
-          ...node.color ? { color: node.color } : {}
-        };
-        elements.push(accelerator);
-        register(node.name, id);
-        break;
-      }
-      case "submap": {
-        const node = parseNode(after);
-        if (!node) {
-          failed(line);
-          break;
-        }
-        const id = ids.alloc("submap", node.name);
-        const submap = {
-          id,
-          elementType: "submap",
-          label: node.name,
-          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;
-      }
+      case "deaccelerator":
+        return this.readAccelerator(line, after, kw);
+      case "submap":
+        return this.readSubmap(line, after);
       default: {
-        if (!pushLink(line)) rawPassthrough.push(line);
+        const link = readLink(line, this.lineNo, this.currentLine);
+        if (link) this.pendingLinks.push(link);
+        else this.keep(line, unknownStatementMessage(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);
+  readBlockChild(after) {
+    const blockPipeline = this.blockPipeline;
+    const child = parseBlockChild(after, this.report);
+    if (child) {
+      blockPipeline.children.push({
+        ...child,
+        maturity: this.clamp(child.maturity),
+        lineNo: this.lineNo,
+        text: this.currentLine
+      });
+      return true;
     }
-    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;
+    if (splitAtCoords(after)?.name) {
+      this.diag(
+        `Component with [visibility, maturity] inside the block of pipeline "${blockPipeline.name}" is not a child \u2014 use [maturity]`
+      );
     }
-    start = clamp01(start);
-    end = clamp01(end);
-    if (end <= start) end = Math.min(1, start + 0.05);
-    const pipeline = {
+    return false;
+  }
+  readAnchor(line, after) {
+    const node = parseNode(after, ANCHOR_SUFFIXES, this.report);
+    if (!node) return this.failed(line);
+    const label = this.nameElement(node.name, "anchor");
+    const id = this.ids.alloc("anchor", label);
+    const anchor = compact({
       id,
-      elementType: "pipeline",
-      label: p.name,
-      position: { visibility, evolution: (start + end) / 2 },
-      evolutionStart: start,
-      evolutionEnd: end,
-      childIds,
-      ...p.color ? { color: p.color } : {}
+      elementType: "anchor",
+      label,
+      position: this.position(node.coords.a, node.coords.b),
+      labelOffset: node.labelOffset,
+      color: node.color
+    });
+    this.elements.push(anchor);
+    this.register(node.name, label, id);
+  }
+  /** `component`/`market`/`ecosystem` and `build`/`buy`/`outsource` lines with coordinates. */
+  pushComponent(after, kw) {
+    const keywordMethod = METHODS.has(kw) ? kw : void 0;
+    const node = parseNode(after, COMPONENT_SUFFIXES, this.report, keywordMethod);
+    if (!node) return false;
+    const decorators = mergeLegacy(kw, node.decorators);
+    const label = this.nameElement(node.name, "component");
+    const id = this.ids.alloc("cmp", label);
+    const component = compact({
+      id,
+      elementType: "component",
+      label,
+      position: this.position(node.coords.a, node.coords.b),
+      labelOffset: node.labelOffset,
+      decorators: Object.keys(decorators).length ? decorators : void 0,
+      color: node.color
+    });
+    this.elements.push(component);
+    if (node.urlRef) this.addUrlRef(node.urlRef);
+    this.register(node.name, label, id);
+    return true;
+  }
+  readNote(line, after) {
+    const split = splitAtCoords(after);
+    if (!split) return this.failed(line);
+    const { color } = readSuffix(split.suffix, NOTE_SUFFIXES, this.report);
+    this.reportMisplacedSuffix(
+      splitTrailingGroups(split.name, { color: true, height: false }).groups,
+      "before the coordinates is read as part of the text",
+      "write it after them"
+    );
+    const textPart = this.readText(split.name.replace(/\\n/g, "\n"));
+    const note = compact({
+      id: this.ids.alloc("note", textPart || "note"),
+      elementType: "note",
+      label: textPart,
+      position: this.position(split.coords.a, split.coords.b),
+      color
+    });
+    this.elements.push(note);
+  }
+  /** `pipeline X [s, e]`, `pipeline X` (block form, range from children) — optionally with `{` at the end. */
+  readPipeline(line, after) {
+    this.endUnclosedBlock();
+    let body = after;
+    let opensBlock = false;
+    while (body.endsWith("{")) {
+      if (opensBlock) this.diag('Ignored "{" \u2014 a block must directly follow a pipeline line');
+      opensBlock = true;
+      body = body.slice(0, -1).trim();
+    }
+    const { name, range, suffixText, misplaced } = splitPipelineLine(body);
+    if (!name) return this.failed(line);
+    if (range && !range.coords) this.diag(unreadableNumberMessage(range.tuple));
+    this.reportMisplacedSuffix(
+      misplaced,
+      "before the coordinates is read as part of the name",
+      "write it after them"
+    );
+    const notes = [];
+    const note = (message) => notes.push(message);
+    const suffix = readSuffix(suffixText, PIPELINE_SUFFIXES, note);
+    const coords = range?.coords;
+    const pending = {
+      name,
+      lineNo: this.lineNo,
+      text: this.currentLine,
+      ...coords ? { start: this.clamp(coords.a), end: this.clamp(coords.b) } : {},
+      ...suffix.height !== void 0 ? { visibility: roundAsWritten(this.clamp(suffix.height, note)) } : {},
+      ...suffix.color ? { color: suffix.color } : {},
+      notes,
+      raw: line.slice(0, line.length - after.length) + body,
+      children: []
     };
-    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;
+    this.pendingPipeline.push(pending);
+    if (opensBlock) {
+      this.blockPipeline = pending;
+      this.blockOpening = { line: this.lineNo, text: this.currentLine };
+    } else this.lastPipeline = pending;
+  }
+  readEvolve(line, after) {
+    const notes = [];
+    const note = (message) => notes.push(message);
+    const evolve = parseEvolve(after, note);
+    if (!evolve) return this.failed(line);
+    this.pendingEvolve.push({
+      ...evolve,
+      target: this.clamp(evolve.target, note),
+      notes,
+      raw: line,
+      lineNo: this.lineNo,
+      text: this.currentLine
+    });
+  }
+  readStyle(line, after) {
+    const style = after.toLowerCase();
+    if (KNOWN_STYLES.has(style)) {
+      this.setConfig("style", { ...this.config, style });
+    } else this.failed(line);
+  }
+  readSize(line, after) {
+    const split = splitAtCoords(after);
+    const coords = split?.coords;
+    if (!coords || !isRoundTrippableNumber(coords.a) || !isRoundTrippableNumber(coords.b)) {
+      return this.failed(line);
     }
-    const movement = compact({
-      targetEvolution: ev.target,
-      newLabel: ev.newLabel,
-      method: ev.method,
-      labelOffset: ev.labelOffset
+    this.reportTextBefore(split.name);
+    readSuffix(split.suffix, NO_SUFFIXES, this.report);
+    this.setConfig("size", { ...this.config, size: { width: coords.a, height: coords.b } });
+  }
+  readEvolution(line, after) {
+    const parts = after.split("->").map((s) => s.trim());
+    if (parts.length === 4) {
+      const [first, second, third, fourth] = parts.map((part) => this.readText(part));
+      const evolutionLabels = [first, second, third, fourth];
+      this.setConfig("evolution", { ...this.config, evolutionLabels });
+    } else {
+      const reason = `Evolution needs exactly four stages, found ${parts.length}`;
+      this.keepUnusedConfigLine("evolution", line, reason);
+    }
+  }
+  /** `y-axis Label->BottomLabel->TopLabel` — keeps the end labels losslessly too. */
+  readYAxis(line, after) {
+    const written = after.split("->").map((s) => s.trim());
+    const [label, bottom, top] = written.filter(Boolean).map((part) => this.readText(part));
+    if (!label) return this.keepUnusedConfigLine("y-axis", line, "y-axis has no label");
+    const { yAxisEndLabels: _replaced, ...otherConfig } = this.config;
+    const ends = bottom && top ? [bottom, top] : void 0;
+    this.setConfig("y-axis", {
+      ...otherConfig,
+      yAxisLabel: label,
+      ...ends ? { yAxisEndLabels: ends } : {}
     });
-    elements[idx] = { ...elements[idx], movement };
-  }
-  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;
+    if (written.length !== 1 && !(written.length === 3 && written.every(Boolean))) {
+      const read = [label, ...ends ?? []].join("->");
+      this.diag(`y-axis takes "Label" or "Label->Bottom->Top" \u2014 read as "${read}"`);
     }
-    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 };
+  }
+  readAnnotationsBox(line, after) {
+    const split = splitAtCoords(after);
+    if (!split) {
+      return this.keep(
+        line,
+        "Annotations box has no position \u2014 not used; add [visibility, maturity]"
+      );
     }
+    this.reportTextBefore(split.name);
+    readSuffix(split.suffix, NO_SUFFIXES, this.report);
+    const annotationsBoxPosition = this.position(split.coords.a, split.coords.b);
+    this.setConfig("annotations", { ...this.config, annotationsBoxPosition });
   }
-  for (const [name, address] of urlDefs) {
-    if (!usedUrlDefs.has(name)) rawPassthrough.push(`url ${name} [${address}]`);
+  /** `annotation N <position> [(color …)] <text>`; the position is a tuple or a tuple list. */
+  readAnnotation(line, after) {
+    const numMatch = /^\s*(\d+)/.exec(after);
+    const number = numMatch ? Number(numMatch[1]) : ++this.annotationCounter;
+    if (!Number.isSafeInteger(number)) return this.failed(line);
+    const found = parsePositions(after.replace(/^\s*\d+\s*/, ""));
+    if (!found) {
+      return this.keep(line, "Annotation has no position \u2014 not drawn; add [visibility, maturity]");
+    }
+    if (!found.tuples.length) return this.failed(line);
+    for (const unreadable of found.unreadable) this.diag(unreadableNumberMessage(unreadable));
+    this.reportTextBefore(found.before);
+    const { color, rest } = splitLeadingColor(found.after);
+    this.reportMisplacedSuffix(
+      splitTrailingGroups(rest, { color: true, height: false }).groups,
+      "after the annotation text is read as part of the text",
+      "write it directly after the position"
+    );
+    const text = this.readText(rest.trim());
+    const positions = found.tuples.map((t) => this.position(t.a, t.b));
+    const annotation = {
+      id: this.ids.alloc("anno", String(number)),
+      elementType: "annotation",
+      label: text,
+      position: positions[0],
+      number,
+      positions,
+      text,
+      ...color ? { color } : {}
+    };
+    this.elements.push(annotation);
   }
-  let depN = 0;
-  let flowN = 0;
-  const edges = [];
-  for (const link of pendingLinks) {
-    const fromId = nameToId.get(link.left);
-    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
+  /** Project extension (freeform drawing): `line [[v,e], [v,e], …] (closed) (dashed) (color x)`. */
+  readDrawing(line, after) {
+    const list = parseMultiCoords(after);
+    if (!list || list.tuples.length < 2) return this.failed(line);
+    for (const unreadable of list.unreadable) this.diag(unreadableNumberMessage(unreadable));
+    this.reportTextBefore(list.before);
+    const suffix = readSuffix(list.after, DRAWING_SUFFIXES, this.report);
+    const points = list.tuples.map((t) => this.position(t.a, t.b));
+    const drawing = {
+      id: this.ids.alloc("draw", "line"),
+      elementType: "drawing",
+      label: "",
+      position: points[0],
+      points,
+      ...suffix.closed ? { closed: true } : {},
+      ...suffix.strokeStyle ? { strokeStyle: suffix.strokeStyle } : {},
+      ...suffix.color ? { color: suffix.color } : {}
+    };
+    this.elements.push(drawing);
+  }
+  /** Canonical OWM form: `<kind> [vis1, mat1, vis2, mat2]` (two corners, normalized). */
+  readAttitude(line, after, kind) {
+    const split = splitAtCoords4(after);
+    if (!split) return this.failed(line);
+    this.reportTextBefore(split.before);
+    const { color } = readSuffix(split.after, ATTITUDE_SUFFIXES, this.report);
+    const { a, b, c, d } = split.coords;
+    const corners = [this.clamp(a), this.clamp(b), this.clamp(c), this.clamp(d)];
+    this.elements.push(makeAttitude(this.ids, kind, corners, color));
+  }
+  /** OWM: `url Name [https://…]` — definition, referenced via `url(Name)` on elements. */
+  readUrlDefinition(line, after) {
+    const definition = readUrlDefinition(after);
+    if (!definition) return this.failed(line);
+    this.urlDefinitions.push({ ...definition, lineNo: this.lineNo, text: this.currentLine });
+  }
+  /**
+   * Legacy OWM: `buy <Name>` (method on an existing component) or `buy <Name> [vis, mat]` (create a
+   * component with a method).
+   */
+  readMethod(line, after, kw) {
+    if (this.pushComponent(after, kw)) return;
+    if (!after) return this.keep(line, `${kw}: needs a component name \u2014 not used`);
+    this.pendingMethod.push({
+      name: after,
+      method: kw,
+      raw: line,
+      lineNo: this.lineNo,
+      text: this.currentLine
+    });
+  }
+  readAccelerator(line, after, kw) {
+    const node = parseNode(after, ACCELERATOR_SUFFIXES, this.report);
+    if (!node) return this.failed(line);
+    const label = this.nameElement(node.name, "accelerator");
+    const id = this.ids.alloc("accel", label);
+    const accelerator = {
+      id,
+      elementType: "accelerator",
+      direction: kw === "deaccelerator" ? "deaccelerate" : "accelerate",
+      label,
+      position: this.position(node.coords.a, node.coords.b),
+      ...node.color ? { color: node.color } : {}
+    };
+    this.elements.push(accelerator);
+    this.register(node.name, label, id);
+  }
+  readSubmap(line, after) {
+    const node = parseNode(after, SUBMAP_SUFFIXES, this.report);
+    if (!node) return this.failed(line);
+    const label = this.nameElement(node.name, "submap");
+    const id = this.ids.alloc("submap", label);
+    const submap = {
+      id,
+      elementType: "submap",
+      label,
+      position: this.position(node.coords.a, node.coords.b),
+      ...node.color ? { color: node.color } : {}
+    };
+    this.elements.push(submap);
+    if (node.urlRef) this.addUrlRef(node.urlRef);
+    this.register(node.name, label, id);
+  }
+  finish() {
+    const removedFromPassthrough = replacedConfigLines(
+      this.unusedConfigLines,
+      this.config,
+      this.reportAt
+    );
+    this.resolvePipelines();
+    const indexById = new Map(this.elements.map((el, index) => [el.id, index]));
+    this.resolveEvolves(indexById);
+    this.resolveMethods(indexById);
+    const keptDefinitions = resolveUrlReferences(
+      this.elements,
+      this.pendingUrlRefs,
+      this.urlDefinitions,
+      this.reportAt
+    );
+    for (const definition of keptDefinitions) {
+      this.keepLine(
+        `url ${definition.name} [${definition.address}]`,
+        definition.lineNo,
+        definition.text
       );
-      continue;
     }
-    if (link.kind === "dependency") {
-      edges.push(
-        compact({
-          id: `dep_${++depN}`,
-          edgeType: "dependency",
-          from: fromId,
-          to: toId,
-          label: link.label
-        })
+    const declaredNames = /* @__PURE__ */ new Set([...this.idBySourceName.keys(), ...this.idByElementName.keys()]);
+    const edges = buildEdges(
+      this.pendingLinks,
+      (name) => this.idOfName(name),
+      (link, missing) => {
+        this.keepLine(link.raw, link.lineNo, link.text);
+        this.diag(`Link: "${missing}" not found`, link.lineNo, link.text);
+      },
+      (link) => link.label && this.readText(link.label, link.lineNo, link.text)
+    );
+    const kept = this.passthrough.filter((_, index) => !removedFromPassthrough.has(index));
+    const rawPassthrough = withoutClosersOfKeptComments(kept, this.reportAt);
+    const map = compact({
+      schemaVersion: wardleySchemaModel.CURRENT_SCHEMA_VERSION,
+      config: this.config,
+      elements: this.elements,
+      edges,
+      rawPassthrough: rawPassthrough.length ? rawPassthrough : void 0
+    });
+    return {
+      result: { map: wardleySchemaModel.validateMap(map), diagnostics: this.diagnostics },
+      declaredNames,
+      keywordLinks: this.keywordLinks
+    };
+  }
+  /**
+   * A pipeline pairs with the component written under its name: it takes that component's height,
+   * as the serializer assumes when it leaves out `(y …)`. Block children are not such components.
+   */
+  resolvePipelines() {
+    const componentByName = /* @__PURE__ */ new Map();
+    for (const el of this.elements) {
+      if (el.elementType === "component") componentByName.set(el.label, el);
+    }
+    for (const p of this.pendingPipeline) {
+      const label = writtenName(p.name, "pipeline");
+      const component = componentByName.get(label);
+      const writtenRange = pipelineRange(p);
+      if (!writtenRange) {
+        this.keepLine(p.raw, p.lineNo, p.text);
+        if (!component) {
+          this.diag(
+            `Pipeline "${p.name}" has no range \u2014 not drawn; add [start, end] or child components`,
+            p.lineNo,
+            p.text
+          );
+        }
+        continue;
+      }
+      for (const message of p.notes) this.diag(message, p.lineNo, p.text);
+      if (label !== p.name) this.diag(renamedMessage(p.name, label), p.lineNo, p.text);
+      const range = widenEmptyRange(writtenRange);
+      const widened = range.start !== writtenRange.start || range.end !== writtenRange.end;
+      if (widened && !writtenRange.fromChildren) {
+        this.diag(
+          `Pipeline "${p.name}" range is empty or reversed \u2014 changed to [${range.start}, ${range.end}]`,
+          p.lineNo,
+          p.text
+        );
+      }
+      const visibility = p.visibility ?? component?.position.visibility ?? 0.5;
+      const id = this.ids.alloc("pipeline", label);
+      if (this.idOfName(p.name) === void 0 && this.idOfName(label) === void 0) {
+        this.register(p.name, label, id);
+      }
+      const childNames = p.children.map(
+        (child) => this.nameElement(child.name, "component", child.lineNo, child.text)
       );
-    } else {
-      const [f, t] = link.reverse ? [toId, fromId] : [fromId, toId];
-      edges.push(
-        compact({
-          id: `flow_${++flowN}`,
-          edgeType: "flow",
-          from: f,
-          to: t,
-          bidirectional: link.bidirectional ? true : void 0,
-          flowValue: link.flowValue,
-          label: link.label
-        })
+      const { pipeline, children } = pipelineElements(
+        { ...p, name: label },
+        id,
+        visibility,
+        range,
+        this.ids,
+        childNames
       );
+      this.elements.push(pipeline);
+      children.forEach((child, index) => {
+        this.elements.push(child);
+        this.register(p.children[index].name, child.label, child.id);
+      });
+    }
+  }
+  componentIndex(name, indexById) {
+    const index = indexById.get(this.idOfName(name) ?? "");
+    return index !== void 0 && this.elements[index].elementType === "component" ? index : -1;
+  }
+  resolveEvolves(indexById) {
+    const evolveLineOf = /* @__PURE__ */ new Map();
+    for (const ev of this.pendingEvolve) {
+      const index = this.componentIndex(ev.name, indexById);
+      if (index < 0) {
+        this.keepLine(ev.raw, ev.lineNo, ev.text);
+        const misplaced = splitMisplacedEvolveSuffix(ev.name);
+        const hint = misplaced && this.componentIndex(misplaced.name, indexById) >= 0 ? misplacedEvolveSuffixHint(misplaced) : "";
+        this.diag(`evolve: component "${ev.name}" not found${hint}`, ev.lineNo, ev.text);
+        continue;
+      }
+      for (const message of ev.notes) this.diag(message, ev.lineNo, ev.text);
+      const component = this.elements[index];
+      const earlier = evolveLineOf.get(component.id);
+      if (earlier !== void 0) {
+        const message = `Repeated evolve for "${ev.name}" \u2014 replaces the one on line ${earlier}`;
+        this.diag(message, ev.lineNo, ev.text);
+      }
+      evolveLineOf.set(component.id, ev.lineNo);
+      const movement = compact({
+        targetEvolution: ev.target,
+        newLabel: ev.newLabel && this.readText(ev.newLabel, ev.lineNo, ev.text),
+        method: ev.method,
+        labelOffset: ev.labelOffset
+      });
+      this.elements[index] = { ...component, movement };
     }
   }
-  const map = compact({
-    schemaVersion: wardleySchemaModel.CURRENT_SCHEMA_VERSION,
-    config,
-    elements,
-    edges,
-    rawPassthrough: rawPassthrough.length ? rawPassthrough : void 0
+  /** Legacy standalone methods (`buy <name>`). */
+  resolveMethods(indexById) {
+    for (const pm of this.pendingMethod) {
+      const index = this.componentIndex(pm.name, indexById);
+      if (index < 0) {
+        this.keepLine(pm.raw, pm.lineNo, pm.text);
+        this.diag(`${pm.method}: component "${pm.name}" not found`, pm.lineNo, pm.text);
+        continue;
+      }
+      const el = this.elements[index];
+      const replaced = el.decorators?.method;
+      if (replaced && replaced !== pm.method) {
+        const message = `${pm.method}: "${pm.name}" already has the method "${replaced}" \u2014 replaced`;
+        this.diag(message, pm.lineNo, pm.text);
+      }
+      this.elements[index] = { ...el, decorators: { ...el.decorators, method: pm.method } };
+    }
+  }
+};
+function renamedMessage(sourceName, name) {
+  return `Name "${sourceName}" renamed to "${name}" \u2014 a name cannot hold link operators ("->", "+>", "+<", "+'"), comment markers or a leading "{"`;
+}
+function withoutTrailingCarriageReturns(line) {
+  let end = line.length;
+  while (end > 0 && line[end - 1] === "\r") end--;
+  return line.slice(0, end);
+}
+function withoutClosersOfKeptComments(entries, report) {
+  const nextParse = new CommentStripper();
+  return entries.map((entry) => {
+    let text = entry.text;
+    if (!entry.isComment && nextParse.insideBlockComment && text.includes("*/")) {
+      text = text.replaceAll("*/", " ");
+      report(
+        'Ignored "*/" \u2014 this line is kept after an unclosed "/*" and would end that comment',
+        entry.lineNo,
+        entry.source
+      );
+    }
+    nextParse.strip(text);
+    return text;
   });
-  return { map: wardleySchemaModel.validateMap(map), diagnostics };
 }
-function parseNode(after) {
+function replacedConfigLines(unusedLines, config, report) {
+  const configIsSet = {
+    evolution: config.evolutionLabels !== void 0,
+    "y-axis": config.yAxisLabel !== void 0
+  };
+  const replacedIndexes = /* @__PURE__ */ new Set();
+  for (const unused of unusedLines) {
+    const replaced = configIsSet[unused.keyword];
+    if (replaced) replacedIndexes.add(unused.index);
+    const outcome = replaced ? `removed; another "${unused.keyword}" line sets it` : "not used";
+    report(`${unused.reason} \u2014 ${outcome}`, unused.line, unused.text);
+  }
+  return replacedIndexes;
+}
+function resolveUrlReferences(elements, refs, definitions, report) {
+  const definitionByName = /* @__PURE__ */ new Map();
+  const replaced = /* @__PURE__ */ new Set();
+  for (const definition of definitions) {
+    const earlier = definitionByName.get(definition.name);
+    if (earlier) {
+      replaced.add(earlier);
+      report(
+        `Repeated url definition "${definition.name}" \u2014 replaces the one on line ${earlier.lineNo}, which is kept unused`,
+        definition.lineNo,
+        definition.text
+      );
+    }
+    definitionByName.set(definition.name, definition);
+  }
+  const used = /* @__PURE__ */ new Set();
+  for (const { index, ref, line, text } of refs) {
+    const definition = definitionByName.get(ref);
+    if (definition) used.add(definition);
+    const address = definition?.address ?? (/^[a-z][\w+.-]*:\/\//i.test(ref) ? ref : void 0);
+    if (!address) {
+      report(`url(${ref}) has no matching "url ${ref} [address]" line \u2014 ignored`, line, text);
+      continue;
+    }
+    const el = elements[index];
+    if (el.elementType === "component") elements[index] = { ...el, url: address };
+    else if (el.elementType === "submap") elements[index] = { ...el, urlRef: address };
+  }
+  return definitions.filter((definition) => replaced.has(definition) || !used.has(definition));
+}
+function parseNode(after, suffixes, report, keywordMethod) {
   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 suffix = readSuffix(split.suffix, suffixes, report, "after the coordinates", keywordMethod);
   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
+    decorators: suffix.decorators,
+    labelOffset: suffix.labelOffset,
+    urlRef: suffix.urlRef,
+    color: suffix.color
   });
 }
-function clamp01(n) {
-  return n < 0 ? 0 : n > 1 ? 1 : n;
+var COMPONENT_SUFFIXES = /* @__PURE__ */ new Set(["color", "decorators", "label", "url"]);
+var PIPELINE_CHILD_SUFFIXES = /* @__PURE__ */ new Set(["color", "decorators", "label"]);
+var ANCHOR_SUFFIXES = /* @__PURE__ */ new Set(["color", "label"]);
+var SUBMAP_SUFFIXES = /* @__PURE__ */ new Set(["color", "url"]);
+var ACCELERATOR_SUFFIXES = /* @__PURE__ */ new Set(["color"]);
+var NOTE_SUFFIXES = /* @__PURE__ */ new Set(["color"]);
+var ATTITUDE_SUFFIXES = /* @__PURE__ */ new Set(["color"]);
+var PIPELINE_SUFFIXES = /* @__PURE__ */ new Set(["color", "height"]);
+var DRAWING_SUFFIXES = /* @__PURE__ */ new Set(["color", "stroke"]);
+var EVOLVE_SUFFIXES = /* @__PURE__ */ new Set(["method"]);
+var NO_SUFFIXES = /* @__PURE__ */ new Set();
+function readSuffix(text, slots, report, place = "after the coordinates", keywordMethod) {
+  const reading = {};
+  const decorators = keywordMethod ? { method: keywordMethod } : {};
+  const seen = /* @__PURE__ */ new Set();
+  const ignored = [];
+  const readGroupItem = (item) => {
+    if (slots.has("decorators") && (item === "market" || item === "ecosystem" || item === "inertia")) {
+      decorators[item] = true;
+      return true;
+    }
+    if ((slots.has("decorators") || slots.has("method")) && METHODS.has(item)) {
+      decorators.method ??= item;
+      return decorators.method === item;
+    }
+    if (slots.has("stroke") && item === "closed") {
+      reading.closed = true;
+      return true;
+    }
+    if (slots.has("stroke") && (item === "dashed" || item === "dotted")) {
+      reading.strokeStyle ??= item;
+      return reading.strokeStyle === item;
+    }
+    return false;
+  };
+  const firstOf = (token, slot) => {
+    if (!slots.has(slot) || seen.has(token.kind)) return false;
+    seen.add(token.kind);
+    return true;
+  };
+  for (const token of scanSuffix(text)) {
+    switch (token.kind) {
+      case "color":
+        if (firstOf(token, "color")) reading.color = token.color;
+        else ignored.push(token);
+        break;
+      case "height":
+        if (firstOf(token, "height")) {
+          const height = readUnclampedNumber(token.value);
+          if (height === null) report(unreadableNumberMessage(token.text));
+          else reading.height = height;
+        } else ignored.push(token);
+        break;
+      case "label":
+        if (firstOf(token, "label")) {
+          const dx = readUnclampedNumber(token.dx);
+          const dy = readUnclampedNumber(token.dy);
+          if (dx === null || dy === null) report(unreadableNumberMessage(token.text));
+          else reading.labelOffset = { dx, dy };
+        } else ignored.push(token);
+        break;
+      case "url":
+        if (token.ref && firstOf(token, "url")) reading.urlRef = token.ref;
+        else ignored.push(token);
+        break;
+      case "inertia":
+        if (slots.has("decorators")) decorators.inertia = true;
+        else ignored.push(token);
+        break;
+      case "group": {
+        const unfit = token.items.filter((item) => !readGroupItem(item.text.toLowerCase()));
+        if (unfit.length === token.items.length) ignored.push(token);
+        else for (const item of unfit) ignored.push(item);
+        break;
+      }
+      case "word":
+        ignored.push(token);
+    }
+  }
+  if (ignored.length) report(`Ignored text ${place}: ${quotedSpans(text, ignored)}`);
+  return compact({ ...reading, decorators });
 }
-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]);
+function quotedSpans(text, spans) {
+  const pieces = [];
+  let start = spans[0].at;
+  let end = start + spans[0].text.length;
+  for (let i = 1; i < spans.length; i++) {
+    const span = spans[i];
+    if (text.slice(end, span.at).trim() !== "") {
+      pieces.push(text.slice(start, end));
+      start = span.at;
+    }
+    end = span.at + span.text.length;
+  }
+  pieces.push(text.slice(start, end));
+  return pieces.map((piece) => `"${piece}"`).join(", ");
+}
+function splitPipelineLine(body) {
+  const kinds = { color: true, height: true };
+  const split = splitAtTuple(body);
+  if (split) {
+    return {
+      name: split.before,
+      range: { tuple: split.tuple, coords: split.coords },
+      suffixText: split.after,
+      misplaced: splitTrailingGroups(split.before, kinds).groups
+    };
+  }
+  const { rest, groups } = splitTrailingGroups(body, kinds);
+  return { name: rest, range: null, suffixText: groups.join(" "), misplaced: [] };
+}
+function unreadableNumberMessage(text) {
+  return `Unreadable number in "${text}" \u2014 ignored`;
+}
+function pipelineRange(p) {
+  if (p.start !== void 0 && p.end !== void 0) {
+    return { start: roundAsWritten(p.start), end: roundAsWritten(p.end) };
+  }
+  const [first, ...others] = p.children;
+  if (!first) return null;
+  let start = first.maturity;
+  let end = first.maturity;
+  for (const child of others) {
+    start = Math.min(start, child.maturity);
+    end = Math.max(end, child.maturity);
+  }
+  return { start: roundAsWritten(start), end: roundAsWritten(end), fromChildren: true };
+}
+function widenEmptyRange({ start, end }) {
+  if (end > start) return { start, end };
+  const widenedStart = start >= 1 ? 0.95 : start;
+  return { start: widenedStart, end: roundAsWritten(Math.min(1, widenedStart + 0.05)) };
+}
+function pipelineElements(p, id, visibility, range, ids, childNames) {
+  const children = p.children.map(
+    (c, index) => compact({
+      id: ids.alloc("cmp", childNames[index]),
+      elementType: "component",
+      label: childNames[index],
+      position: { visibility, evolution: c.maturity },
+      labelOffset: c.labelOffset,
+      decorators: Object.keys(c.decorators).length ? c.decorators : void 0,
+      pipelineId: id,
+      color: c.color
+    })
+  );
+  const pipeline = {
+    id,
+    elementType: "pipeline",
+    label: p.name,
+    position: { visibility, evolution: (range.start + range.end) / 2 },
+    evolutionStart: range.start,
+    evolutionEnd: range.end,
+    childIds: children.map((child) => child.id),
+    ...p.color ? { color: p.color } : {}
+  };
+  return { pipeline, children };
+}
+function parseBlockChild(after, report) {
+  const split = splitAtFirstChildTuple(after);
+  if (!split?.before || split.values.length !== 1) return null;
+  const maturity = Number(split.values[0]);
   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);
+  const suffix = readSuffix(split.after, PIPELINE_CHILD_SUFFIXES, report);
   return compact({
-    name,
+    name: split.before,
     maturity,
-    decorators: dec.decorators,
-    labelOffset: lo.labelOffset ?? void 0,
-    color: col.color ?? void 0
+    decorators: suffix.decorators,
+    labelOffset: suffix.labelOffset,
+    color: suffix.color
   });
 }
-function makeAttitude(ids, kind, v1, m1, v2, m2, color) {
+function makeAttitude(ids, kind, [v1, m1, v2, m2], color) {
   return {
     id: ids.alloc("attitude", kind),
     elementType: "attitude",
@@ -798,12 +1525,12 @@ function makeAttitude(ids, kind, v1, m1, v2, m2, color) {
     label: "",
     ...color ? { color } : {},
     position: {
-      visibility: clamp01(Math.max(v1, v2)),
-      evolution: clamp01(Math.min(m1, m2))
+      visibility: Math.max(v1, v2),
+      evolution: Math.min(m1, m2)
     },
     corner2: {
-      visibility: clamp01(Math.min(v1, v2)),
-      evolution: clamp01(Math.max(m1, m2))
+      visibility: Math.min(v1, v2),
+      evolution: Math.max(m1, m2)
     }
   };
 }
@@ -811,18 +1538,36 @@ function mergeLegacy(kw, dec) {
   const merged = { ...dec };
   if (kw === "market") merged["market"] = true;
   if (kw === "ecosystem") merged["ecosystem"] = true;
+  if (METHODS.has(kw)) merged["method"] = kw;
   return compact(merged);
 }
-function parseEvolve(after) {
+var MISPLACED_EVOLVE_SUFFIX_RE = /(?:\((build|buy|outsource)\)|\binertia)$/i;
+function splitMisplacedEvolveSuffix(name) {
+  const m = MISPLACED_EVOLVE_SUFFIX_RE.exec(name);
+  if (!m) return null;
+  const rest = name.slice(0, m.index).trimEnd();
+  return rest ? { name: rest, suffix: m[0] } : null;
+}
+function misplacedEvolveSuffixHint({ name, suffix }) {
+  return suffix.startsWith("(") ? ` \u2014 for component "${name}", write "${suffix}" after the target` : ` \u2014 for component "${name}", write "${suffix}" on its component line`;
+}
+var NUMBER_TOKEN_RE = /(^|\s)([-+]?(?:\d+(?:\.\d*)?|\.\d+)(?:e[-+]?\d+)?)(?=\s|\(|$)/gi;
+function parseEvolve(after, report) {
   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];
-  const target = Number(last);
-  if (Number.isNaN(target)) return null;
-  const namePart = tokens.slice(0, -1).join(" ").trim();
-  if (!namePart) return null;
+  let targetMatch;
+  for (const match of lo.rest.matchAll(NUMBER_TOKEN_RE)) targetMatch = match;
+  if (!targetMatch) return null;
+  const targetAt = targetMatch.index + targetMatch[1].length;
+  const namePart = lo.rest.slice(0, targetAt).trim();
+  const target = Number(targetMatch[2]);
+  if (!namePart || !Number.isFinite(target)) return null;
+  if (lo.unreadable) report(unreadableNumberMessage(lo.unreadable));
+  const tail = readSuffix(
+    lo.rest.slice(targetAt + targetMatch[2].length),
+    EVOLVE_SUFFIXES,
+    report,
+    "after the evolve target"
+  );
   const renameIdx = namePart.indexOf("->");
   const name = renameIdx >= 0 ? namePart.slice(0, renameIdx).trim() : namePart;
   const newLabel = renameIdx >= 0 ? namePart.slice(renameIdx + 2).trim() : void 0;
@@ -830,7 +1575,7 @@ function parseEvolve(after) {
     name,
     newLabel: newLabel || void 0,
     target,
-    method: dec.decorators.method,
+    method: tail.decorators.method,
     labelOffset: lo.labelOffset ?? void 0
   });
 }
@@ -842,23 +1587,28 @@ function urlOf(el) {
   return void 0;
 }
 function r(n) {
-  return String(Math.round(n * 1e3) / 1e3);
-}
-var NAMED_TYPES = /* @__PURE__ */ new Set(["anchor", "component", "accelerator", "submap"]);
-function defaultName(type) {
-  return type === "anchor" ? "User" : type === "accelerator" ? "Accelerator" : type === "submap" ? "Submap" : "Component";
+  return String(roundAsWritten(n));
 }
 function uniqueNames(map) {
-  const used = /* @__PURE__ */ new Set();
+  const namesInUse = new UniqueNames();
   const byId = /* @__PURE__ */ new Map();
   for (const el of map.elements) {
-    if (!NAMED_TYPES.has(el.elementType)) continue;
-    const base = el.label.trim().replace(/->/g, "\u2192") || defaultName(el.elementType);
-    let name = base;
-    let i = 2;
-    while (used.has(name)) name = `${base} ${i++}`;
-    used.add(name);
-    byId.set(el.id, name);
+    if (NAMED_TYPES.has(el.elementType)) {
+      byId.set(el.id, namesInUse.claim(writtenName(el.label, el.elementType)));
+    } else if (el.elementType === "pipeline") {
+      byId.set(el.id, writtenName(el.label, el.elementType));
+    }
+  }
+  return byId;
+}
+function urlDefinitionNames(map, nameOf, keptDefinitionNames) {
+  const namesInUse = new UniqueNames();
+  for (const name of keptDefinitionNames) namesInUse.claim(name);
+  const byId = /* @__PURE__ */ new Map();
+  for (const el of map.elements) {
+    if (!urlOf(el)) continue;
+    const readable = nameOf(el).replace(/[()[\]<>]/g, " ").replace(/\s+/g, " ").trim();
+    byId.set(el.id, namesInUse.claim(`${readable} URL`.trim()));
   }
   return byId;
 }
@@ -879,30 +1629,75 @@ function decoratorSuffix(dec) {
   if (dec.inertia) out += " inertia";
   return out;
 }
-function serializeDSL(map) {
-  const lines = [];
-  const names = uniqueNames(map);
-  const nameOf = (el) => names.get(el.id) ?? el.label;
-  lines.push(`title ${map.config.title}`);
-  if (map.config.style) lines.push(`style ${map.config.style}`);
-  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) {
-    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;
+function configLines(config) {
+  const lines = [`title ${writtenText(config.title)}`];
+  if (config.style) lines.push(`style ${config.style}`);
+  if (config.size) lines.push(`size [${r(config.size.width)}, ${r(config.size.height)}]`);
+  if (config.evolutionLabels) {
+    lines.push(`evolution ${config.evolutionLabels.map(writtenText).join("->")}`);
+  }
+  if (config.yAxisLabel) {
+    const ends = config.yAxisEndLabels;
+    const endLabels = ends ? `->${writtenText(ends[0])}->${writtenText(ends[1])}` : "";
+    lines.push(`y-axis ${writtenText(config.yAxisLabel)}${endLabels}`);
+  }
+  if (config.annotationsBoxPosition) {
+    const b = config.annotationsBoxPosition;
     lines.push(`annotations [${r(b.visibility)}, ${r(b.evolution)}]`);
   }
-  const urlDefNames = /* @__PURE__ */ new Map();
+  return lines;
+}
+function passthroughLines(map) {
+  const emitted = /* @__PURE__ */ new Set();
+  if (map.config.evolutionLabels) emitted.add("evolution");
+  if (map.config.yAxisLabel) emitted.add("y-axis");
+  const comments = new CommentStripper();
+  const lines = [];
+  const urlDefinitionNames2 = [];
+  for (const raw of map.rawPassthrough ?? []) {
+    const code = comments.strip(raw).code;
+    const keyword = keywordOf(code);
+    if (emitted.has(keyword)) continue;
+    lines.push(raw);
+    const definition = keyword === "url" ? readUrlDefinition(code.trim().slice(3)) : null;
+    if (definition) urlDefinitionNames2.push(definition.name);
+  }
+  return { lines, urlDefinitionNames: urlDefinitionNames2 };
+}
+function pipelineHeights(map, pipelineIds, nameOf) {
+  const componentVisibilityByName = /* @__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}]`);
+    if (el.elementType !== "component") continue;
+    const isChild = !!el.pipelineId && pipelineIds.has(el.pipelineId);
+    if (!isChild) componentVisibilityByName.set(nameOf(el), el.position.visibility);
+  }
+  return (el) => {
+    if (el.elementType !== "pipeline") return "";
+    const derived = componentVisibilityByName.get(nameOf(el)) ?? 0.5;
+    const written = r(el.position.visibility);
+    return written !== r(derived) ? ` (y ${written})` : "";
+  };
+}
+function edgeLines(map, nameOf) {
+  const namesById = new Map(map.elements.map((el) => [el.id, nameOf(el)]));
+  return map.edges.map((edge) => {
+    const from = namesById.get(edge.from) ?? edge.from;
+    const to = namesById.get(edge.to) ?? edge.to;
+    const annotation = edge.label ? `; ${writtenText(edge.label)}` : "";
+    if (edge.edgeType === "dependency") return `${from} -> ${to}${annotation}`;
+    const op = edge.flowValue ? `+'${edge.flowValue}'${edge.bidirectional ? "<>" : ">"}` : edge.bidirectional ? "+<>" : "+>";
+    return `${from} ${op} ${to}${annotation}`;
+  });
+}
+function serializeDSL(map) {
+  const names = uniqueNames(map);
+  const nameOf = (el) => names.get(el.id) ?? writtenText(el.label);
+  const passthrough = passthroughLines(map);
+  const lines = configLines(map.config);
+  const urlDefNames = urlDefinitionNames(map, nameOf, passthrough.urlDefinitionNames);
+  for (const el of map.elements) {
+    const defName = urlDefNames.get(el.id);
+    if (defName) lines.push(`url ${defName} [${urlOf(el)}]`);
   }
   const urlSuffix = (el) => {
     const def = urlDefNames.get(el.id);
@@ -920,61 +1715,28 @@ function serializeDSL(map) {
     list.push(el);
     childrenByPipeline.set(el.pipelineId, list);
   }
-  const isPipelineChild = (el) => el.elementType === "component" && !!el.pipelineId && pipelineIds.has(el.pipelineId);
+  const pipelineHeight = pipelineHeights(map, pipelineIds, nameOf);
   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) {
     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) ?? 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}`);
-    } else {
-      const op = edge.flowValue ? `+'${edge.flowValue}'${edge.bidirectional ? "<>" : ">"}` : edge.bidirectional ? "+<>" : "+>";
-      lines.push(`${from} ${op} ${to}${annotation}`);
+    if (el.elementType === "component" && el.pipelineId && pipelineIds.has(el.pipelineId)) {
+      continue;
     }
-  }
-  if (map.rawPassthrough) {
-    const emitted = /* @__PURE__ */ new Set();
-    if (map.config.evolutionLabels) emitted.add("evolution");
-    if (map.config.yAxisLabel) emitted.add("y-axis");
-    for (const raw of map.rawPassthrough) {
-      if (emitted.has(raw.trim().split(/\s+/)[0])) continue;
-      lines.push(raw);
+    lines.push(elementLine(el, nameOf(el)) + pipelineHeight(el) + urlSuffix(el));
+    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("}");
     }
   }
-  return lines.join("\n") + "\n";
+  return [...lines, ...evolveLines, ...edgeLines(map, nameOf), ...passthrough.lines, ""].join("\n");
 }
 function elementLine(el, name) {
   const p = el.position;
@@ -984,14 +1746,14 @@ function elementLine(el, name) {
     case "component":
       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)}]${colorSuffix(el)}`;
+      return `note ${writtenNoteText(el.label)} [${r(p.visibility)}, ${r(p.evolution)}]${colorSuffix(el)}`;
     case "pipeline":
       return `pipeline ${name} [${r(el.evolutionStart)}, ${r(el.evolutionEnd)}]${colorSuffix(el)}`;
     case "submap":
       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}`;
+      return `annotation ${el.number} ${pos}${colorSuffix(el)} ${writtenText(el.text)}`;
     }
     case "accelerator":
       return `${el.direction === "deaccelerate" ? "deaccelerator" : "accelerator"} ${name} [${r(p.visibility)}, ${r(p.evolution)}]${colorSuffix(el)}`;
@@ -1007,7 +1769,7 @@ function elementLine(el, name) {
 }
 function evolveLine(el, name) {
   const mv = el.movement;
-  const label = mv.newLabel ? `${name}->${mv.newLabel}` : name;
+  const label = mv.newLabel ? `${name}->${writtenText(mv.newLabel)}` : name;
   const method = mv.method ? ` (${mv.method})` : "";
   return `evolve ${label} ${r(mv.targetEvolution)}${method}${offsetSuffix(mv.labelOffset)}`;
 }