@miragon/wardley-dsl 0.5.2 → 0.6.0

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,172 @@ 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" };
+}
+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 LABEL_OFFSET_RE = /\blabel\s*\[\s*([-\d.]+)\s*,\s*([-\d.]+)\s*\]/i;
+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;
+  }
+  /** Takes a name as it is, even when it is already taken (a name the source text already uses). */
+  reserve(name) {
+    this.used.add(name);
+  }
+};
+
 // src/parser.ts
 function splitDependency(core) {
   const arrow = core.indexOf("->");
@@ -153,7 +390,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 +401,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, built) {
+  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") {
+      const edge2 = compact({
+        id: `dep_${++dependencies}`,
+        edgeType: "dependency",
+        from: fromId,
+        to: toId,
+        label: labelOf(link)
+      });
+      edges.push(edge2);
+      built(edge2, link);
+      continue;
+    }
+    const [from, to] = link.reverse ? [toId, fromId] : [fromId, toId];
+    const edge = compact({
+      id: `flow_${++flows}`,
+      edgeType: "flow",
+      from,
+      to,
+      bidirectional: link.bidirectional ? true : void 0,
+      flowValue: link.flowValue,
+      label: labelOf(link)
+    });
+    edges.push(edge);
+    built(edge, link);
+  }
+  return edges;
+}
 var IdAllocator = class {
   used = /* @__PURE__ */ new Set();
   alloc(prefix, label) {
@@ -185,612 +521,1122 @@ 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
-      });
+  return readMap(text).result;
+}
+function parseDSLWithSourceMap(text) {
+  const reading = readMap(text);
+  return { ...reading.result, sourceMap: reading.sourceMap };
+}
+function readMap(text) {
+  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) : reading;
+}
+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: wardleySchemaModel.DEFAULT_MAP_TITLE };
+  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 = "";
+  declarationLineById = /* @__PURE__ */ new Map();
+  configLinesByKeyword = /* @__PURE__ */ new Map();
+  evolveLinesById = /* @__PURE__ */ new Map();
+  methodLinesById = /* @__PURE__ */ new Map();
+  blockLines = /* @__PURE__ */ new Map();
+  pipelineIds = /* @__PURE__ */ new Map();
+  rangeFromChildren = /* @__PURE__ */ new Set();
+  addElement(element, line = this.lineNo) {
+    this.elements.push(element);
+    this.declarationLineById.set(element.id, line);
+  }
+  recordBlockLine(pipeline, end) {
+    const lines = this.blockLines.get(pipeline) ?? {};
+    lines[end] = this.lineNo;
+    this.blockLines.set(pipeline, lines);
+  }
+  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);
+    const configLines2 = this.configLinesByKeyword.get(keyword) ?? [];
+    configLines2.push(this.lineNo);
+    this.configLinesByKeyword.set(keyword, configLines2);
+    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;
-    }
-    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;
+  }
+  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 (line.startsWith("{")) {
-      if (lastPipeline) {
-        blockPipeline = lastPipeline;
-        lastPipeline = null;
-        continue;
+    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);
+    }
+    return name;
+  }
+  openBlock() {
+    if (this.lastPipeline) {
+      this.blockPipeline = this.lastPipeline;
+      this.recordBlockLine(this.blockPipeline, "open");
+      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.recordBlockLine(this.blockPipeline, "close");
+      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());
+    }
+    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) {
+      this.recordBlockLine(this.blockPipeline, "close");
+      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 } : {}
-    };
-    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,
-      labelOffset: ev.labelOffset
+      elementType: "anchor",
+      label,
+      position: this.position(node.coords.a, node.coords.b),
+      labelOffset: node.labelOffset,
+      color: node.color
     });
-    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;
-    }
-    elements[idx] = { ...el, decorators: { ...el.decorators, method: pm.method } };
+    this.addElement(anchor);
+    this.register(node.name, label, id);
   }
-  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 };
+  /** `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.addElement(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.addElement(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: []
+    };
+    this.pendingPipeline.push(pending);
+    if (opensBlock) {
+      this.blockPipeline = pending;
+      this.recordBlockLine(pending, "open");
+      this.blockOpening = { line: this.lineNo, text: this.currentLine };
+    } else this.lastPipeline = pending;
   }
-  for (const [name, address] of urlDefs) {
-    if (!usedUrlDefs.has(name)) rawPassthrough.push(`url ${name} [${address}]`);
+  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
+    });
   }
-  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
-      );
-      continue;
+  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);
     }
-    if (link.kind === "dependency") {
-      edges.push(
-        compact({
-          id: `dep_${++depN}`,
-          edgeType: "dependency",
-          from: fromId,
-          to: toId,
-          label: link.label
-        })
+    this.reportTextBefore(split.name);
+    readSuffix(split.suffix, NO_SUFFIXES, this.report);
+    this.setConfig("size", { ...this.config, size: { width: coords.a, height: coords.b } });
+    const problem = sizeOutsideLimits(coords.a, coords.b);
+    if (problem) this.diag(problem);
+    if (!Number.isInteger(coords.a) || !Number.isInteger(coords.b)) {
+      this.diag(
+        `Map size ${coords.a}\xD7${coords.b} is not in whole pixels \u2014 OWM only reads whole-pixel sizes`
       );
+    }
+  }
+  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 [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 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 } : {}
+    });
+    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}"`);
+    }
+  }
+  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 });
   }
-  const map = compact({
-    schemaVersion: wardleySchemaModel.CURRENT_SCHEMA_VERSION,
-    config,
-    elements,
-    edges,
-    rawPassthrough: rawPassthrough.length ? rawPassthrough : void 0
-  });
-  return { map: wardleySchemaModel.validateMap(map), diagnostics };
-}
-function parseNode(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);
-  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
+  /** `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.addElement(annotation);
+  }
+  /** 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.addElement(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.addElement(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.addElement(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.addElement(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 urlReferences = /* @__PURE__ */ new Map();
+    const usedDefinitions = /* @__PURE__ */ new Set();
+    const keptDefinitions = resolveUrlReferences(
+      this.elements,
+      this.pendingUrlRefs,
+      this.urlDefinitions,
+      this.reportAt,
+      (element, definition) => {
+        if (definition) usedDefinitions.add(definition);
+        urlReferences.set(
+          element.id,
+          definition ? { kind: "definition", name: definition.name } : { kind: "embedded" }
+        );
+      }
+    );
+    for (const definition of keptDefinitions) {
+      this.keepLine(
+        `url ${definition.name} [${definition.address}]`,
+        definition.lineNo,
+        definition.text
+      );
+    }
+    const declaredNames = /* @__PURE__ */ new Set([...this.idBySourceName.keys(), ...this.idByElementName.keys()]);
+    const edgeLineById = /* @__PURE__ */ new Map();
+    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),
+      (edge, link) => edgeLineById.set(edge.id, link.lineNo)
+    );
+    const kept = this.passthrough.filter((_, index) => !removedFromPassthrough.has(index));
+    const rawPassthrough = withoutClosersOfKeptComments(kept, this.reportAt);
+    const sourceMap = this.sourceMap({
+      removedFromPassthrough,
+      usedDefinitions,
+      urlReferences,
+      edgeLineById,
+      kept
+    });
+    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 },
+      sourceMap,
+      declaredNames,
+      keywordLinks: this.keywordLinks
+    };
+  }
+  sourceMap(parts) {
+    const primaryLineOf = /* @__PURE__ */ new Map();
+    const secondaryLinesOf = /* @__PURE__ */ new Map();
+    const addSecondary = (key, line) => {
+      const lines = secondaryLinesOf.get(key) ?? [];
+      lines.push(line);
+      secondaryLinesOf.set(key, lines);
+    };
+    const addRepeated = (key, lines) => {
+      if (!lines?.length) return;
+      primaryLineOf.set(key, lines[lines.length - 1]);
+      for (const line of lines.slice(0, -1)) addSecondary(key, line);
+    };
+    for (const [keyword, lines] of this.configLinesByKeyword) {
+      addRepeated(`config:${keyword}`, lines);
+    }
+    for (const unused of this.unusedConfigLines) {
+      if (parts.removedFromPassthrough.has(unused.index)) {
+        addSecondary(`config:${unused.keyword}`, unused.line);
+      }
+    }
+    for (const definition of parts.usedDefinitions) {
+      primaryLineOf.set(`url:${definition.name}`, definition.lineNo);
+    }
+    for (const el of this.elements) {
+      const isChild = el.elementType === "component" && el.pipelineId !== void 0;
+      const key = `${isChild ? "child" : "element"}:${el.id}`;
+      const line = this.declarationLineById.get(el.id);
+      if (line !== void 0) primaryLineOf.set(key, line);
+      for (const methodLine of this.methodLinesById.get(el.id) ?? []) addSecondary(key, methodLine);
+      addRepeated(`evolve:${el.id}`, this.evolveLinesById.get(el.id));
+    }
+    for (const [id, line] of parts.edgeLineById) primaryLineOf.set(`edge:${id}`, line);
+    const blocks = /* @__PURE__ */ new Map();
+    for (const [pipeline, lines] of this.blockLines) {
+      const id = this.pipelineIds.get(pipeline);
+      if (id !== void 0) blocks.set(id, lines);
+    }
+    return {
+      primaryLineOf,
+      secondaryLinesOf,
+      passthrough: parts.kept.map((entry) => ({ line: entry.lineNo, isComment: entry.isComment })),
+      blocks,
+      rangeFromChildren: this.rangeFromChildren,
+      urlReferences: parts.urlReferences
+    };
+  }
+  /**
+   * 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);
+      this.pipelineIds.set(p, id);
+      if (writtenRange.fromChildren) this.rangeFromChildren.add(id);
+      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)
+      );
+      const { pipeline, children } = pipelineElements(
+        { ...p, name: label },
+        id,
+        visibility,
+        range,
+        this.ids,
+        childNames
+      );
+      this.addElement(pipeline, p.lineNo);
+      children.forEach((child, index) => {
+        this.addElement(child, p.children[index].lineNo);
+        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 evolveLines = this.evolveLinesById.get(component.id) ?? [];
+      evolveLines.push(ev.lineNo);
+      this.evolveLinesById.set(component.id, evolveLines);
+      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 };
+    }
+  }
+  /** 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 } };
+      const methodLines = this.methodLinesById.get(el.id) ?? [];
+      methodLines.push(pm.lineNo);
+      this.methodLinesById.set(el.id, methodLines);
+    }
+  }
+};
+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;
   });
 }
-function clamp01(n) {
-  return n < 0 ? 0 : n > 1 ? 1 : n;
+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;
 }
-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 resolveUrlReferences(elements, refs, definitions, report, resolved) {
+  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 };
+    resolved(el, definition);
+  }
+  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 suffix = readSuffix(split.suffix, suffixes, report, "after the coordinates", keywordMethod);
+  return compact({
+    name: split.name,
+    coords: split.coords,
+    decorators: suffix.decorators,
+    labelOffset: suffix.labelOffset,
+    urlRef: suffix.urlRef,
+    color: suffix.color
+  });
+}
+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 });
+}
+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 +1644,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 +1657,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,10 +1694,21 @@ function parseEvolve(after) {
     name,
     newLabel: newLabel || void 0,
     target,
-    method: dec.decorators.method,
+    method: tail.decorators.method,
     labelOffset: lo.labelOffset ?? void 0
   });
 }
+function sizeOutsideLimits(width, height) {
+  const below = width < wardleySchemaModel.PLOT_MIN.width || height < wardleySchemaModel.PLOT_MIN.height;
+  const above = width > wardleySchemaModel.PLOT_MAX.width || height > wardleySchemaModel.PLOT_MAX.height;
+  if (!below && !above) return null;
+  const drawnWidth = wardleySchemaModel.drawnPlotLength(width, "width");
+  const drawnHeight = wardleySchemaModel.drawnPlotLength(height, "height");
+  const minimum = `${wardleySchemaModel.PLOT_MIN.width}\xD7${wardleySchemaModel.PLOT_MIN.height}`;
+  const maximum = `${wardleySchemaModel.PLOT_MAX.width}\xD7${wardleySchemaModel.PLOT_MAX.height}`;
+  const limit = below && above ? `outside ${minimum} to ${maximum}` : below ? `below the minimum ${minimum}` : `above the maximum ${maximum}`;
+  return `Map size ${width}\xD7${height} is ${limit} \u2014 drawn at ${drawnWidth}\xD7${drawnHeight}`;
+}
 
 // src/serializer.ts
 function urlOf(el) {
@@ -842,26 +1717,59 @@ 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;
 }
+var EMBEDDABLE_ADDRESS_RE = /^[a-z][\w+.-]*:\/\/[^\s()]*$/i;
+function planUrls(map, nameOf, keptDefinitionNames, hints) {
+  const namesInUse = new UniqueNames();
+  for (const name of keptDefinitionNames) namesInUse.claim(name);
+  const addressByHintedName = /* @__PURE__ */ new Map();
+  const definitionNameById = /* @__PURE__ */ new Map();
+  const referenceById = /* @__PURE__ */ new Map();
+  for (const el of map.elements) {
+    const address = urlOf(el);
+    const hint = hints?.get(el.id);
+    if (!address || !hint) continue;
+    if (hint.kind === "embedded") {
+      if (EMBEDDABLE_ADDRESS_RE.test(address)) referenceById.set(el.id, address);
+      continue;
+    }
+    const hintedAddress = addressByHintedName.get(hint.name);
+    if (hintedAddress === void 0) {
+      addressByHintedName.set(hint.name, address);
+      namesInUse.reserve(hint.name);
+    } else if (hintedAddress !== address) continue;
+    definitionNameById.set(el.id, hint.name);
+  }
+  const definitions = [];
+  const written = /* @__PURE__ */ new Set();
+  for (const el of map.elements) {
+    const address = urlOf(el);
+    if (!address || referenceById.has(el.id)) continue;
+    let name = definitionNameById.get(el.id);
+    if (name === void 0) {
+      const readable = nameOf(el).replace(/[()[\]<>]/g, " ").replace(/\s+/g, " ").trim();
+      name = namesInUse.claim(`${readable} URL`.trim());
+    }
+    referenceById.set(el.id, name);
+    if (written.has(name)) continue;
+    written.add(name);
+    definitions.push({ name, address });
+  }
+  return { definitions, referenceById };
+}
 function offsetSuffix(lo) {
   return lo ? ` label [${r(lo.dx)}, ${r(lo.dy)}]` : "";
 }
@@ -879,34 +1787,83 @@ function decoratorSuffix(dec) {
   if (dec.inertia) out += " inertia";
   return out;
 }
-function serializeDSL(map) {
+function configLines(config) {
+  const lines = [{ key: "config:title", text: `title ${writtenText(config.title)}` }];
+  const add = (keyword, text) => lines.push({ key: `config:${keyword}`, text });
+  if (config.style) add("style", `style ${config.style}`);
+  if (config.size) add("size", `size [${r(config.size.width)}, ${r(config.size.height)}]`);
+  if (config.evolutionLabels) {
+    add("evolution", `evolution ${config.evolutionLabels.map(writtenText).join("->")}`);
+  }
+  if (config.yAxisLabel) {
+    const ends = config.yAxisEndLabels;
+    const endLabels = ends ? `->${writtenText(ends[0])}->${writtenText(ends[1])}` : "";
+    add("y-axis", `y-axis ${writtenText(config.yAxisLabel)}${endLabels}`);
+  }
+  if (config.annotationsBoxPosition) {
+    const b = config.annotationsBoxPosition;
+    add("annotations", `annotations [${r(b.visibility)}, ${r(b.evolution)}]`);
+  }
+  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 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;
-    lines.push(`annotations [${r(b.visibility)}, ${r(b.evolution)}]`);
-  }
-  const urlDefNames = /* @__PURE__ */ new Map();
+  const urlDefinitionNames = [];
+  (map.rawPassthrough ?? []).forEach((raw, index) => {
+    const code = comments.strip(raw).code;
+    const keyword = keywordOf(code);
+    if (emitted.has(keyword)) return;
+    lines.push({ key: `raw:${index}`, text: raw });
+    const definition = keyword === "url" ? readUrlDefinition(code.trim().slice(3)) : null;
+    if (definition) urlDefinitionNames.push(definition.name);
+  });
+  return { lines, urlDefinitionNames };
+}
+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)}` : "";
+    const key = `edge:${edge.id}`;
+    if (edge.edgeType === "dependency") return { key, text: `${from} -> ${to}${annotation}` };
+    const op = edge.flowValue ? `+'${edge.flowValue}'${edge.bidirectional ? "<>" : ">"}` : edge.bidirectional ? "+<>" : "+>";
+    return { key, text: `${from} ${op} ${to}${annotation}` };
+  });
+}
+function serializeDSL(map) {
+  return [...serializeKeyedLines(map).map((line) => line.text), ""].join("\n");
+}
+function serializeKeyedLines(map, hints = {}) {
+  const names = uniqueNames(map);
+  const nameOf = (el) => names.get(el.id) ?? writtenText(el.label);
+  const passthrough = passthroughLines(map);
+  const lines = configLines(map.config);
+  const urls = planUrls(map, nameOf, passthrough.urlDefinitionNames, hints.urlReferences);
+  for (const { name, address } of urls.definitions) {
+    lines.push({ key: `url:${name}`, text: `url ${name} [${address}]` });
   }
   const urlSuffix = (el) => {
-    const def = urlDefNames.get(el.id);
-    return def ? ` url(${def})` : "";
+    const reference = urls.referenceById.get(el.id);
+    return reference ? ` url(${reference})` : "";
   };
   const pipelineIds = new Set(
     map.elements.filter((e) => e.elementType === "pipeline").map((e) => e.id)
@@ -920,61 +1877,32 @@ 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("}");
-      }
+      evolveLines.push({ key: `evolve:${el.id}`, text: evolveLine(el, nameOf(el)) });
     }
-  }
-  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({
+      key: `element:${el.id}`,
+      text: elementLine(el, nameOf(el)) + pipelineHeight(el) + urlSuffix(el)
+    });
+    const kids = childrenByPipeline.get(el.id) ?? [];
+    if (kids.length) {
+      lines.push({ key: `block-open:${el.id}`, text: "{" });
+      for (const k of kids) {
+        lines.push({
+          key: `child:${k.id}`,
+          text: `  component ${nameOf(k)} [${r(k.position.evolution)}]${decoratorSuffix(k.decorators)}${colorSuffix(k)}${offsetSuffix(k.labelOffset)}`
+        });
+      }
+      lines.push({ key: `block-close:${el.id}`, text: "}" });
     }
   }
-  return lines.join("\n") + "\n";
+  return [...lines, ...evolveLines, ...edgeLines(map, nameOf), ...passthrough.lines];
 }
 function elementLine(el, name) {
   const p = el.position;
@@ -984,14 +1912,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,11 +1935,576 @@ 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)}`;
 }
 
+// src/patch.ts
+function patchDSL(originalText, map, options = {}) {
+  return patchDSLWithOutcome(originalText, map, options).text;
+}
+function patchDSLWithOutcome(originalText, map, options = {}) {
+  const original = typeof originalText === "string" ? originalText : "";
+  let canonical;
+  try {
+    canonical = serializeDSL(map);
+  } catch {
+    return { text: original, outcome: "unchanged" };
+  }
+  try {
+    const expected = fingerprint(parseDSL(canonical));
+    const source = readSource(original);
+    const edited = alignToSource(source.map, map, options.previous);
+    for (const mode of ["minimal", "rewrite"]) {
+      const text = patchLines(source, edited, mode);
+      if (text !== null && fingerprint(parseDSL(text)) === expected) {
+        return { text, outcome: mode === "minimal" ? "patched" : "rewritten" };
+      }
+    }
+    return { text: withLineBreaksOf(source, canonical), outcome: "serialized" };
+  } catch {
+    return { text: canonical, outcome: "serialized" };
+  }
+}
+function readSource(text) {
+  const lines = splitLines(text);
+  const parsed = parseDSLWithSourceMap(text);
+  const crlf = (text.match(/\r\n/g) ?? []).length;
+  const lf = (text.match(/\n/g) ?? []).length - crlf;
+  return {
+    lines,
+    shapes: shapeLines(lines),
+    map: parsed.map,
+    sourceMap: parsed.sourceMap,
+    lineBreak: crlf > lf ? "\r\n" : "\n",
+    endsWithLineBreak: text === "" || text.endsWith("\n")
+  };
+}
+function splitLines(text) {
+  const lines = [];
+  const lineBreaks = /\r?\n/g;
+  let start = 0;
+  for (let match = lineBreaks.exec(text); match; match = lineBreaks.exec(text)) {
+    lines.push({ text: text.slice(start, match.index), lineBreak: match[0] });
+    start = match.index + match[0].length;
+  }
+  if (start < text.length) lines.push({ text: text.slice(start), lineBreak: "" });
+  return lines;
+}
+function withoutTrailingCarriageReturns2(text) {
+  let end = text.length;
+  while (end > 0 && text.charCodeAt(end - 1) === 13) end--;
+  return text.slice(0, end);
+}
+function shapeLines(lines) {
+  const comments = new CommentStripper();
+  return lines.map(({ text }) => {
+    const raw = withoutTrailingCarriageReturns2(text);
+    const startsInBlockComment = comments.insideBlockComment;
+    let fragments = comments.strip(raw).comments;
+    let rest = raw;
+    let commentHead = "";
+    let commentTail = "";
+    let editable = true;
+    if (startsInBlockComment) {
+      const head = fragments[0];
+      if (head?.endsWith("*/") && raw.startsWith(head)) {
+        commentHead = head;
+        rest = raw.slice(head.length);
+        fragments = fragments.slice(1);
+      } else {
+        editable = false;
+      }
+    }
+    let codePart = rest;
+    if (editable && fragments.length) {
+      const comment = fragments[0];
+      if (fragments.length > 1 || !rest.endsWith(comment)) {
+        editable = false;
+      } else {
+        const beforeComment = rest.slice(0, rest.length - comment.length);
+        codePart = beforeComment.trimEnd();
+        commentTail = beforeComment.slice(codePart.length) + comment;
+      }
+    }
+    return {
+      indent: /^\s*/.exec(codePart)[0],
+      code: codePart.trim(),
+      commentHead,
+      commentTail,
+      editable,
+      endsInBlockComment: comments.insideBlockComment
+    };
+  });
+}
+function withLineBreaksOf(source, text) {
+  if (source.lines.length === 0) return text;
+  const withBreaks = source.lineBreak === "\n" ? text : text.replace(/\n/g, source.lineBreak);
+  return source.endsWithLineBreak ? withBreaks : withBreaks.replace(/\r?\n$/, "");
+}
+function identityOf(el) {
+  switch (el.elementType) {
+    case "annotation":
+      return `annotation\0${el.number}`;
+    case "attitude":
+      return `attitude\0${el.kind}`;
+    default:
+      return `${el.elementType}\0${el.label}`;
+  }
+}
+function edgeIdentityOf(edge) {
+  return `${edge.edgeType}\0${edge.from}\0${edge.to}`;
+}
+function matchElements(source, edited, hint = /* @__PURE__ */ new Map()) {
+  const unmatchedSource = new Map(source.elements.map((el) => [el.id, el]));
+  const idByEditedId = /* @__PURE__ */ new Map();
+  const claim = (editedId, sourceId) => {
+    idByEditedId.set(editedId, sourceId);
+    unmatchedSource.delete(sourceId);
+  };
+  const unclaimed = () => edited.elements.filter((el) => !idByEditedId.has(el.id));
+  for (const el of edited.elements) {
+    const same = unmatchedSource.get(el.id);
+    if (same && identityOf(same) === identityOf(el)) claim(el.id, el.id);
+  }
+  for (const el of unclaimed()) {
+    const hinted = hint.get(el.id);
+    const candidate = hinted === void 0 ? void 0 : unmatchedSource.get(hinted);
+    if (candidate?.elementType === el.elementType) claim(el.id, candidate.id);
+  }
+  const sourceIdsByIdentity = /* @__PURE__ */ new Map();
+  for (const el of unmatchedSource.values()) {
+    const ids = sourceIdsByIdentity.get(identityOf(el)) ?? [];
+    ids.push(el.id);
+    sourceIdsByIdentity.set(identityOf(el), ids);
+  }
+  for (const el of unclaimed()) {
+    const match = sourceIdsByIdentity.get(identityOf(el))?.shift();
+    if (match !== void 0) claim(el.id, match);
+  }
+  for (const el of unclaimed()) {
+    if (unmatchedSource.get(el.id)?.elementType === el.elementType) claim(el.id, el.id);
+  }
+  return idByEditedId;
+}
+function alignToSource(source, edited, previous) {
+  const hint = previous ? matchElements(source, previous) : void 0;
+  const idByEditedId = matchElements(source, edited, hint);
+  const usedIds = /* @__PURE__ */ new Set([...source.elements.map((el) => el.id), ...idByEditedId.values()]);
+  const freshId = (id) => {
+    let candidate = id;
+    for (let suffix = 2; usedIds.has(candidate); suffix++) candidate = `${id}~${suffix}`;
+    usedIds.add(candidate);
+    return candidate;
+  };
+  for (const el of edited.elements) {
+    if (!idByEditedId.has(el.id)) idByEditedId.set(el.id, freshId(el.id));
+  }
+  const rename = (id) => idByEditedId.get(id) ?? id;
+  const elements = edited.elements.map((el) => {
+    const renamed = { ...el, id: rename(el.id) };
+    if (renamed.elementType === "component" && renamed.pipelineId !== void 0) {
+      return { ...renamed, pipelineId: rename(renamed.pipelineId) };
+    }
+    if (renamed.elementType === "pipeline") {
+      return { ...renamed, childIds: renamed.childIds.map(rename) };
+    }
+    return renamed;
+  });
+  const edges = alignEdges(
+    source.edges,
+    edited.edges.map((edge) => ({ ...edge, from: rename(edge.from), to: rename(edge.to) }))
+  );
+  return {
+    ...edited,
+    elements: inSourceOrder(elements, source.elements),
+    edges: inSourceOrder(edges, source.edges)
+  };
+}
+function alignEdges(sourceEdges, editedEdges) {
+  const unmatchedSource = new Map(sourceEdges.map((edge) => [edge.id, edge]));
+  const idByIndex = /* @__PURE__ */ new Map();
+  const claim = (index, id) => {
+    idByIndex.set(index, id);
+    unmatchedSource.delete(id);
+  };
+  editedEdges.forEach((edge, index) => {
+    const same = unmatchedSource.get(edge.id);
+    if (same && edgeIdentityOf(same) === edgeIdentityOf(edge)) claim(index, edge.id);
+  });
+  editedEdges.forEach((edge, index) => {
+    if (idByIndex.has(index)) return;
+    const match = [...unmatchedSource.values()].find(
+      (candidate) => edgeIdentityOf(candidate) === edgeIdentityOf(edge)
+    );
+    if (match) claim(index, match.id);
+  });
+  editedEdges.forEach((edge, index) => {
+    if (idByIndex.has(index)) return;
+    if (unmatchedSource.get(edge.id)?.edgeType === edge.edgeType) claim(index, edge.id);
+  });
+  const usedIds = /* @__PURE__ */ new Set([...sourceEdges.map((edge) => edge.id), ...idByIndex.values()]);
+  return editedEdges.map((edge, index) => {
+    let id = idByIndex.get(index);
+    if (id === void 0) {
+      id = edge.id;
+      for (let suffix = 2; usedIds.has(id); suffix++) id = `${edge.id}~${suffix}`;
+      usedIds.add(id);
+    }
+    return { ...edge, id };
+  });
+}
+function inSourceOrder(items, sourceItems) {
+  const sourceIndex = new Map(sourceItems.map((item, index) => [item.id, index]));
+  const position = (item) => sourceIndex.get(item.id) ?? Number.POSITIVE_INFINITY;
+  return items.map((item, index) => ({ item, index })).sort((a, b) => position(a.item) - position(b.item) || a.index - b.index).map(({ item }) => item);
+}
+var isRawKey = (key) => key.startsWith("raw:");
+function keyedTexts(lines) {
+  return new Map(lines.filter((line) => !isRawKey(line.key)).map((line) => [line.key, line.text]));
+}
+function listsByLine(lineCount) {
+  return Array.from({ length: lineCount }, () => []);
+}
+function diffPassthrough(before, after) {
+  const remainingByText = /* @__PURE__ */ new Map();
+  for (const line of before.filter((entry) => isRawKey(entry.key))) {
+    const indexes = remainingByText.get(line.text) ?? [];
+    indexes.push(Number(line.key.slice("raw:".length)));
+    remainingByText.set(line.text, indexes);
+  }
+  const added = [];
+  for (const line of after.filter((entry) => isRawKey(entry.key))) {
+    if (remainingByText.get(line.text)?.shift() === void 0) added.push(line);
+  }
+  return { removed: new Set([...remainingByText.values()].flat()), added };
+}
+function pipelineOfEachChild(map) {
+  const pipelineById = /* @__PURE__ */ new Map();
+  for (const el of map.elements) {
+    if (el.elementType === "component" && el.pipelineId !== void 0) {
+      pipelineById.set(el.id, el.pipelineId);
+    }
+  }
+  return pipelineById;
+}
+function reparentedChildKeys(source, edited) {
+  const pipelineBefore = pipelineOfEachChild(source);
+  const keys = /* @__PURE__ */ new Set();
+  for (const [id, pipelineId] of pipelineOfEachChild(edited)) {
+    const previous = pipelineBefore.get(id);
+    if (previous !== void 0 && previous !== pipelineId) keys.add(`child:${id}`);
+  }
+  return keys;
+}
+function pipelinesNoLongerSpannedByChildren(edited, rangeFromChildren) {
+  const keys = /* @__PURE__ */ new Set();
+  if (rangeFromChildren.size === 0) return keys;
+  const evolutionsByPipeline = /* @__PURE__ */ new Map();
+  for (const el of edited.elements) {
+    if (el.elementType !== "component" || el.pipelineId === void 0) continue;
+    const evolutions = evolutionsByPipeline.get(el.pipelineId) ?? [];
+    evolutions.push(roundAsWritten(el.position.evolution));
+    evolutionsByPipeline.set(el.pipelineId, evolutions);
+  }
+  for (const el of edited.elements) {
+    if (el.elementType !== "pipeline" || !rangeFromChildren.has(el.id)) continue;
+    const evolutions = evolutionsByPipeline.get(el.id) ?? [];
+    const read = evolutions.length > 0 ? widenEmptyRange({ start: Math.min(...evolutions), end: Math.max(...evolutions) }) : void 0;
+    const spanned = read !== void 0 && read.start === roundAsWritten(el.evolutionStart) && read.end === roundAsWritten(el.evolutionEnd);
+    if (!spanned) keys.add(`element:${el.id}`);
+  }
+  return keys;
+}
+function patchLines(source, edited, mode) {
+  const { lines, shapes, sourceMap } = source;
+  const hints = { urlReferences: sourceMap.urlReferences };
+  const before = serializeKeyedLines(source.map, hints);
+  const after = serializeKeyedLines(edited, hints);
+  const textBefore = keyedTexts(before);
+  const textAfter = keyedTexts(after);
+  const passthrough = diffPassthrough(before, after);
+  const reparented = reparentedChildKeys(source.map, edited);
+  const unspanned = pipelinesNoLongerSpannedByChildren(edited, sourceMap.rangeFromChildren);
+  const statusOf = (key) => {
+    const written = textAfter.get(key);
+    if (written === void 0 || reparented.has(key)) return "deleted";
+    if (mode === "rewrite" || written !== textBefore.get(key) || unspanned.has(key)) {
+      return "changed";
+    }
+    return "same";
+  };
+  const primaryKeysByLine = listsByLine(lines.length);
+  for (const [key, line] of sourceMap.primaryLineOf) {
+    if (textBefore.has(key)) primaryKeysByLine[line - 1]?.push(key);
+  }
+  const secondaryKeysByLine = listsByLine(lines.length);
+  for (const [key, secondaryLines] of sourceMap.secondaryLinesOf) {
+    if (!textBefore.has(key)) continue;
+    for (const line of secondaryLines) secondaryKeysByLine[line - 1]?.push(key);
+  }
+  const passthroughByLine = listsByLine(lines.length);
+  sourceMap.passthrough.forEach((entry, index) => passthroughByLine[entry.line - 1]?.push(index));
+  const bracesByLine = listsByLine(lines.length);
+  for (const [pipelineId, block] of sourceMap.blocks) {
+    if (block.open !== void 0) {
+      bracesByLine[block.open - 1]?.push({ pipelineId, end: "open" });
+    }
+    if (block.close !== void 0) {
+      bracesByLine[block.close - 1]?.push({ pipelineId, end: "close" });
+    }
+  }
+  const braceRemoved = (pipelineId) => !textAfter.has(`block-open:${pipelineId}`) && (textBefore.has(`block-open:${pipelineId}`) || !textAfter.has(`element:${pipelineId}`));
+  const result = [];
+  for (let index = 0; index < lines.length; index++) {
+    const patched = patchLine(index);
+    if (patched === void 0) return null;
+    result.push(patched);
+  }
+  function patchLine(index) {
+    const line = lines[index];
+    const shape = shapes[index];
+    const primaries = primaryKeysByLine[index];
+    const removedPassthrough = passthroughByLine[index].filter(
+      (entry) => passthrough.removed.has(entry)
+    );
+    const braces = bracesByLine[index];
+    const changed = primaries.some((key) => statusOf(key) !== "same") || secondaryKeysByLine[index].some((key) => statusOf(key) !== "same") || removedPassthrough.length > 0 || braces.some((brace) => braceRemoved(brace.pipelineId));
+    if (!changed) return line.text;
+    if (!shape.editable || primaries.length > 1) return void 0;
+    if (removedPassthrough.some((entry) => sourceMap.passthrough[entry].isComment)) {
+      return void 0;
+    }
+    let statement = null;
+    const primary = primaries[0];
+    if (primary !== void 0) {
+      const status = statusOf(primary);
+      if (status === "changed") statement = textAfter.get(primary).trim();
+      else if (status === "deleted") statement = "";
+    } else if (secondaryKeysByLine[index].length || removedPassthrough.length) {
+      statement = "";
+    }
+    const open = braces.find((brace) => brace.end === "open");
+    const close = braces.find((brace) => brace.end === "close");
+    let rest = shape.code;
+    let prefix = "";
+    let suffix = "";
+    if (open && primary !== `element:${open.pipelineId}` && rest.startsWith("{")) {
+      prefix = braceRemoved(open.pipelineId) ? "" : "{";
+      rest = rest.slice(1).trimStart();
+    } else if (open && rest.endsWith("{")) {
+      suffix = braceRemoved(open.pipelineId) ? "" : "{";
+      rest = rest.slice(0, -1).trimEnd();
+    } else if (open) return void 0;
+    if (close && rest.endsWith("}") && !(open && suffix)) {
+      suffix = braceRemoved(close.pipelineId) ? "" : "}";
+      rest = rest.slice(0, -1).trimEnd();
+    } else if (close) return void 0;
+    const assembled = [prefix, statement ?? rest, suffix].filter(Boolean).join(" ");
+    if (assembled) return shape.commentHead + shape.indent + assembled + shape.commentTail;
+    if (shape.commentHead) return shape.commentHead + shape.commentTail;
+    return shape.commentTail ? shape.indent + shape.commentTail.trimStart() : null;
+  }
+  const insertions = planInsertions(source, edited, after, textBefore, textAfter, reparented);
+  if (!insertions) return null;
+  passthrough.added.forEach((line, index) => {
+    addInsertion(insertions, lines.length - 1, line.text, after.length + index);
+  });
+  return assemble(source, result, insertions);
+}
+function addInsertion(insertions, afterLine, text, order) {
+  const list = insertions.get(afterLine) ?? [];
+  list.push({ text, order });
+  insertions.set(afterLine, list);
+}
+function planInsertions(source, edited, after, textBefore, textAfter, reparented) {
+  const { lines, shapes, sourceMap } = source;
+  const lastLine = lines.length - 1;
+  const lineOf = (key) => {
+    const line = sourceMap.primaryLineOf.get(key);
+    return line === void 0 ? void 0 : line - 1;
+  };
+  const pipelineLineOf = (pipelineId) => lineOf(`element:${pipelineId}`);
+  const childLinesOf = (pipelineId) => source.map.elements.flatMap((el) => {
+    if (el.elementType !== "component" || el.pipelineId !== pipelineId) return [];
+    const line = lineOf(`child:${el.id}`);
+    return line === void 0 ? [] : [line];
+  });
+  const blockEndOf = (pipelineId) => {
+    const block = sourceMap.blocks.get(pipelineId);
+    if (block?.open === void 0 || pipelineLineOf(pipelineId) === void 0) return void 0;
+    if (block.close !== void 0) return block.close - 1;
+    return Math.max(block.open - 1, ...childLinesOf(pipelineId));
+  };
+  const anchorInBlock = (pipelineId) => {
+    const block = sourceMap.blocks.get(pipelineId);
+    let anchor;
+    if (block.close === void 0) anchor = blockEndOf(pipelineId);
+    else if (block.close !== block.open && shapes[block.close - 1].code === "}") {
+      anchor = block.close - 2;
+    } else return null;
+    return shapes[anchor]?.endsInBlockComment ? null : anchor;
+  };
+  const hasSourceBlock = (pipelineId) => blockEndOf(pipelineId) !== void 0;
+  const endOf = (key) => {
+    const line = lineOf(key);
+    if (line === void 0 || !key.startsWith("element:")) return line;
+    return Math.max(line, blockEndOf(key.slice("element:".length)) ?? line);
+  };
+  const sourceElementTypes = new Map(source.map.elements.map((el) => [el.id, el.elementType]));
+  const editedElementById = new Map(edited.elements.map((el) => [el.id, el]));
+  const lastLineOf = (accepts) => {
+    let last;
+    for (const key of sourceMap.primaryLineOf.keys()) {
+      if (!accepts(key) || !textBefore.has(key)) continue;
+      const end = endOf(key);
+      if (end !== void 0 && (last === void 0 || end > last)) last = end;
+    }
+    return last;
+  };
+  const isElementOfType = (type) => (key) => key.startsWith("element:") && sourceElementTypes.get(key.slice("element:".length)) === type;
+  const startsWith = (prefix) => (key) => key.startsWith(prefix);
+  const settle = (line) => {
+    if (line < 0) return -1;
+    let settled = line;
+    for (const pipelineId of sourceMap.blocks.keys()) {
+      const start = pipelineLineOf(pipelineId);
+      const end = blockEndOf(pipelineId);
+      if (start === void 0 || end === void 0) continue;
+      if (settled >= start && settled < end) settled = end;
+    }
+    while (settled < lastLine && shapes[settled].endsInBlockComment) settled++;
+    return settled;
+  };
+  const firstOf = (...candidates) => {
+    for (const candidate of candidates) if (candidate !== void 0) return candidate;
+    return lastLine;
+  };
+  const needsInsertion = (key) => reparented.has(key) || !sourceMap.primaryLineOf.has(key) && textBefore.get(key) !== textAfter.get(key);
+  const anchorOfElement = (id) => {
+    const type = editedElementById.get(id)?.elementType ?? "";
+    return settle(
+      firstOf(
+        lastLineOf(isElementOfType(type)),
+        lastLineOf(startsWith("element:")),
+        lastLineOf(startsWith("url:")),
+        lastLineOf(startsWith("config:"))
+      )
+    );
+  };
+  const anchorOfNewBlock = (pipelineId) => pipelineLineOf(pipelineId) ?? anchorOfElement(pipelineId);
+  const insertions = /* @__PURE__ */ new Map();
+  for (let order = 0; order < after.length; order++) {
+    const { key, text } = after[order];
+    if (isRawKey(key)) continue;
+    const separator = key.indexOf(":");
+    const kind = key.slice(0, separator);
+    const id = key.slice(separator + 1);
+    let anchor;
+    if (kind === "block-open" || kind === "block-close") {
+      if (textBefore.has(`block-open:${id}`)) continue;
+      if (hasSourceBlock(id)) {
+        if (anchorInBlock(id) === null) return null;
+        continue;
+      }
+      anchor = anchorOfNewBlock(id);
+    } else if (!needsInsertion(key)) {
+      continue;
+    } else if (kind === "config") {
+      anchor = settle(firstOf(lastLineOf(startsWith("config:")), -1));
+    } else if (kind === "url") {
+      const lastUrl = lastLineOf(startsWith("url:"));
+      anchor = settle(firstOf(lastUrl, lastLineOf(startsWith("config:")), -1));
+    } else if (kind === "element") {
+      anchor = anchorOfElement(id);
+    } else if (kind === "child") {
+      const child = editedElementById.get(id);
+      const pipelineId = child?.elementType === "component" ? child.pipelineId : void 0;
+      if (pipelineId === void 0) return null;
+      anchor = hasSourceBlock(pipelineId) ? anchorInBlock(pipelineId) : anchorOfNewBlock(pipelineId);
+    } else if (kind === "evolve") {
+      anchor = settle(firstOf(lastLineOf(startsWith("evolve:")), endOf(`element:${id}`)));
+    } else if (kind === "edge") {
+      anchor = settle(firstOf(lastLineOf(startsWith("edge:"))));
+    } else return null;
+    if (anchor === null) return null;
+    addInsertion(insertions, anchor, text, order);
+  }
+  return insertions;
+}
+function assemble(source, result, insertions) {
+  const output = [];
+  const insertAfter = (line) => {
+    const list = [...insertions.get(line) ?? []].sort((a, b) => a.order - b.order);
+    for (const { text } of list) output.push({ text, lineBreak: "" });
+  };
+  insertAfter(-1);
+  result.forEach((text, index) => {
+    if (text !== null) output.push({ text, lineBreak: source.lines[index].lineBreak });
+    insertAfter(index);
+  });
+  return output.map(({ text, lineBreak }, index) => {
+    const isLast = index === output.length - 1;
+    if (isLast && !source.endsWithLineBreak) return text;
+    return text + (lineBreak || source.lineBreak);
+  }).join("");
+}
+function normalized(value) {
+  if (typeof value === "number") return roundAsWritten(value);
+  if (Array.isArray(value)) return value.map(normalized);
+  if (value !== null && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).filter(([, entry]) => entry !== void 0).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key, entry]) => [key, normalized(entry)])
+    );
+  }
+  return value;
+}
+function fingerprint(map) {
+  const elementById = new Map(map.elements.map((el) => [el.id, el]));
+  const reference = (id) => {
+    const el = elementById.get(id);
+    return el ? `${el.elementType}:${el.label}` : `?${id}`;
+  };
+  const entries = [`config ${JSON.stringify(normalized(map.config))}`];
+  for (const el of map.elements) {
+    const { id: _id, ...rest } = el;
+    const described = { ...rest };
+    if (el.elementType === "component" && el.pipelineId !== void 0) {
+      described["pipelineId"] = reference(el.pipelineId);
+    }
+    if (el.elementType === "pipeline") described["childIds"] = el.childIds.map(reference).sort();
+    entries.push(`element ${JSON.stringify(normalized(described))}`);
+  }
+  for (const edge of map.edges) {
+    const { id: _id, ...rest } = edge;
+    const described = { ...rest, from: reference(edge.from), to: reference(edge.to) };
+    entries.push(`edge ${JSON.stringify(normalized(described))}`);
+  }
+  for (const raw of map.rawPassthrough ?? []) entries.push(`raw ${raw}`);
+  return entries.sort().join("\n");
+}
+
+// src/raw-passthrough.ts
+function withoutRawStatements(rawPassthrough, keyword) {
+  if (!rawPassthrough) return rawPassthrough;
+  const wanted = keyword.toLowerCase();
+  const comments = new CommentStripper();
+  let changed = false;
+  const kept = [];
+  for (const raw of rawPassthrough) {
+    const stripped = comments.strip(raw);
+    if (keywordOf(stripped.code) !== wanted) {
+      kept.push(raw);
+      continue;
+    }
+    changed = true;
+    if (stripped.comments.length) kept.push(stripped.comments.join(" "));
+  }
+  if (!changed) return rawPassthrough;
+  return kept.length ? kept : void 0;
+}
+
 Object.defineProperty(exports, "loadMap", {
   enumerable: true,
   get: function () { return wardleySchemaModel.loadMap; }
@@ -1030,7 +2523,9 @@ exports.parseDSL = parseDSL;
 exports.parseDSLWithDiagnostics = parseDSLWithDiagnostics;
 exports.parseDecorators = parseDecorators;
 exports.parseLabelOffset = parseLabelOffset;
+exports.patchDSL = patchDSL;
 exports.serializeDSL = serializeDSL;
 exports.slug = slug;
+exports.withoutRawStatements = withoutRawStatements;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map