@miragon/wardley-dsl 0.5.3 → 0.7.0

package/dist/index.js

@@ -1,4 +1,4 @@
-import { validateMap, CURRENT_SCHEMA_VERSION } from '@miragon/wardley-schema-model';
+import { DEFAULT_MAP_TITLE, validateMap, PLOT_MIN, PLOT_MAX, drawnPlotLength, CURRENT_SCHEMA_VERSION } from '@miragon/wardley-schema-model';
 export { loadMap, parseMapJSON as mapFromJSON, serializeMap as mapToJSON } from '@miragon/wardley-schema-model';
 
 // src/parser.ts
@@ -356,6 +356,10 @@ var UniqueNames = class {
     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
@@ -463,7 +467,7 @@ function unknownStatementMessage(line) {
   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) {
+function buildEdges(links, idOfName, unresolved, labelOf, built) {
   let dependencies = 0;
   let flows = 0;
   const edges = [];
@@ -475,29 +479,29 @@ function buildEdges(links, idOfName, unresolved, labelOf) {
       continue;
     }
     if (link.kind === "dependency") {
-      edges.push(
-        compact({
-          id: `dep_${++dependencies}`,
-          edgeType: "dependency",
-          from: fromId,
-          to: toId,
-          label: labelOf(link)
-        })
-      );
+      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];
-    edges.push(
-      compact({
-        id: `flow_${++flows}`,
-        edgeType: "flow",
-        from,
-        to,
-        bidirectional: link.bidirectional ? true : void 0,
-        flowValue: link.flowValue,
-        label: labelOf(link)
-      })
-    );
+    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;
 }
@@ -516,11 +520,18 @@ function parseDSL(text) {
   return parseDSLWithDiagnostics(text).map;
 }
 function parseDSLWithDiagnostics(text) {
+  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).result : reading.result;
+  return needsDeclaredNames ? new MapReader(reading.declaredNames).read(text) : reading;
 }
 var MapReader = class {
   constructor(linkNames) {
@@ -540,7 +551,7 @@ var MapReader = class {
   pendingEvolve = [];
   pendingPipeline = [];
   pendingMethod = [];
-  config = { title: "Untitled Map" };
+  config = { title: DEFAULT_MAP_TITLE };
   lineThatSetConfig = /* @__PURE__ */ new Map();
   unusedConfigLines = [];
   annotationCounter = 0;
@@ -553,6 +564,22 @@ var MapReader = class {
   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) {
@@ -567,7 +594,7 @@ var MapReader = class {
   }
   /** 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)");
+    this.keep(line, "Line not understood \u2014 kept as written");
   }
   // 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
@@ -585,6 +612,9 @@ var MapReader = class {
       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) {
@@ -669,13 +699,16 @@ var MapReader = class {
   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.blockPipeline = null;
-    else this.diag('Ignored "}" \u2014 no pipeline block is open');
+    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() {
@@ -744,7 +777,10 @@ var MapReader = class {
     const closesBlock = this.blockPipeline !== null && statement.endsWith("}");
     if (closesBlock) statement = statement.slice(0, -1).trim();
     if (statement) this.readStatement(statement);
-    if (closesBlock) this.blockPipeline = null;
+    if (closesBlock && this.blockPipeline) {
+      this.recordBlockLine(this.blockPipeline, "close");
+      this.blockPipeline = null;
+    }
   }
   readStatement(line) {
     const kw = keywordOf(line);
@@ -837,7 +873,7 @@ var MapReader = class {
       labelOffset: node.labelOffset,
       color: node.color
     });
-    this.elements.push(anchor);
+    this.addElement(anchor);
     this.register(node.name, label, id);
   }
   /** `component`/`market`/`ecosystem` and `build`/`buy`/`outsource` lines with coordinates. */
@@ -857,7 +893,7 @@ var MapReader = class {
       decorators: Object.keys(decorators).length ? decorators : void 0,
       color: node.color
     });
-    this.elements.push(component);
+    this.addElement(component);
     if (node.urlRef) this.addUrlRef(node.urlRef);
     this.register(node.name, label, id);
     return true;
@@ -879,7 +915,7 @@ var MapReader = class {
       position: this.position(split.coords.a, split.coords.b),
       color
     });
-    this.elements.push(note);
+    this.addElement(note);
   }
   /** `pipeline X [s, e]`, `pipeline X` (block form, range from children) — optionally with `{` at the end. */
   readPipeline(line, after) {
@@ -917,6 +953,7 @@ var MapReader = class {
     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;
   }
@@ -949,6 +986,13 @@ var MapReader = class {
     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());
@@ -1021,7 +1065,7 @@ var MapReader = class {
       text,
       ...color ? { color } : {}
     };
-    this.elements.push(annotation);
+    this.addElement(annotation);
   }
   /** Project extension (freeform drawing): `line [[v,e], [v,e], …] (closed) (dashed) (color x)`. */
   readDrawing(line, after) {
@@ -1041,7 +1085,7 @@ var MapReader = class {
       ...suffix.strokeStyle ? { strokeStyle: suffix.strokeStyle } : {},
       ...suffix.color ? { color: suffix.color } : {}
     };
-    this.elements.push(drawing);
+    this.addElement(drawing);
   }
   /** Canonical OWM form: `<kind> [vis1, mat1, vis2, mat2]` (two corners, normalized). */
   readAttitude(line, after, kind) {
@@ -1051,7 +1095,7 @@ var MapReader = class {
     const { color } = readSuffix(split.after, ATTITUDE_SUFFIXES, this.report);
     const { a, b, c, d } = split.coords;
     const corners = [this.clamp(a), this.clamp(b), this.clamp(c), this.clamp(d)];
-    this.elements.push(makeAttitude(this.ids, kind, corners, color));
+    this.addElement(makeAttitude(this.ids, kind, corners, color));
   }
   /** OWM: `url Name [https://…]` — definition, referenced via `url(Name)` on elements. */
   readUrlDefinition(line, after) {
@@ -1087,7 +1131,7 @@ var MapReader = class {
       position: this.position(node.coords.a, node.coords.b),
       ...node.color ? { color: node.color } : {}
     };
-    this.elements.push(accelerator);
+    this.addElement(accelerator);
     this.register(node.name, label, id);
   }
   readSubmap(line, after) {
@@ -1102,7 +1146,7 @@ var MapReader = class {
       position: this.position(node.coords.a, node.coords.b),
       ...node.color ? { color: node.color } : {}
     };
-    this.elements.push(submap);
+    this.addElement(submap);
     if (node.urlRef) this.addUrlRef(node.urlRef);
     this.register(node.name, label, id);
   }
@@ -1116,11 +1160,20 @@ var MapReader = class {
     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
+      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(
@@ -1130,6 +1183,7 @@ var MapReader = class {
       );
     }
     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),
@@ -1137,10 +1191,18 @@ var MapReader = class {
         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)
+      (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: CURRENT_SCHEMA_VERSION,
       config: this.config,
@@ -1150,10 +1212,58 @@ var MapReader = class {
     });
     return {
       result: { map: 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.
@@ -1191,6 +1301,8 @@ var MapReader = class {
       }
       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);
       }
@@ -1205,9 +1317,9 @@ var MapReader = class {
         this.ids,
         childNames
       );
-      this.elements.push(pipeline);
+      this.addElement(pipeline, p.lineNo);
       children.forEach((child, index) => {
-        this.elements.push(child);
+        this.addElement(child, p.children[index].lineNo);
         this.register(p.children[index].name, child.label, child.id);
       });
     }
@@ -1235,6 +1347,9 @@ var MapReader = class {
         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),
@@ -1260,6 +1375,9 @@ var MapReader = class {
         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);
     }
   }
 };
@@ -1301,7 +1419,7 @@ function replacedConfigLines(unusedLines, config, report) {
   }
   return replacedIndexes;
 }
-function resolveUrlReferences(elements, refs, definitions, report) {
+function resolveUrlReferences(elements, refs, definitions, report, resolved) {
   const definitionByName = /* @__PURE__ */ new Map();
   const replaced = /* @__PURE__ */ new Set();
   for (const definition of definitions) {
@@ -1328,6 +1446,7 @@ function resolveUrlReferences(elements, refs, definitions, report) {
     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));
 }
@@ -1578,6 +1697,17 @@ function parseEvolve(after, report) {
     labelOffset: lo.labelOffset ?? void 0
   });
 }
+function sizeOutsideLimits(width, height) {
+  const below = width < PLOT_MIN.width || height < PLOT_MIN.height;
+  const above = width > PLOT_MAX.width || height > PLOT_MAX.height;
+  if (!below && !above) return null;
+  const drawnWidth = drawnPlotLength(width, "width");
+  const drawnHeight = drawnPlotLength(height, "height");
+  const minimum = `${PLOT_MIN.width}\xD7${PLOT_MIN.height}`;
+  const maximum = `${PLOT_MAX.width}\xD7${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) {
@@ -1600,16 +1730,44 @@ function uniqueNames(map) {
   }
   return byId;
 }
-function urlDefinitionNames(map, nameOf, keptDefinitionNames) {
+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 byId = /* @__PURE__ */ new Map();
+  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) {
-    if (!urlOf(el)) continue;
-    const readable = nameOf(el).replace(/[()[\]<>]/g, " ").replace(/\s+/g, " ").trim();
-    byId.set(el.id, namesInUse.claim(`${readable} URL`.trim()));
+    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 byId;
+  return { definitions, referenceById };
 }
 function offsetSuffix(lo) {
   return lo ? ` label [${r(lo.dx)}, ${r(lo.dy)}]` : "";
@@ -1629,20 +1787,21 @@ function decoratorSuffix(dec) {
   return out;
 }
 function configLines(config) {
-  const lines = [`title ${writtenText(config.title)}`];
-  if (config.style) lines.push(`style ${config.style}`);
-  if (config.size) lines.push(`size [${r(config.size.width)}, ${r(config.size.height)}]`);
+  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) {
-    lines.push(`evolution ${config.evolutionLabels.map(writtenText).join("->")}`);
+    add("evolution", `evolution ${config.evolutionLabels.map(writtenText).join("->")}`);
   }
   if (config.yAxisLabel) {
     const ends = config.yAxisEndLabels;
     const endLabels = ends ? `->${writtenText(ends[0])}->${writtenText(ends[1])}` : "";
-    lines.push(`y-axis ${writtenText(config.yAxisLabel)}${endLabels}`);
+    add("y-axis", `y-axis ${writtenText(config.yAxisLabel)}${endLabels}`);
   }
   if (config.annotationsBoxPosition) {
     const b = config.annotationsBoxPosition;
-    lines.push(`annotations [${r(b.visibility)}, ${r(b.evolution)}]`);
+    add("annotations", `annotations [${r(b.visibility)}, ${r(b.evolution)}]`);
   }
   return lines;
 }
@@ -1652,16 +1811,16 @@ function passthroughLines(map) {
   if (map.config.yAxisLabel) emitted.add("y-axis");
   const comments = new CommentStripper();
   const lines = [];
-  const urlDefinitionNames2 = [];
-  for (const raw of map.rawPassthrough ?? []) {
+  const urlDefinitionNames = [];
+  (map.rawPassthrough ?? []).forEach((raw, index) => {
     const code = comments.strip(raw).code;
     const keyword = keywordOf(code);
-    if (emitted.has(keyword)) continue;
-    lines.push(raw);
+    if (emitted.has(keyword)) return;
+    lines.push({ key: `raw:${index}`, text: raw });
     const definition = keyword === "url" ? readUrlDefinition(code.trim().slice(3)) : null;
-    if (definition) urlDefinitionNames2.push(definition.name);
-  }
-  return { lines, urlDefinitionNames: urlDefinitionNames2 };
+    if (definition) urlDefinitionNames.push(definition.name);
+  });
+  return { lines, urlDefinitionNames };
 }
 function pipelineHeights(map, pipelineIds, nameOf) {
   const componentVisibilityByName = /* @__PURE__ */ new Map();
@@ -1683,24 +1842,27 @@ function edgeLines(map, nameOf) {
     const from = namesById.get(edge.from) ?? edge.from;
     const to = namesById.get(edge.to) ?? edge.to;
     const annotation = edge.label ? `; ${writtenText(edge.label)}` : "";
-    if (edge.edgeType === "dependency") return `${from} -> ${to}${annotation}`;
+    const 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 `${from} ${op} ${to}${annotation}`;
+    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 urlDefNames = urlDefinitionNames(map, nameOf, passthrough.urlDefinitionNames);
-  for (const el of map.elements) {
-    const defName = urlDefNames.get(el.id);
-    if (defName) lines.push(`url ${defName} [${urlOf(el)}]`);
+  const 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)
@@ -1718,24 +1880,28 @@ function serializeDSL(map) {
   const evolveLines = [];
   for (const el of map.elements) {
     if (el.elementType === "component" && el.movement) {
-      evolveLines.push(evolveLine(el, nameOf(el)));
+      evolveLines.push({ key: `evolve:${el.id}`, text: evolveLine(el, nameOf(el)) });
     }
     if (el.elementType === "component" && el.pipelineId && pipelineIds.has(el.pipelineId)) {
       continue;
     }
-    lines.push(elementLine(el, nameOf(el)) + pipelineHeight(el) + urlSuffix(el));
+    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("{");
+      lines.push({ key: `block-open:${el.id}`, text: "{" });
       for (const k of kids) {
-        lines.push(
-          `  component ${nameOf(k)} [${r(k.position.evolution)}]${decoratorSuffix(k.decorators)}${colorSuffix(k)}${offsetSuffix(k.labelOffset)}`
-        );
+        lines.push({
+          key: `child:${k.id}`,
+          text: `  component ${nameOf(k)} [${r(k.position.evolution)}]${decoratorSuffix(k.decorators)}${colorSuffix(k)}${offsetSuffix(k.labelOffset)}`
+        });
       }
-      lines.push("}");
+      lines.push({ key: `block-close:${el.id}`, text: "}" });
     }
   }
-  return [...lines, ...evolveLines, ...edgeLines(map, nameOf), ...passthrough.lines, ""].join("\n");
+  return [...lines, ...evolveLines, ...edgeLines(map, nameOf), ...passthrough.lines];
 }
 function elementLine(el, name) {
   const p = el.position;
@@ -1773,6 +1939,593 @@ function evolveLine(el, name) {
   return `evolve ${label} ${r(mv.targetEvolution)}${method}${offsetSuffix(mv.labelOffset)}`;
 }
 
-export { keywordOf, parseCoords, parseDSL, parseDSLWithDiagnostics, parseDecorators, parseLabelOffset, serializeDSL, slug };
+// 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/read-back-ids.ts
+var ELEMENT_KEY = /^(?:element|child):(.*)$/s;
+function elementIdOf(key) {
+  return ELEMENT_KEY.exec(key)?.[1];
+}
+function readBackIds(map) {
+  const lines = serializeKeyedLines(map);
+  const { sourceMap } = parseDSLWithSourceMap([...lines.map((line) => line.text), ""].join("\n"));
+  const readIdByLine = /* @__PURE__ */ new Map();
+  for (const [key, line] of sourceMap.primaryLineOf) {
+    const id = elementIdOf(key);
+    if (id !== void 0) readIdByLine.set(line, id);
+  }
+  const ids = /* @__PURE__ */ new Map();
+  lines.forEach((line, index) => {
+    const id = elementIdOf(line.key);
+    const readId = readIdByLine.get(index + 1);
+    if (id !== void 0 && readId !== void 0) ids.set(id, readId);
+  });
+  return ids;
+}
+
+// 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;
+}
+
+export { keywordOf, parseCoords, parseDSL, parseDSLWithDiagnostics, parseDecorators, parseLabelOffset, patchDSL, readBackIds, serializeDSL, slug, withoutRawStatements };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map