@cristianormazabal/triton-core 0.1.17 → 0.1.19

package/dist/index.js

@@ -38320,8 +38320,99 @@ var c4 = {
   }
 };
 
-// src/diagrams/triton/architecture/layout.ts
-var ARROW_ID8 = "arch-arrow";
+// src/diagrams/mermaid/architecture/gridPlacer.ts
+var DELTA = {
+  LR: [-1, 0],
+  RL: [1, 0],
+  TB: [0, -1],
+  BT: [0, 1],
+  LT: [-1, -1],
+  LB: [-1, 1],
+  RT: [1, -1],
+  RB: [1, 1],
+  TL: [-1, -1],
+  TR: [1, -1],
+  BL: [-1, 1],
+  BR: [1, 1]
+};
+function directionalGridPlacer(nodes, edges2) {
+  if (nodes.length === 0) return /* @__PURE__ */ new Map();
+  const adjList = /* @__PURE__ */ new Map();
+  for (const n of nodes) adjList.set(n.id, /* @__PURE__ */ new Map());
+  for (const e of edges2) {
+    const fs = e.fromSide.toUpperCase();
+    const ts = e.toSide.toUpperCase();
+    const fwd = fs + ts;
+    const rev = ts + fs;
+    const fromAdj = adjList.get(e.from);
+    const toAdj = adjList.get(e.to);
+    if (!fromAdj || !toAdj) continue;
+    if (fromAdj.has(fwd) && fromAdj.get(fwd) !== e.to) {
+      console.warn(`[gridPlacer] Contradictory constraint on "${e.from}" direction ${fwd} \u2014 first-wins`);
+    } else {
+      fromAdj.set(fwd, e.to);
+    }
+    if (toAdj.has(rev) && toAdj.get(rev) !== e.from) {
+      console.warn(`[gridPlacer] Contradictory constraint on "${e.to}" direction ${rev} \u2014 first-wins`);
+    } else {
+      toAdj.set(rev, e.from);
+    }
+  }
+  const position = /* @__PURE__ */ new Map();
+  const occupied = /* @__PURE__ */ new Map();
+  function bfs(seed2, seedCol, seedRow) {
+    position.set(seed2, { col: seedCol, row: seedRow });
+    occupied.set(`${seedCol},${seedRow}`, seed2);
+    const queue2 = [seed2];
+    while (queue2.length > 0) {
+      const curr = queue2.shift();
+      const currPos = position.get(curr);
+      const adj = adjList.get(curr);
+      if (!adj) continue;
+      for (const [pair, neighbor] of adj) {
+        if (position.has(neighbor)) continue;
+        const d = DELTA[pair];
+        if (!d) continue;
+        let col = currPos.col + d[0];
+        let row = currPos.row + d[1];
+        const key = `${col},${row}`;
+        if (occupied.has(key) && occupied.get(key) !== neighbor) {
+          console.warn(`[gridPlacer] Cell collision at (${col},${row}), bumping "${neighbor}"`);
+          let bump = row + 1;
+          while (occupied.has(`${col},${bump}`)) bump++;
+          row = bump;
+        }
+        position.set(neighbor, { col, row });
+        occupied.set(`${col},${row}`, neighbor);
+        queue2.push(neighbor);
+      }
+    }
+  }
+  const connected = /* @__PURE__ */ new Set([...edges2.map((e) => e.from), ...edges2.map((e) => e.to)]);
+  const seed = nodes.find((n) => connected.has(n.id)) ?? nodes[0];
+  bfs(seed.id, 0, 0);
+  for (const n of nodes) {
+    if (!position.has(n.id)) {
+      const maxCol = position.size > 0 ? Math.max(...[...position.values()].map((p) => p.col)) + 2 : 0;
+      bfs(n.id, maxCol, 0);
+    }
+  }
+  if (position.size === 0) {
+    nodes.forEach((n, i) => position.set(n.id, { col: i, row: 0 }));
+  }
+  const vals = [...position.values()];
+  const minCol = Math.min(...vals.map((p) => p.col));
+  const minRow = Math.min(...vals.map((p) => p.row));
+  const result = /* @__PURE__ */ new Map();
+  for (const [id, pos] of position) {
+    result.set(id, { col: pos.col - minCol, row: pos.row - minRow });
+  }
+  return result;
+}
+
+// src/diagrams/mermaid/architecture/layout.ts
+var ARROW_END_ID = "arch-arrow-end";
+var ARROW_START_ID = "arch-arrow-start";
 function port(r, side) {
   switch (side.toUpperCase()) {
     case "L":
@@ -38334,42 +38425,162 @@ function port(r, side) {
       return { x: r.x + r.width / 2, y: r.y + r.height };
   }
 }
-function layoutArchitecture(ir, theme) {
+function sideToDir(side) {
+  switch (side.toUpperCase()) {
+    case "L":
+      return "W";
+    case "R":
+      return "E";
+    case "T":
+      return "N";
+    default:
+      return "S";
+  }
+}
+function groupsByDepth(groups) {
+  const result = [];
+  const added = /* @__PURE__ */ new Set();
+  function add(g) {
+    if (added.has(g.id)) return;
+    if (g.parent) {
+      const par = groups.find((pg) => pg.id === g.parent);
+      if (par) add(par);
+    }
+    result.push(g);
+    added.add(g.id);
+  }
+  for (const g of groups) add(g);
+  return result;
+}
+function layoutArchitecture(ir, theme, options) {
   const { palette, typography, spacing } = theme;
   const p = pen(theme);
   const margin = spacing.diagramMargin;
   const font = typography.baseFontSize;
+  const iconPacks = options?.icons;
   const svcW = 130, svcH = 56;
-  const nodes = ir.services.map((s) => ({ id: s.id, width: svcW, height: svcH }));
-  const edges2 = ir.edges.map((e) => ({ from: e.from, to: e.to }));
-  const laid = layeredLayout(nodes, edges2, { direction: "LR", layerGap: 90, nodeGap: 44, margin: margin + 26 });
+  const jctW = 16, jctH = 16;
+  const nodeSizes = /* @__PURE__ */ new Map();
+  for (const s of ir.services) nodeSizes.set(s.id, { width: svcW, height: svcH });
+  for (const j of ir.junctions) nodeSizes.set(j.id, { width: jctW, height: jctH });
+  const colGap = 90, rowGap = 44;
+  const gridCells = directionalGridPlacer(
+    [...ir.services, ...ir.junctions],
+    ir.edges
+  );
+  const positions = /* @__PURE__ */ new Map();
+  for (const [id, cell] of gridCells) {
+    positions.set(id, {
+      x: cell.col * (svcW + colGap) + margin,
+      y: cell.row * (svcH + rowGap) + margin
+    });
+  }
+  for (const align of ir.aligns) {
+    const coords = align.members.map((id) => positions.get(id)).filter((pos) => !!pos);
+    if (coords.length < 2) continue;
+    if (align.axis === "row") {
+      const ys = coords.map((c) => c.y).sort((a, b) => a - b);
+      const medY = ys[Math.floor(ys.length / 2)];
+      for (const id of align.members) {
+        const pos = positions.get(id);
+        if (pos) pos.y = medY;
+      }
+    } else {
+      const xs = coords.map((c) => c.x).sort((a, b) => a - b);
+      const medX = xs[Math.floor(xs.length / 2)];
+      for (const id of align.members) {
+        const pos = positions.get(id);
+        if (pos) pos.x = medX;
+      }
+    }
+  }
   const titleH = ir.metadata.title ? typography.titleFontSize + 14 : 0;
   const yOff = titleH;
   const rectOf = (id) => {
-    const b = laid.boxes.get(id);
-    return b ? { x: b.x, y: b.y + yOff, width: b.width, height: b.height } : void 0;
+    const pos = positions.get(id);
+    const sz = nodeSizes.get(id);
+    if (!pos || !sz) return void 0;
+    return { x: pos.x, y: pos.y + yOff, width: sz.width, height: sz.height };
+  };
+  const groupRectCache = /* @__PURE__ */ new Map();
+  const computeGroupRect = (gId) => {
+    if (groupRectCache.has(gId)) return groupRectCache.get(gId);
+    const pad = 20;
+    const memberRects = [
+      ...ir.services.filter((s) => s.group === gId).map((s) => rectOf(s.id)).filter((r) => !!r),
+      ...ir.junctions.filter((j) => j.group === gId).map((j) => rectOf(j.id)).filter((r) => !!r),
+      ...ir.groups.filter((g) => g.parent === gId).map((g) => computeGroupRect(g.id)).filter((r) => !!r)
+    ];
+    if (memberRects.length === 0) return void 0;
+    const minX = Math.min(...memberRects.map((r) => r.x)) - pad;
+    const minY = Math.min(...memberRects.map((r) => r.y)) - pad - 14;
+    const maxX = Math.max(...memberRects.map((r) => r.x + r.width)) + pad;
+    const maxY = Math.max(...memberRects.map((r) => r.y + r.height)) + pad;
+    const rect = { x: minX, y: minY, width: maxX - minX, height: maxY - minY };
+    groupRectCache.set(gId, rect);
+    return rect;
   };
+  for (const g of ir.groups) computeGroupRect(g.id);
   const elements = [];
-  if (ir.metadata.title) elements.push(p.text(ir.metadata.title, margin, margin + typography.titleFontSize, typography.titleFontSize, palette.text, { weight: "bold" }));
-  ir.groups.forEach((g, gi) => {
-    const members = ir.services.filter((s) => s.group === g.id).map((s) => rectOf(s.id)).filter((r) => !!r);
-    if (members.length === 0) return;
-    const pad = 20;
-    const minX = Math.min(...members.map((r) => r.x)) - pad;
-    const minY = Math.min(...members.map((r) => r.y)) - pad - 14;
-    const maxX = Math.max(...members.map((r) => r.x + r.width)) + pad;
-    const maxY = Math.max(...members.map((r) => r.y + r.height)) + pad;
+  if (ir.metadata.title) {
+    elements.push(p.text(
+      String(ir.metadata.title),
+      margin,
+      margin + typography.titleFontSize,
+      typography.titleFontSize,
+      palette.text,
+      { weight: "bold" }
+    ));
+  }
+  const orderedGroups = groupsByDepth(ir.groups);
+  orderedGroups.forEach((g, gi) => {
+    const r = computeGroupRect(g.id);
+    if (!r) return;
     const hue = categoricalHue(gi);
-    elements.push(p.rect({ x: rhu(minX), y: rhu(minY), width: rhu(maxX - minX), height: rhu(maxY - minY) }, hue + "14", hue, 1.4, { rx: 10 }));
-    elements.push(p.text(g.label, rhu(minX + 12), rhu(minY + 16), typography.smallFontSize, hue, { weight: "bold" }));
+    elements.push(p.rect(
+      { x: rhu(r.x), y: rhu(r.y), width: rhu(r.width), height: rhu(r.height) },
+      hue + "14",
+      hue,
+      1.4,
+      { rx: 10 }
+    ));
+    elements.push(p.text(
+      g.label,
+      rhu(r.x + 12),
+      rhu(r.y + 16),
+      typography.smallFontSize,
+      hue,
+      { weight: "bold" }
+    ));
   });
-  const allBoxes = [...laid.boxes.values()];
+  const allBoxes = [];
+  for (const [id, pos] of positions) {
+    const sz = nodeSizes.get(id);
+    if (sz) allBoxes.push({ id, x: pos.x, y: pos.y, width: sz.width, height: sz.height });
+  }
   for (const e of ir.edges) {
-    const a = rectOf(e.from), b = rectOf(e.to);
-    if (!a || !b) continue;
-    const pa = port(a, e.fromSide), pb = port(b, e.toSide);
-    const fromDir = e.fromSide.toUpperCase() === "L" ? "W" : e.fromSide.toUpperCase() === "R" ? "E" : e.fromSide.toUpperCase() === "T" ? "N" : "S";
-    const toDir = e.toSide.toUpperCase() === "L" ? "W" : e.toSide.toUpperCase() === "R" ? "E" : e.toSide.toUpperCase() === "T" ? "N" : "S";
+    let fromRect = rectOf(e.from);
+    if (!fromRect) continue;
+    if (e.fromGroup) {
+      const svc = ir.services.find((s) => s.id === e.from);
+      if (svc?.group) {
+        const gr = computeGroupRect(svc.group);
+        if (gr) fromRect = gr;
+      }
+    }
+    let toRect2 = rectOf(e.to);
+    if (!toRect2) continue;
+    if (e.toGroup) {
+      const svc = ir.services.find((s) => s.id === e.to);
+      if (svc?.group) {
+        const gr = computeGroupRect(svc.group);
+        if (gr) toRect2 = gr;
+      }
+    }
+    const pa = port(fromRect, e.fromSide);
+    const pb = port(toRect2, e.toSide);
+    const fromDir = sideToDir(e.fromSide);
+    const toDir = sideToDir(e.toSide);
     const obstacles = allBoxes.filter((bx) => bx.id !== e.from && bx.id !== e.to).map((bx) => ({ x: bx.x, y: bx.y + yOff, width: bx.width, height: bx.height }));
     const route = orthogonalRouter.route({
       from: pa,
@@ -38380,28 +38591,106 @@ function layoutArchitecture(ir, theme) {
       fromDir,
       toDir
     });
-    elements.push(p.path(route.path, palette.primary, 1.6, { markerEnd: ARROW_ID8 }));
+    const pathOpts = {};
+    if (e.arrowRight) pathOpts.markerEnd = ARROW_END_ID;
+    if (e.arrowLeft) pathOpts.markerStart = ARROW_START_ID;
+    elements.push(p.path(route.path, palette.primary, 1.6, pathOpts));
   }
+  const warnedIcons = /* @__PURE__ */ new Set();
   ir.services.forEach((s, i) => {
     const r = rectOf(s.id);
+    if (!r) return;
     const hue = categoricalHue(i);
-    elements.push(p.rect({ x: rhu(r.x), y: rhu(r.y), width: rhu(r.width), height: rhu(r.height) }, palette.surface, palette.border, 1.4, { rx: 8 }));
-    elements.push(p.rect({ x: rhu(r.x), y: rhu(r.y), width: rhu(r.width), height: 8 }, hue, hue, 0, { rx: 4 }));
-    elements.push(...iconGlyph(p, s.icon, r.x + r.width / 2, r.y + 24, hue, palette));
-    elements.push(p.text(s.label, rhuInt(r.x + r.width / 2), rhu(r.y + r.height - 9), font, palette.text, { weight: "bold", anchor: "middle" }));
+    elements.push(p.rect(
+      { x: rhu(r.x), y: rhu(r.y), width: rhu(r.width), height: rhu(r.height) },
+      palette.surface,
+      palette.border,
+      1.4,
+      { rx: 8 }
+    ));
+    elements.push(p.rect(
+      { x: rhu(r.x), y: rhu(r.y), width: rhu(r.width), height: 8 },
+      hue,
+      hue,
+      0,
+      { rx: 4 }
+    ));
+    const iconElems = resolveIconElems(p, s.icon, r.x + r.width / 2, r.y + 24, hue, palette, iconPacks, warnedIcons);
+    elements.push(...iconElems);
+    elements.push(p.text(
+      s.label,
+      rhuInt(r.x + r.width / 2),
+      rhu(r.y + r.height - 9),
+      font,
+      palette.text,
+      { weight: "bold", anchor: "middle" }
+    ));
   });
-  const allR = ir.services.map((s) => rectOf(s.id));
-  const totalW = rhuInt(Math.max(...allR.map((r) => r.x + r.width)) + margin + 26);
-  const totalH = rhuInt(Math.max(...allR.map((r) => r.y + r.height)) + margin + 26);
-  const defs = [`<marker id="${ARROW_ID8}" markerWidth="10" markerHeight="8" refX="9" refY="4" orient="auto"><polygon points="0 0, 10 4, 0 8" fill="${palette.primary}" /></marker>`];
+  ir.junctions.forEach((j) => {
+    const r = rectOf(j.id);
+    if (!r) return;
+    const cx = rhu(r.x + r.width / 2);
+    const cy = rhu(r.y + r.height / 2);
+    const R = 4;
+    elements.push(p.circle({ x: cx, y: cy }, R, palette.primary, palette.primary, 0));
+    elements.push(p.path(
+      `M ${rhu(cx - R)} ${cy} L ${rhu(cx + R)} ${cy} M ${cx} ${rhu(cy - R)} L ${cx} ${rhu(cy + R)}`,
+      palette.primary,
+      1.6
+    ));
+  });
+  const allNodeRects = [
+    ...ir.services.map((s) => rectOf(s.id)).filter((r) => !!r),
+    ...ir.junctions.map((j) => rectOf(j.id)).filter((r) => !!r)
+  ];
+  const allGroupRects = [...groupRectCache.values()];
+  const allRects = [...allNodeRects, ...allGroupRects];
+  if (allRects.length === 0) {
+    const scene2 = applyOverlays(
+      { viewBox: { x: 0, y: 0, width: 200, height: 100 }, background: palette.background, elements, defs: [] },
+      ir.overlays,
+      theme
+    );
+    return { scene: scene2, anchors: {} };
+  }
+  const totalW = rhuInt(Math.max(...allRects.map((r) => r.x + r.width)) + margin + 26);
+  const totalH = rhuInt(Math.max(...allRects.map((r) => r.y + r.height)) + margin + 26);
+  const vbX = rhuInt(Math.min(0, ...allRects.map((r) => r.x)) - margin);
+  const vbY = rhuInt(Math.min(0, ...allRects.map((r) => r.y)) - margin);
+  const defs = [
+    `<marker id="${ARROW_END_ID}" markerWidth="10" markerHeight="8" refX="9" refY="4" orient="auto"><polygon points="0 0, 10 4, 0 8" fill="${palette.primary}" /></marker>`,
+    `<marker id="${ARROW_START_ID}" markerWidth="10" markerHeight="8" refX="1" refY="4" orient="auto-start-reverse"><polygon points="0 0, 10 4, 0 8" fill="${palette.primary}" /></marker>`
+  ];
   const scene = applyOverlays({
-    viewBox: { x: 0, y: 0, width: totalW, height: totalH },
+    viewBox: { x: vbX, y: vbY, width: totalW - vbX, height: totalH - vbY },
     background: palette.background,
     elements,
     defs
   }, ir.overlays, theme);
   return { scene, anchors: {} };
 }
+function resolveIconElems(p, icon, cx, cy, hue, palette, iconPacks, warnedIcons) {
+  if (icon.includes(":") && iconPacks) {
+    const ref = parseIconRef(icon);
+    if (ref.ok) {
+      const resolved = resolveIcon(ref.value, iconPacks);
+      if (resolved.ok) {
+        const size = 24;
+        return [p.icon(resolved.value, rhu(cx - size / 2), rhu(cy - size / 2), size, { color: hue })];
+      }
+    }
+    if (!warnedIcons.has(icon)) {
+      warnedIcons.add(icon);
+      console.warn(`[architecture] icon "${icon}" could not be resolved \u2014 falling back to glyph.`);
+    }
+  } else if (icon.includes(":") && !iconPacks) {
+    if (!warnedIcons.has(icon)) {
+      warnedIcons.add(icon);
+      console.warn(`[architecture] icon "${icon}" is an iconify token but no icon packs were loaded.`);
+    }
+  }
+  return iconGlyph(p, icon, cx, cy, hue, palette);
+}
 function iconGlyph(p, icon, cx, cy, hue, palette) {
   const name = icon.toLowerCase();
   const out = [];
@@ -38426,7 +38715,7 @@ function iconGlyph(p, icon, cx, cy, hue, palette) {
   return out;
 }
 
-// src/diagrams/triton/architecture/parser.js
+// src/diagrams/mermaid/architecture/parser.js
 function peg$subclass21(child, parent) {
   function C() {
     this.constructor = child;
@@ -38562,14 +38851,20 @@ function peg$parse21(input, options) {
   var peg$c3 = ")";
   var peg$c4 = "[";
   var peg$c5 = "]";
-  var peg$c6 = "service";
-  var peg$c7 = "in";
-  var peg$c8 = ":";
-  var peg$c9 = "-->";
-  var peg$c10 = "--";
+  var peg$c6 = "in";
+  var peg$c7 = "service";
+  var peg$c8 = "junction";
+  var peg$c9 = ":";
+  var peg$c10 = "{group}";
   var peg$c11 = "<-->";
-  var peg$c12 = "\r";
-  var peg$c13 = "\n";
+  var peg$c12 = "-->";
+  var peg$c13 = "<--";
+  var peg$c14 = "--";
+  var peg$c15 = "align";
+  var peg$c16 = "row";
+  var peg$c17 = "column";
+  var peg$c18 = "\r";
+  var peg$c19 = "\n";
   var peg$r0 = /^[ \t]/;
   var peg$r1 = /^[^)\n]/;
   var peg$r2 = /^[^\]\n]/;
@@ -38585,48 +38880,96 @@ function peg$parse21(input, options) {
   var peg$e6 = peg$literalExpectation("[", false);
   var peg$e7 = peg$classExpectation(["]", "\n"], true, false);
   var peg$e8 = peg$literalExpectation("]", false);
-  var peg$e9 = peg$literalExpectation("service", true);
-  var peg$e10 = peg$literalExpectation("in", true);
-  var peg$e11 = peg$literalExpectation(":", false);
-  var peg$e12 = peg$literalExpectation("-->", false);
-  var peg$e13 = peg$literalExpectation("--", false);
+  var peg$e9 = peg$literalExpectation("in", true);
+  var peg$e10 = peg$literalExpectation("service", true);
+  var peg$e11 = peg$literalExpectation("junction", true);
+  var peg$e12 = peg$literalExpectation(":", false);
+  var peg$e13 = peg$literalExpectation("{group}", false);
   var peg$e14 = peg$literalExpectation("<-->", false);
-  var peg$e15 = peg$classExpectation(["L", "R", "T", "B", "l", "r", "t", "b"], false, false);
-  var peg$e16 = peg$classExpectation(["\n"], true, false);
-  var peg$e17 = peg$classExpectation([["A", "Z"], ["a", "z"], ["0", "9"], "_"], false, false);
-  var peg$e18 = peg$literalExpectation("\r", false);
-  var peg$e19 = peg$literalExpectation("\n", false);
-  var peg$e20 = peg$anyExpectation();
+  var peg$e15 = peg$literalExpectation("-->", false);
+  var peg$e16 = peg$literalExpectation("<--", false);
+  var peg$e17 = peg$literalExpectation("--", false);
+  var peg$e18 = peg$literalExpectation("align", true);
+  var peg$e19 = peg$literalExpectation("row", true);
+  var peg$e20 = peg$literalExpectation("column", true);
+  var peg$e21 = peg$classExpectation(["L", "R", "T", "B", "l", "r", "t", "b"], false, false);
+  var peg$e22 = peg$classExpectation(["\n"], true, false);
+  var peg$e23 = peg$classExpectation([["A", "Z"], ["a", "z"], ["0", "9"], "_"], false, false);
+  var peg$e24 = peg$literalExpectation("\r", false);
+  var peg$e25 = peg$literalExpectation("\n", false);
+  var peg$e26 = peg$anyExpectation();
   var peg$f0 = function(lines2) {
     const groups = [];
     const services = [];
+    const junctions = [];
     const edges2 = [];
+    const aligns = [];
     let curGroup, curIndent = -1;
     for (const l of lines2.filter(Boolean)) {
       if (l.t === "group") {
-        groups.push({ id: l.id, label: l.label, icon: l.icon });
+        groups.push({ id: l.id, label: l.label, icon: l.icon, ...l.inGroup ? { parent: l.inGroup } : {} });
         curGroup = l.id;
         curIndent = l.indent;
       } else if (l.t === "service") {
         const group = l.inGroup || (l.indent > curIndent && curGroup ? curGroup : void 0);
         services.push({ id: l.id, label: l.label, icon: l.icon, ...group ? { group } : {} });
-      } else if (l.t === "edge") edges2.push({ from: l.from, fromSide: l.fromSide, to: l.to, toSide: l.toSide });
+      } else if (l.t === "junction") {
+        const group = l.inGroup || (l.indent > curIndent && curGroup ? curGroup : void 0);
+        junctions.push({ id: l.id, ...group ? { group } : {} });
+      } else if (l.t === "edge") {
+        edges2.push({ from: l.from, fromSide: l.fromSide, fromGroup: l.fromGroup, to: l.to, toSide: l.toSide, toGroup: l.toGroup, arrowLeft: l.arrowLeft, arrowRight: l.arrowRight });
+      } else if (l.t === "align") {
+        aligns.push({ axis: l.axis, members: l.members });
+      }
     }
-    return { version: "1.0", metadata: {}, groups, services, edges: edges2 };
+    return { version: "1.0", metadata: {}, groups, services, junctions, edges: edges2, aligns };
+  };
+  var peg$f1 = function(ind, id, icon, label, g) {
+    return g;
   };
-  var peg$f1 = function(ind, id, icon, label) {
-    return { t: "group", indent: ind.length, id, icon: icon.trim(), label: label.trim() };
+  var peg$f2 = function(ind, id, icon, label, inG) {
+    return { t: "group", indent: ind.length, id, icon: icon.trim(), label: label.trim(), inGroup: inG || void 0 };
   };
-  var peg$f2 = function(ind, id, icon, label, g) {
+  var peg$f3 = function(ind, id, icon, label, g) {
     return g;
   };
-  var peg$f3 = function(ind, id, icon, label, inG) {
+  var peg$f4 = function(ind, id, icon, label, inG) {
     return { t: "service", indent: ind.length, id, icon: icon.trim(), label: label.trim(), inGroup: inG || void 0 };
   };
-  var peg$f4 = function(from, fromSide, toSide, to) {
-    return { t: "edge", from, fromSide, to, toSide };
+  var peg$f5 = function(ind, id, g) {
+    return g;
   };
-  var peg$f5 = function() {
+  var peg$f6 = function(ind, id, inG) {
+    return { t: "junction", indent: ind.length, id, inGroup: inG || void 0 };
+  };
+  var peg$f7 = function(fromEp, fromSide, arrow, toSide, toEp) {
+    return { t: "edge", from: fromEp.id, fromSide, fromGroup: fromEp.grp, to: toEp.id, toSide, toGroup: toEp.grp, arrowLeft: arrow.left, arrowRight: arrow.right };
+  };
+  var peg$f8 = function(id) {
+    return true;
+  };
+  var peg$f9 = function(id, grp) {
+    return { id, grp: grp === true };
+  };
+  var peg$f10 = function() {
+    return { left: true, right: true };
+  };
+  var peg$f11 = function() {
+    return { left: false, right: true };
+  };
+  var peg$f12 = function() {
+    return { left: true, right: false };
+  };
+  var peg$f13 = function() {
+    return { left: false, right: false };
+  };
+  var peg$f14 = function(axis, head, id) {
+    return id;
+  };
+  var peg$f15 = function(axis, head, tail) {
+    return { t: "align", axis: axis.toLowerCase(), members: [head, ...tail] };
+  };
+  var peg$f16 = function() {
     return null;
   };
   var peg$currPos = options.peg$currPos | 0;
@@ -38800,16 +39143,22 @@ function peg$parse21(input, options) {
     if (s0 === peg$FAILED) {
       s0 = peg$parseServiceLine();
       if (s0 === peg$FAILED) {
-        s0 = peg$parseEdgeLine();
+        s0 = peg$parseJunctionLine();
         if (s0 === peg$FAILED) {
-          s0 = peg$parseBlankLine();
+          s0 = peg$parseAlignLine();
+          if (s0 === peg$FAILED) {
+            s0 = peg$parseEdgeLine();
+            if (s0 === peg$FAILED) {
+              s0 = peg$parseBlankLine();
+            }
+          }
         }
       }
     }
     return s0;
   }
   function peg$parseGroupLine() {
-    var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12;
+    var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15;
     s0 = peg$currPos;
     s1 = peg$currPos;
     s2 = [];
@@ -38937,11 +39286,49 @@ function peg$parse21(input, options) {
                   }
                 }
                 if (s10 !== peg$FAILED) {
-                  s11 = peg$parseRestIgnore();
-                  s12 = peg$parseLineEnd();
+                  s11 = peg$currPos;
+                  s12 = peg$parse__();
                   if (s12 !== peg$FAILED) {
+                    s13 = input.substr(peg$currPos, 2);
+                    if (s13.toLowerCase() === peg$c6) {
+                      peg$currPos += 2;
+                    } else {
+                      s13 = peg$FAILED;
+                      if (peg$silentFails === 0) {
+                        peg$fail(peg$e9);
+                      }
+                    }
+                    if (s13 !== peg$FAILED) {
+                      s14 = peg$parse__();
+                      if (s14 !== peg$FAILED) {
+                        s15 = peg$parseIdent();
+                        if (s15 !== peg$FAILED) {
+                          peg$savedPos = s11;
+                          s11 = peg$f1(s1, s4, s6, s9, s15);
+                        } else {
+                          peg$currPos = s11;
+                          s11 = peg$FAILED;
+                        }
+                      } else {
+                        peg$currPos = s11;
+                        s11 = peg$FAILED;
+                      }
+                    } else {
+                      peg$currPos = s11;
+                      s11 = peg$FAILED;
+                    }
+                  } else {
+                    peg$currPos = s11;
+                    s11 = peg$FAILED;
+                  }
+                  if (s11 === peg$FAILED) {
+                    s11 = null;
+                  }
+                  s12 = peg$parseRestIgnore();
+                  s13 = peg$parseLineEnd();
+                  if (s13 !== peg$FAILED) {
                     peg$savedPos = s0;
-                    s0 = peg$f1(s1, s4, s6, s9);
+                    s0 = peg$f2(s1, s4, s6, s9, s11);
                   } else {
                     peg$currPos = s0;
                     s0 = peg$FAILED;
@@ -39004,12 +39391,12 @@ function peg$parse21(input, options) {
     }
     s1 = input.substring(s1, peg$currPos);
     s2 = input.substr(peg$currPos, 7);
-    if (s2.toLowerCase() === peg$c6) {
+    if (s2.toLowerCase() === peg$c7) {
       peg$currPos += 7;
     } else {
       s2 = peg$FAILED;
       if (peg$silentFails === 0) {
-        peg$fail(peg$e9);
+        peg$fail(peg$e10);
       }
     }
     if (s2 !== peg$FAILED) {
@@ -39109,12 +39496,12 @@ function peg$parse21(input, options) {
                   s12 = peg$parse__();
                   if (s12 !== peg$FAILED) {
                     s13 = input.substr(peg$currPos, 2);
-                    if (s13.toLowerCase() === peg$c7) {
+                    if (s13.toLowerCase() === peg$c6) {
                       peg$currPos += 2;
                     } else {
                       s13 = peg$FAILED;
                       if (peg$silentFails === 0) {
-                        peg$fail(peg$e10);
+                        peg$fail(peg$e9);
                       }
                     }
                     if (s13 !== peg$FAILED) {
@@ -39123,7 +39510,7 @@ function peg$parse21(input, options) {
                         s15 = peg$parseIdent();
                         if (s15 !== peg$FAILED) {
                           peg$savedPos = s11;
-                          s11 = peg$f2(s1, s4, s6, s9, s15);
+                          s11 = peg$f3(s1, s4, s6, s9, s15);
                         } else {
                           peg$currPos = s11;
                           s11 = peg$FAILED;
@@ -39147,7 +39534,184 @@ function peg$parse21(input, options) {
                   s13 = peg$parseLineEnd();
                   if (s13 !== peg$FAILED) {
                     peg$savedPos = s0;
-                    s0 = peg$f3(s1, s4, s6, s9, s11);
+                    s0 = peg$f4(s1, s4, s6, s9, s11);
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    return s0;
+  }
+  function peg$parseJunctionLine() {
+    var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
+    s0 = peg$currPos;
+    s1 = peg$currPos;
+    s2 = [];
+    s3 = input.charAt(peg$currPos);
+    if (peg$r0.test(s3)) {
+      peg$currPos++;
+    } else {
+      s3 = peg$FAILED;
+      if (peg$silentFails === 0) {
+        peg$fail(peg$e1);
+      }
+    }
+    while (s3 !== peg$FAILED) {
+      s2.push(s3);
+      s3 = input.charAt(peg$currPos);
+      if (peg$r0.test(s3)) {
+        peg$currPos++;
+      } else {
+        s3 = peg$FAILED;
+        if (peg$silentFails === 0) {
+          peg$fail(peg$e1);
+        }
+      }
+    }
+    s1 = input.substring(s1, peg$currPos);
+    s2 = input.substr(peg$currPos, 8);
+    if (s2.toLowerCase() === peg$c8) {
+      peg$currPos += 8;
+    } else {
+      s2 = peg$FAILED;
+      if (peg$silentFails === 0) {
+        peg$fail(peg$e11);
+      }
+    }
+    if (s2 !== peg$FAILED) {
+      s3 = peg$parse__();
+      if (s3 !== peg$FAILED) {
+        s4 = peg$parseIdent();
+        if (s4 !== peg$FAILED) {
+          s5 = peg$currPos;
+          s6 = peg$parse__();
+          if (s6 !== peg$FAILED) {
+            s7 = input.substr(peg$currPos, 2);
+            if (s7.toLowerCase() === peg$c6) {
+              peg$currPos += 2;
+            } else {
+              s7 = peg$FAILED;
+              if (peg$silentFails === 0) {
+                peg$fail(peg$e9);
+              }
+            }
+            if (s7 !== peg$FAILED) {
+              s8 = peg$parse__();
+              if (s8 !== peg$FAILED) {
+                s9 = peg$parseIdent();
+                if (s9 !== peg$FAILED) {
+                  peg$savedPos = s5;
+                  s5 = peg$f5(s1, s4, s9);
+                } else {
+                  peg$currPos = s5;
+                  s5 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s5;
+                s5 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s5;
+              s5 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s5;
+            s5 = peg$FAILED;
+          }
+          if (s5 === peg$FAILED) {
+            s5 = null;
+          }
+          s6 = peg$parseRestIgnore();
+          s7 = peg$parseLineEnd();
+          if (s7 !== peg$FAILED) {
+            peg$savedPos = s0;
+            s0 = peg$f6(s1, s4, s5);
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    return s0;
+  }
+  function peg$parseEdgeLine() {
+    var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12;
+    s0 = peg$currPos;
+    s1 = peg$parse_();
+    s2 = peg$parseEdgeEndpoint();
+    if (s2 !== peg$FAILED) {
+      if (input.charCodeAt(peg$currPos) === 58) {
+        s3 = peg$c9;
+        peg$currPos++;
+      } else {
+        s3 = peg$FAILED;
+        if (peg$silentFails === 0) {
+          peg$fail(peg$e12);
+        }
+      }
+      if (s3 !== peg$FAILED) {
+        s4 = peg$parseSide();
+        if (s4 !== peg$FAILED) {
+          s5 = peg$parse_();
+          s6 = peg$parseArrow();
+          if (s6 !== peg$FAILED) {
+            s7 = peg$parse_();
+            s8 = peg$parseSide();
+            if (s8 !== peg$FAILED) {
+              if (input.charCodeAt(peg$currPos) === 58) {
+                s9 = peg$c9;
+                peg$currPos++;
+              } else {
+                s9 = peg$FAILED;
+                if (peg$silentFails === 0) {
+                  peg$fail(peg$e12);
+                }
+              }
+              if (s9 !== peg$FAILED) {
+                s10 = peg$parseEdgeEndpoint();
+                if (s10 !== peg$FAILED) {
+                  s11 = peg$parseRestIgnore();
+                  s12 = peg$parseLineEnd();
+                  if (s12 !== peg$FAILED) {
+                    peg$savedPos = s0;
+                    s0 = peg$f7(s2, s4, s6, s8, s10);
                   } else {
                     peg$currPos = s0;
                     s0 = peg$FAILED;
@@ -39182,81 +39746,192 @@ function peg$parse21(input, options) {
     }
     return s0;
   }
-  function peg$parseEdgeLine() {
-    var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12;
+  function peg$parseEdgeEndpoint() {
+    var s0, s1, s2, s3;
     s0 = peg$currPos;
-    s1 = peg$parse_();
-    s2 = peg$parseIdent();
-    if (s2 !== peg$FAILED) {
-      if (input.charCodeAt(peg$currPos) === 58) {
-        s3 = peg$c8;
-        peg$currPos++;
+    s1 = peg$parseIdent();
+    if (s1 !== peg$FAILED) {
+      s2 = peg$currPos;
+      if (input.substr(peg$currPos, 7) === peg$c10) {
+        s3 = peg$c10;
+        peg$currPos += 7;
       } else {
         s3 = peg$FAILED;
         if (peg$silentFails === 0) {
-          peg$fail(peg$e11);
+          peg$fail(peg$e13);
         }
       }
       if (s3 !== peg$FAILED) {
-        s4 = peg$parseSide();
-        if (s4 !== peg$FAILED) {
-          s5 = peg$parse_();
-          if (input.substr(peg$currPos, 3) === peg$c9) {
-            s6 = peg$c9;
-            peg$currPos += 3;
+        peg$savedPos = s2;
+        s3 = peg$f8(s1);
+      }
+      s2 = s3;
+      if (s2 === peg$FAILED) {
+        s2 = null;
+      }
+      peg$savedPos = s0;
+      s0 = peg$f9(s1, s2);
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    return s0;
+  }
+  function peg$parseArrow() {
+    var s0, s1;
+    s0 = peg$currPos;
+    if (input.substr(peg$currPos, 4) === peg$c11) {
+      s1 = peg$c11;
+      peg$currPos += 4;
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) {
+        peg$fail(peg$e14);
+      }
+    }
+    if (s1 !== peg$FAILED) {
+      peg$savedPos = s0;
+      s1 = peg$f10();
+    }
+    s0 = s1;
+    if (s0 === peg$FAILED) {
+      s0 = peg$currPos;
+      if (input.substr(peg$currPos, 3) === peg$c12) {
+        s1 = peg$c12;
+        peg$currPos += 3;
+      } else {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) {
+          peg$fail(peg$e15);
+        }
+      }
+      if (s1 !== peg$FAILED) {
+        peg$savedPos = s0;
+        s1 = peg$f11();
+      }
+      s0 = s1;
+      if (s0 === peg$FAILED) {
+        s0 = peg$currPos;
+        if (input.substr(peg$currPos, 3) === peg$c13) {
+          s1 = peg$c13;
+          peg$currPos += 3;
+        } else {
+          s1 = peg$FAILED;
+          if (peg$silentFails === 0) {
+            peg$fail(peg$e16);
+          }
+        }
+        if (s1 !== peg$FAILED) {
+          peg$savedPos = s0;
+          s1 = peg$f12();
+        }
+        s0 = s1;
+        if (s0 === peg$FAILED) {
+          s0 = peg$currPos;
+          if (input.substr(peg$currPos, 2) === peg$c14) {
+            s1 = peg$c14;
+            peg$currPos += 2;
           } else {
-            s6 = peg$FAILED;
+            s1 = peg$FAILED;
             if (peg$silentFails === 0) {
-              peg$fail(peg$e12);
+              peg$fail(peg$e17);
             }
           }
-          if (s6 === peg$FAILED) {
-            if (input.substr(peg$currPos, 2) === peg$c10) {
-              s6 = peg$c10;
-              peg$currPos += 2;
-            } else {
-              s6 = peg$FAILED;
-              if (peg$silentFails === 0) {
-                peg$fail(peg$e13);
-              }
-            }
-            if (s6 === peg$FAILED) {
-              if (input.substr(peg$currPos, 4) === peg$c11) {
-                s6 = peg$c11;
-                peg$currPos += 4;
-              } else {
-                s6 = peg$FAILED;
-                if (peg$silentFails === 0) {
-                  peg$fail(peg$e14);
-                }
-              }
+          if (s1 !== peg$FAILED) {
+            peg$savedPos = s0;
+            s1 = peg$f13();
+          }
+          s0 = s1;
+        }
+      }
+    }
+    return s0;
+  }
+  function peg$parseAlignLine() {
+    var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;
+    s0 = peg$currPos;
+    s1 = peg$parse_();
+    s2 = input.substr(peg$currPos, 5);
+    if (s2.toLowerCase() === peg$c15) {
+      peg$currPos += 5;
+    } else {
+      s2 = peg$FAILED;
+      if (peg$silentFails === 0) {
+        peg$fail(peg$e18);
+      }
+    }
+    if (s2 !== peg$FAILED) {
+      s3 = peg$parse__();
+      if (s3 !== peg$FAILED) {
+        s4 = input.substr(peg$currPos, 3);
+        if (s4.toLowerCase() === peg$c16) {
+          peg$currPos += 3;
+        } else {
+          s4 = peg$FAILED;
+          if (peg$silentFails === 0) {
+            peg$fail(peg$e19);
+          }
+        }
+        if (s4 === peg$FAILED) {
+          s4 = input.substr(peg$currPos, 6);
+          if (s4.toLowerCase() === peg$c17) {
+            peg$currPos += 6;
+          } else {
+            s4 = peg$FAILED;
+            if (peg$silentFails === 0) {
+              peg$fail(peg$e20);
             }
           }
-          if (s6 !== peg$FAILED) {
-            s7 = peg$parse_();
-            s8 = peg$parseSide();
-            if (s8 !== peg$FAILED) {
-              if (input.charCodeAt(peg$currPos) === 58) {
-                s9 = peg$c8;
-                peg$currPos++;
-              } else {
-                s9 = peg$FAILED;
-                if (peg$silentFails === 0) {
-                  peg$fail(peg$e11);
-                }
-              }
+        }
+        if (s4 !== peg$FAILED) {
+          s5 = peg$parse__();
+          if (s5 !== peg$FAILED) {
+            s6 = peg$parseIdent();
+            if (s6 !== peg$FAILED) {
+              s7 = [];
+              s8 = peg$currPos;
+              s9 = peg$parse__();
               if (s9 !== peg$FAILED) {
                 s10 = peg$parseIdent();
                 if (s10 !== peg$FAILED) {
-                  s11 = peg$parseRestIgnore();
-                  s12 = peg$parseLineEnd();
-                  if (s12 !== peg$FAILED) {
-                    peg$savedPos = s0;
-                    s0 = peg$f4(s2, s4, s8, s10);
+                  peg$savedPos = s8;
+                  s8 = peg$f14(s4, s6, s10);
+                } else {
+                  peg$currPos = s8;
+                  s8 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s8;
+                s8 = peg$FAILED;
+              }
+              if (s8 !== peg$FAILED) {
+                while (s8 !== peg$FAILED) {
+                  s7.push(s8);
+                  s8 = peg$currPos;
+                  s9 = peg$parse__();
+                  if (s9 !== peg$FAILED) {
+                    s10 = peg$parseIdent();
+                    if (s10 !== peg$FAILED) {
+                      peg$savedPos = s8;
+                      s8 = peg$f14(s4, s6, s10);
+                    } else {
+                      peg$currPos = s8;
+                      s8 = peg$FAILED;
+                    }
                   } else {
-                    peg$currPos = s0;
-                    s0 = peg$FAILED;
+                    peg$currPos = s8;
+                    s8 = peg$FAILED;
                   }
+                }
+              } else {
+                s7 = peg$FAILED;
+              }
+              if (s7 !== peg$FAILED) {
+                s8 = peg$parseRestIgnore();
+                s9 = peg$parseLineEnd();
+                if (s9 !== peg$FAILED) {
+                  peg$savedPos = s0;
+                  s0 = peg$f15(s4, s6, s7);
                 } else {
                   peg$currPos = s0;
                   s0 = peg$FAILED;
@@ -39295,7 +39970,7 @@ function peg$parse21(input, options) {
     } else {
       s0 = peg$FAILED;
       if (peg$silentFails === 0) {
-        peg$fail(peg$e15);
+        peg$fail(peg$e21);
       }
     }
     return s0;
@@ -39310,7 +39985,7 @@ function peg$parse21(input, options) {
     } else {
       s2 = peg$FAILED;
       if (peg$silentFails === 0) {
-        peg$fail(peg$e16);
+        peg$fail(peg$e22);
       }
     }
     while (s2 !== peg$FAILED) {
@@ -39321,7 +39996,7 @@ function peg$parse21(input, options) {
       } else {
         s2 = peg$FAILED;
         if (peg$silentFails === 0) {
-          peg$fail(peg$e16);
+          peg$fail(peg$e22);
         }
       }
     }
@@ -39338,7 +40013,7 @@ function peg$parse21(input, options) {
     } else {
       s2 = peg$FAILED;
       if (peg$silentFails === 0) {
-        peg$fail(peg$e17);
+        peg$fail(peg$e23);
       }
     }
     if (s2 !== peg$FAILED) {
@@ -39350,7 +40025,7 @@ function peg$parse21(input, options) {
         } else {
           s2 = peg$FAILED;
           if (peg$silentFails === 0) {
-            peg$fail(peg$e17);
+            peg$fail(peg$e23);
           }
         }
       }
@@ -39369,29 +40044,29 @@ function peg$parse21(input, options) {
     s0 = peg$currPos;
     s1 = peg$parse_();
     if (input.charCodeAt(peg$currPos) === 13) {
-      s2 = peg$c12;
+      s2 = peg$c18;
       peg$currPos++;
     } else {
       s2 = peg$FAILED;
       if (peg$silentFails === 0) {
-        peg$fail(peg$e18);
+        peg$fail(peg$e24);
       }
     }
     if (s2 === peg$FAILED) {
       s2 = null;
     }
     if (input.charCodeAt(peg$currPos) === 10) {
-      s3 = peg$c13;
+      s3 = peg$c19;
       peg$currPos++;
     } else {
       s3 = peg$FAILED;
       if (peg$silentFails === 0) {
-        peg$fail(peg$e19);
+        peg$fail(peg$e25);
       }
     }
     if (s3 !== peg$FAILED) {
       peg$savedPos = s0;
-      s0 = peg$f5();
+      s0 = peg$f16();
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -39402,24 +40077,24 @@ function peg$parse21(input, options) {
     var s0, s1, s2;
     s0 = peg$currPos;
     if (input.charCodeAt(peg$currPos) === 13) {
-      s1 = peg$c12;
+      s1 = peg$c18;
       peg$currPos++;
     } else {
       s1 = peg$FAILED;
       if (peg$silentFails === 0) {
-        peg$fail(peg$e18);
+        peg$fail(peg$e24);
       }
     }
     if (s1 === peg$FAILED) {
       s1 = null;
     }
     if (input.charCodeAt(peg$currPos) === 10) {
-      s2 = peg$c13;
+      s2 = peg$c19;
       peg$currPos++;
     } else {
       s2 = peg$FAILED;
       if (peg$silentFails === 0) {
-        peg$fail(peg$e19);
+        peg$fail(peg$e25);
       }
     }
     if (s2 !== peg$FAILED) {
@@ -39438,7 +40113,7 @@ function peg$parse21(input, options) {
       } else {
         s1 = peg$FAILED;
         if (peg$silentFails === 0) {
-          peg$fail(peg$e20);
+          peg$fail(peg$e26);
         }
       }
       peg$silentFails--;
@@ -39534,7 +40209,7 @@ function peg$parse21(input, options) {
   }
 }
 
-// src/diagrams/triton/architecture/index.ts
+// src/diagrams/mermaid/architecture/index.ts
 var architecture = {
   parseMermaid(input) {
     return peg$parse21(input);
@@ -39542,8 +40217,8 @@ var architecture = {
   parseYaml(input) {
     return JSON.parse(input);
   },
-  layout(ir, theme) {
-    return layoutArchitecture(ir, theme);
+  layout(ir, theme, options) {
+    return layoutArchitecture(ir, theme, options);
   }
 };
 
@@ -43768,9 +44443,89 @@ function parseEntries(spec) {
     return { key: pair, value: "" };
   });
 }
+function parseBucketLabels(spec) {
+  const labels = [];
+  let current = "";
+  let inQuotes = false;
+  let escaping = false;
+  for (const ch of spec) {
+    if (escaping) {
+      current += ch;
+      escaping = false;
+      continue;
+    }
+    if (inQuotes && ch === "\\") {
+      escaping = true;
+      continue;
+    }
+    if (ch === '"') {
+      inQuotes = !inQuotes;
+      continue;
+    }
+    if (!inQuotes && ch === ",") {
+      const label = current.trim();
+      if (label) labels.push(label);
+      current = "";
+      continue;
+    }
+    current += ch;
+  }
+  if (inQuotes) throw new Error(`Unterminated bucket label: ${spec}`);
+  const tail = current.trim();
+  if (tail) labels.push(tail);
+  return labels;
+}
+function splitBucketDirective(spec) {
+  let inQuotes = false;
+  let escaping = false;
+  for (let i = 0; i < spec.length; i++) {
+    const ch = spec[i];
+    if (escaping) {
+      escaping = false;
+      continue;
+    }
+    if (inQuotes && ch === "\\") {
+      escaping = true;
+      continue;
+    }
+    if (ch === '"') {
+      inQuotes = !inQuotes;
+      continue;
+    }
+    if (!inQuotes && ch === ":") {
+      return { id: spec.slice(0, i).trim(), entries: spec.slice(i + 1).trim() };
+    }
+  }
+  return null;
+}
+function parseBucketId(spec) {
+  const [label = ""] = parseBucketLabels(spec);
+  return /^\d+$/.test(label) ? Number(label) : label;
+}
+function normalizeDoc(doc) {
+  const chains = doc.chains ?? [];
+  const bucketLabels = [...doc.bucketLabels ?? []];
+  for (const chain of chains) {
+    if (typeof chain.index === "string" && !bucketLabels.includes(chain.index)) bucketLabels.push(chain.index);
+  }
+  const maxIdx = chains.reduce((mx, c) => typeof c.index === "number" ? Math.max(mx, c.index) : mx, -1);
+  const numericBucketCount = Math.max(doc.buckets ?? 0, maxIdx + 1, 1);
+  if (bucketLabels.length === 0) {
+    for (let i = 0; i < numericBucketCount; i++) bucketLabels.push(String(i));
+  } else {
+    while (bucketLabels.length < numericBucketCount) bucketLabels.push(String(bucketLabels.length));
+  }
+  return {
+    ...doc.title !== void 0 ? { title: doc.title } : {},
+    buckets: bucketLabels.length,
+    bucketLabels,
+    chains
+  };
+}
 function parse10(input) {
   let title;
   let bucketCount;
+  let explicitBucketLabels;
   const chains = [];
   for (const line of lines(input)) {
     const t = line.split(/\s+/);
@@ -43782,18 +44537,25 @@ function parse10(input) {
       continue;
     }
     if (t[0] === "buckets") {
-      const n = Number(t[1]);
-      if (Number.isFinite(n)) bucketCount = n;
+      const spec = line.slice(7).trim();
+      if (!spec) continue;
+      if (/^\d+$/.test(spec)) {
+        bucketCount = Number(spec);
+        explicitBucketLabels = void 0;
+      } else {
+        explicitBucketLabels = parseBucketLabels(spec);
+      }
       continue;
     }
     if (t[0] === "bucket") {
-      const m = line.match(/^bucket\s+(\d+)\s*:\s*(.*)$/);
-      if (m) chains.push({ index: Number(m[1]), entries: parseEntries(m[2]) });
+      const parsed = splitBucketDirective(line.slice(6).trim());
+      if (parsed) chains.push({ index: parseBucketId(parsed.id), entries: parseEntries(parsed.entries) });
     }
   }
-  const maxIdx = chains.reduce((mx, c) => Math.max(mx, c.index), -1);
-  const buckets = Math.max(bucketCount ?? maxIdx + 1, maxIdx + 1, 1);
-  return { ...title !== void 0 ? { title } : {}, buckets, chains };
+  return normalizeDoc({ title, buckets: bucketCount, bucketLabels: explicitBucketLabels, chains });
+}
+function bucketKey(id) {
+  return typeof id === "number" ? `n:${id}` : `s:${id}`;
 }
 function layoutHashmap(doc, theme) {
   const { palette, typography, spacing } = theme;
@@ -43801,7 +44563,7 @@ function layoutHashmap(doc, theme) {
   const margin = spacing.diagramMargin;
   const font = typography.baseFontSize;
   const cellH = 38;
-  const idxW = 46;
+  const idxW = Math.max(46, ...doc.bucketLabels.map((label) => measureText(label, font).width + 24));
   const entryH = 30;
   const entryGap = 30;
   const chainGap = 36;
@@ -43811,22 +44573,23 @@ function layoutHashmap(doc, theme) {
   if (doc.title) {
     elements.push(p.text(doc.title, margin, margin + typography.titleFontSize, typography.titleFontSize, palette.text, { weight: "bold" }));
   }
-  const slots = [];
+  const slotById = /* @__PURE__ */ new Map();
+  const anchors = {};
   for (let i = 0; i < doc.buckets; i++) {
     const slot = { x: origin.x, y: origin.y + i * cellH, width: idxW, height: cellH };
-    slots.push(slot);
+    const label = doc.bucketLabels[i] ?? String(i);
+    slotById.set(bucketKey(i), { row: i, bounds: slot });
+    if (!slotById.has(bucketKey(label))) slotById.set(bucketKey(label), { row: i, bounds: slot });
+    anchors[`b${i}`] = { bounds: slot };
     elements.push(p.rect(slot, palette.surface, palette.border, 1.5, { rx: 3 }));
-    elements.push(p.text(String(i), slot.x + slot.width / 2, slot.y + slot.height / 2 + font * 0.35, font, palette.textMuted, { anchor: "middle", weight: "bold" }));
+    elements.push(p.text(label, slot.x + slot.width / 2, slot.y + slot.height / 2 + font * 0.35, font, palette.textMuted, { anchor: "middle", weight: "bold" }));
   }
-  const anchors = {};
-  slots.forEach((slot, i) => {
-    anchors[`b${i}`] = { bounds: slot };
-  });
   const chainStartX = origin.x + idxW + chainGap;
   let maxRight = chainStartX;
   for (const chain of doc.chains) {
-    const slot = slots[chain.index];
-    if (!slot || chain.entries.length === 0) continue;
+    const slotRef = slotById.get(bucketKey(chain.index));
+    if (!slotRef || chain.entries.length === 0) continue;
+    const { bounds: slot, row } = slotRef;
     const cy = slot.y + slot.height / 2;
     let x = chainStartX;
     let fromX = slot.x + slot.width;
@@ -43837,7 +44600,7 @@ function layoutHashmap(doc, theme) {
       elements.push(p.path(`M ${rhu(fromX)} ${rhu(cy)} L ${rhu(x - 3)} ${rhu(cy)}`, palette.primary, 1.5, { markerEnd: ARROW_ID2 }));
       elements.push(p.rect(box, palette.surface, palette.border, 1.5, { rx: 4 }));
       elements.push(p.text(label, x + w / 2, cy + font * 0.35, font, palette.text, { anchor: "middle", weight: "bold" }));
-      anchors[`b${chain.index}e${j}`] = { bounds: box };
+      anchors[`b${row}e${j}`] = { bounds: box };
       fromX = x + w;
       x = fromX + entryGap;
       maxRight = Math.max(maxRight, fromX);
@@ -43858,7 +44621,7 @@ var hashmap = {
     return { version: "1.0", metadata: {}, ...parse10(input) };
   },
   parseYaml(input) {
-    return JSON.parse(input);
+    return { version: "1.0", metadata: {}, ...normalizeDoc(JSON.parse(input)) };
   },
   layout(ir, theme) {
     return layoutHashmap(ir, theme);