@diagrammo/dgmo 0.45.0 → 0.47.0

package/dist/chunk-GMR5MFHJ.js

@@ -0,0 +1,339 @@
+import {
+  TIMELINE_REGISTRY,
+  splitNameAndMeta,
+  warnUnknownMetaKeys,
+  withTagAliases
+} from "./chunk-Y3J7VR52.js";
+import {
+  makeDgmoError
+} from "./chunk-CXK4DZH3.js";
+
+// src/timeline/parser.ts
+var TIMELINE_DURATION_RE = /^(\d+(?:\.\d{1,2})?)(min|[dwmyhs])(\?)?$/;
+var DATE_RE = /^(\d{4}(?:-\d{2}(?:-\d{2})?)?)/;
+var TIME_RE = /^\s+(\d{1,2}:\d{2}(?::\d{2})?)/;
+var ARROW_RE = /^\s*(?:->|–>)\s*/;
+var ERA_DATE_RE = /^(\d{1,4}(?:-\d{2}(?:-\d{2})?)?)\s+(BCE|BC|CE|AD)\b/i;
+function parseTime(timeStr) {
+  const [hStr, mStr, sStr] = timeStr.split(":");
+  const h = parseInt(hStr, 10);
+  const m = parseInt(mStr, 10);
+  const s = sStr !== void 0 ? parseInt(sStr, 10) : 0;
+  const valid = h >= 0 && h <= 23 && m >= 0 && m <= 59 && s >= 0 && s <= 59;
+  return { valid, h, m, s };
+}
+function parseDateWithOptionalTime(input) {
+  const eraMatch = input.match(ERA_DATE_RE);
+  if (eraMatch) {
+    const marker = eraMatch[2].toUpperCase();
+    const bce = marker === "BCE" || marker === "BC";
+    const date2 = (bce ? "-" : "") + eraMatch[1];
+    return {
+      date: date2,
+      rest: input.slice(eraMatch[0].length),
+      timeValid: true,
+      invalidTime: void 0
+    };
+  }
+  const dateMatch = input.match(DATE_RE);
+  if (!dateMatch) return null;
+  let date = dateMatch[1];
+  let rest = input.slice(date.length);
+  let timeValid = true;
+  let invalidTime;
+  const timeMatch = rest.match(TIME_RE);
+  if (timeMatch) {
+    const timeStr = timeMatch[1];
+    const { valid } = parseTime(timeStr);
+    timeValid = valid;
+    if (!valid) invalidTime = timeStr;
+    date = `${date} ${timeStr}`;
+    rest = rest.slice(timeMatch[0].length);
+  }
+  return { date, rest, timeValid, invalidTime };
+}
+function extractDatePrefix(line) {
+  const startResult = parseDateWithOptionalTime(line);
+  if (!startResult) return null;
+  const { date: startDate } = startResult;
+  let { rest } = startResult;
+  const arrowMatch = rest.match(ARROW_RE);
+  if (arrowMatch) {
+    rest = rest.slice(arrowMatch[0].length);
+    const endResult = parseDateWithOptionalTime(rest);
+    if (endResult) {
+      let uncertain = false;
+      let afterEnd = endResult.rest;
+      if (afterEnd.startsWith("?")) {
+        uncertain = true;
+        afterEnd = afterEnd.slice(1);
+      }
+      const remainder2 = afterEnd.trimStart();
+      return {
+        startDate,
+        endDate: endResult.date,
+        uncertain,
+        remainder: remainder2,
+        startTimeValid: startResult.timeValid,
+        endTimeValid: endResult.timeValid,
+        invalidStartTime: startResult.invalidTime,
+        invalidEndTime: endResult.invalidTime
+      };
+    }
+    return null;
+  }
+  const remainder = rest.trimStart();
+  if (!remainder) {
+    return {
+      startDate,
+      endDate: null,
+      uncertain: false,
+      remainder: "",
+      startTimeValid: startResult.timeValid,
+      endTimeValid: true,
+      invalidStartTime: startResult.invalidTime,
+      invalidEndTime: void 0
+    };
+  }
+  return {
+    startDate,
+    endDate: null,
+    uncertain: false,
+    remainder,
+    startTimeValid: startResult.timeValid,
+    endTimeValid: true,
+    invalidStartTime: startResult.invalidTime,
+    invalidEndTime: void 0
+  };
+}
+function splitDateParts(input) {
+  let s = input;
+  let sign = 1;
+  if (s.startsWith("-")) {
+    sign = -1;
+    s = s.slice(1);
+  }
+  const spaceIdx = s.indexOf(" ");
+  let datePart = s;
+  let hour = 0;
+  let minute = 0;
+  let second = 0;
+  let hasTime = false;
+  if (spaceIdx !== -1) {
+    datePart = s.slice(0, spaceIdx);
+    const tp = s.slice(spaceIdx + 1).split(":");
+    if (tp.length >= 2) {
+      hasTime = true;
+      hour = parseInt(tp[0], 10) || 0;
+      minute = parseInt(tp[1], 10) || 0;
+      second = tp.length >= 3 ? parseInt(tp[2], 10) || 0 : 0;
+    }
+  }
+  const parts = datePart.split("-").map((p) => parseInt(p, 10));
+  const granularity = parts.length >= 3 ? 3 : parts.length === 2 ? 2 : 1;
+  return {
+    sign,
+    year: parts[0],
+    month: parts.length >= 2 ? parts[1] : 1,
+    day: parts.length >= 3 ? parts[2] : 1,
+    hour,
+    minute,
+    second,
+    granularity,
+    hasTime
+  };
+}
+function addDurationToDate(startDate, amount, unit) {
+  const p = splitDateParts(startDate);
+  const signedYear = p.sign * p.year;
+  const date = new Date(2e3, p.month - 1, p.day, p.hour, p.minute, p.second);
+  date.setFullYear(signedYear);
+  switch (unit) {
+    case "d":
+      date.setDate(date.getDate() + Math.round(amount));
+      break;
+    case "w":
+      date.setDate(date.getDate() + Math.round(amount * 7));
+      break;
+    case "m": {
+      const wholeMonths = Math.floor(amount);
+      const fractionalDays = Math.round((amount - wholeMonths) * 30);
+      date.setMonth(date.getMonth() + wholeMonths);
+      if (fractionalDays > 0) {
+        date.setDate(date.getDate() + fractionalDays);
+      }
+      break;
+    }
+    case "y": {
+      const wholeYears = Math.floor(amount);
+      const fractionalMonths = Math.round((amount - wholeYears) * 12);
+      date.setFullYear(date.getFullYear() + wholeYears);
+      if (fractionalMonths > 0) {
+        date.setMonth(date.getMonth() + fractionalMonths);
+      }
+      break;
+    }
+    case "h":
+      date.setTime(date.getTime() + amount * 36e5);
+      break;
+    case "min":
+      date.setTime(date.getTime() + amount * 6e4);
+      break;
+    case "s":
+      date.setTime(date.getTime() + amount * 1e3);
+      break;
+  }
+  const outYear = date.getFullYear();
+  const neg = outYear < 0 ? "-" : "";
+  const endYear = Math.abs(outYear);
+  const endMonth = String(date.getMonth() + 1).padStart(2, "0");
+  const endDay = String(date.getDate()).padStart(2, "0");
+  const endHour = String(date.getHours()).padStart(2, "0");
+  const endMinute = String(date.getMinutes()).padStart(2, "0");
+  const endSecond = String(date.getSeconds()).padStart(2, "0");
+  const hasTime = unit === "h" || unit === "min" || unit === "s" || p.hasTime;
+  const showSeconds = unit === "s" || p.second !== 0 || date.getSeconds() !== 0;
+  if (p.granularity === 1) {
+    return `${neg}${endYear}`;
+  } else if (p.granularity === 2) {
+    return `${neg}${endYear}-${endMonth}`;
+  } else if (hasTime && (date.getHours() !== 0 || date.getMinutes() !== 0 || date.getSeconds() !== 0)) {
+    const time = showSeconds ? `${endHour}:${endMinute}:${endSecond}` : `${endHour}:${endMinute}`;
+    return `${neg}${endYear}-${endMonth}-${endDay} ${time}`;
+  } else {
+    return `${neg}${endYear}-${endMonth}-${endDay}`;
+  }
+}
+function parseTimelineDate(s) {
+  const p = splitDateParts(s);
+  const yearBase = p.sign * p.year;
+  return yearBase + (p.month - 1) / 12 + (p.day - 1) / 365 + p.hour / 8760 + p.minute / 525600 + p.second / 31536e3;
+}
+function parseTimelineEventLine(line, lineNumber, currentGroup, groupMetadata, aliasMap, registry) {
+  const diagnostics = [];
+  const prefix = extractDatePrefix(line);
+  if (!prefix) {
+    if (/^\d/.test(line)) {
+      const firstToken = line.split(/\s/)[0];
+      if (!/^\d{4}(?:-\d{2}(?:-\d{2})?)?$/.test(firstToken)) {
+        diagnostics.push(
+          makeDgmoError(
+            lineNumber,
+            `Expected date format YYYY, YYYY-MM, or YYYY-MM-DD. Got '${firstToken}'.`,
+            "warning"
+          )
+        );
+        return { event: null, diagnostics };
+      }
+    }
+    return null;
+  }
+  if (!prefix.startTimeValid && prefix.invalidStartTime) {
+    diagnostics.push(
+      makeDgmoError(
+        lineNumber,
+        `Invalid time '${prefix.invalidStartTime}'. Hours must be 0-23, minutes 0-59.`,
+        "warning"
+      )
+    );
+  }
+  if (!prefix.endTimeValid && prefix.invalidEndTime) {
+    diagnostics.push(
+      makeDgmoError(
+        lineNumber,
+        `Invalid time '${prefix.invalidEndTime}'. Hours must be 0-23, minutes 0-59.`,
+        "warning"
+      )
+    );
+  }
+  if (!prefix.remainder) {
+    diagnostics.push(
+      makeDgmoError(lineNumber, "Event needs a name after the date.", "warning")
+    );
+    return { event: null, diagnostics };
+  }
+  const tlRegistry = registry ?? withTagAliases(
+    TIMELINE_REGISTRY,
+    /* @__PURE__ */ new Set([...aliasMap.keys(), ...aliasMap.values()])
+  );
+  const split = splitNameAndMeta(prefix.remainder, tlRegistry, aliasMap);
+  warnUnknownMetaKeys(
+    split.meta,
+    tlRegistry,
+    (msg) => diagnostics.push(makeDgmoError(lineNumber, msg, "warning"))
+  );
+  const name = split.name;
+  let endDate = prefix.endDate;
+  let uncertain = prefix.uncertain;
+  const metadata = { ...split.meta };
+  let duration = null;
+  if (metadata["duration"]) {
+    const durStr = metadata["duration"];
+    const uncertainMatch = durStr.match(/^(.+)\?$/);
+    const cleanDur = uncertainMatch ? uncertainMatch[1] : durStr;
+    if (uncertainMatch) uncertain = true;
+    const durMatch = cleanDur.match(TIMELINE_DURATION_RE);
+    if (durMatch) {
+      duration = {
+        amount: parseFloat(durMatch[1]),
+        unit: durMatch[2]
+      };
+    } else {
+      diagnostics.push(
+        makeDgmoError(
+          lineNumber,
+          `Invalid duration '${durStr}'. Expected format like "30d", "2w", "1.5m", "1y", "2h", "30min", "45s".`,
+          "warning"
+        )
+      );
+    }
+    delete metadata["duration"];
+  }
+  if (endDate && duration) {
+    diagnostics.push(
+      makeDgmoError(
+        lineNumber,
+        "Event has both an end date and duration. End date takes precedence.",
+        "warning"
+      )
+    );
+  }
+  if (!endDate && duration) {
+    endDate = addDurationToDate(
+      prefix.startDate,
+      duration.amount,
+      duration.unit
+    );
+  }
+  let label = name;
+  if (split.color !== void 0) {
+    label = `${label} ${split.color}`;
+  }
+  const mergedMetadata = {
+    ...groupMetadata,
+    ...metadata
+  };
+  if (split.color) {
+    mergedMetadata["color"] = split.color;
+  }
+  const eventMeta = { ...mergedMetadata };
+  if (split.color) delete eventMeta["color"];
+  const event = {
+    date: prefix.startDate,
+    endDate,
+    label,
+    group: currentGroup,
+    metadata: eventMeta,
+    lineNumber,
+    ...uncertain ? { uncertain: true } : {}
+  };
+  return { event, diagnostics };
+}
+
+export {
+  extractDatePrefix,
+  addDurationToDate,
+  parseTimelineDate,
+  parseTimelineEventLine
+};
+//# sourceMappingURL=chunk-GMR5MFHJ.js.map

package/dist/chunk-H6PI3KJT.js

@@ -0,0 +1,305 @@
+import {
+  measureText
+} from "./chunk-WCT3NYCV.js";
+
+// src/wireframe/layout.ts
+var DESKTOP_WIDTH = 1200;
+var MOBILE_WIDTH = 375;
+var LABEL_PADDING = 16;
+var LABEL_FIELD_FONT_SIZE = 13;
+var ELEMENT_HEIGHTS = {
+  textInput: 36,
+  button: 40,
+  dropdown: 36,
+  checkbox: 24,
+  radio: 24,
+  heading: 48,
+  subheading: 36,
+  divider: 24,
+  text: 22,
+  listItem: 24,
+  image: 120,
+  progress: 28,
+  chart: 160,
+  alert: 40,
+  nav: 44,
+  tabs: 44
+};
+var SPACING_AFTER = {
+  heading: 16,
+  subheading: 12,
+  divider: 12,
+  textInput: 8,
+  dropdown: 8,
+  checkbox: 8,
+  radio: 8,
+  button: 8,
+  text: 12,
+  listItem: 4,
+  group: 16,
+  image: 12,
+  progress: 12,
+  chart: 16,
+  alert: 12,
+  nav: 12,
+  tabs: 12,
+  table: 16
+};
+var GROUP_PADDING_TOP_WITH_LABEL = 32;
+var GROUP_PADDING_TOP_NO_LABEL = 10;
+var GROUP_PADDING_BOTTOM = 12;
+var GROUP_PADDING_TOP = GROUP_PADDING_TOP_WITH_LABEL;
+var GROUP_PADDING_X = 12;
+var FRAME_PADDING = 20;
+var TITLE_HEIGHT = 40;
+var REGION_SIZES = {
+  sidebar: 0.25,
+  side: 0.25,
+  left: 0.25,
+  right: 0.25,
+  main: 0,
+  // fill remaining
+  content: 0,
+  // fill remaining
+  center: 0
+  // fill remaining
+};
+var FULL_WIDTH_REGIONS = /* @__PURE__ */ new Set(["header", "top", "footer", "bottom"]);
+var HEADER_REGION_HEIGHT = 60;
+var FOOTER_REGION_HEIGHT = 40;
+function layoutWireframe(parsed, _options, overrideWidth, showGroupLabels = true) {
+  GROUP_PADDING_TOP = showGroupLabels ? GROUP_PADDING_TOP_WITH_LABEL : GROUP_PADDING_TOP_NO_LABEL;
+  const defaultWidth = parsed.formFactor === "mobile" ? MOBILE_WIDTH : DESKTOP_WIDTH;
+  const frameWidth = overrideWidth ?? defaultWidth;
+  const titleHeight = parsed.title && parsed.options["no-title"] !== "on" ? TITLE_HEIGHT : 0;
+  const contentWidth = frameWidth - FRAME_PADDING * 2;
+  const nodes = layoutTopLevel(parsed.roots, contentWidth, parsed.formFactor);
+  let maxY = 0;
+  for (const n of nodes) {
+    maxY = Math.max(maxY, n.y + n.height);
+  }
+  const modalNodes = [];
+  let modalY = maxY + 24;
+  for (const modal of parsed.modals) {
+    const modalWidth = Math.min(contentWidth * 0.7, 600);
+    const modalX = (contentWidth - modalWidth) / 2;
+    const node = layoutElement(modal, modalX, modalY, modalWidth);
+    modalNodes.push(node);
+    modalY += node.height + 24;
+  }
+  const totalHeight = (modalNodes.length > 0 ? (
+    // In-bounds by length-check above.
+    modalNodes[modalNodes.length - 1].y + modalNodes[modalNodes.length - 1].height
+  ) : maxY) + FRAME_PADDING * 2 + titleHeight;
+  return {
+    width: frameWidth,
+    height: totalHeight,
+    titleHeight,
+    nodes,
+    modalNodes
+  };
+}
+function layoutTopLevel(roots, contentWidth, formFactor) {
+  const result = [];
+  let y = 0;
+  const rows = [];
+  let currentRow = [];
+  for (const root of roots) {
+    const regionName = root.label.toLowerCase().split(/\s+/)[0];
+    if (FULL_WIDTH_REGIONS.has(regionName) || formFactor === "mobile") {
+      if (currentRow.length > 0) {
+        rows.push(currentRow);
+        currentRow = [];
+      }
+      rows.push([root]);
+    } else {
+      currentRow.push(root);
+    }
+  }
+  if (currentRow.length > 0) rows.push(currentRow);
+  for (const row of rows) {
+    if (row.length === 1 && formFactor !== "mobile") {
+      const el = row[0];
+      const regionName = el.label.toLowerCase().split(/\s+/)[0];
+      if (FULL_WIDTH_REGIONS.has(regionName)) {
+        const node = layoutElement(el, 0, y, contentWidth);
+        if (regionName === "header" || regionName === "top") {
+          node.height = Math.max(node.height, HEADER_REGION_HEIGHT);
+        } else {
+          node.height = Math.max(node.height, FOOTER_REGION_HEIGHT);
+        }
+        result.push(node);
+        y += node.height + 16;
+        continue;
+      }
+    }
+    if (formFactor === "mobile" || row.length === 1) {
+      for (const el of row) {
+        const node = layoutElement(el, 0, y, contentWidth);
+        result.push(node);
+        y += node.height + 16;
+      }
+    } else {
+      const allocated = allocateHorizontalWidths(row, contentWidth);
+      let x = 0;
+      let maxHeight = 0;
+      const rowNodes = [];
+      for (let i = 0; i < row.length; i++) {
+        const w = allocated[i];
+        const node = layoutElement(row[i], x, y, w);
+        rowNodes.push(node);
+        maxHeight = Math.max(maxHeight, node.height);
+        x += w + 12;
+      }
+      for (const n of rowNodes) {
+        n.height = maxHeight;
+      }
+      result.push(...rowNodes);
+      y += maxHeight + 16;
+    }
+  }
+  return result;
+}
+function allocateHorizontalWidths(elements, totalWidth) {
+  const gap = 12;
+  const totalGaps = (elements.length - 1) * gap;
+  const available = totalWidth - totalGaps;
+  const widths = new Array(elements.length).fill(0);
+  let allocated = 0;
+  let fillCount = 0;
+  for (let i = 0; i < elements.length; i++) {
+    const name = elements[i].label.toLowerCase().split(/\s+/)[0];
+    const fraction = REGION_SIZES[name];
+    if (fraction !== void 0 && fraction > 0) {
+      widths[i] = available * fraction;
+      allocated += widths[i];
+    } else if (fraction === 0) {
+      fillCount++;
+    } else {
+      fillCount++;
+    }
+  }
+  if (fillCount > 0) {
+    const remaining = Math.max(0, available - allocated);
+    const each = remaining / fillCount;
+    for (let i = 0; i < widths.length; i++) {
+      if (widths[i] === 0) widths[i] = Math.max(40, each);
+    }
+  }
+  for (let i = 0; i < widths.length; i++) {
+    widths[i] = Math.max(40, widths[i]);
+  }
+  return widths;
+}
+function layoutElement(el, x, y, width) {
+  const node = {
+    id: el.id,
+    x,
+    y,
+    width,
+    height: 0,
+    element: el,
+    children: []
+  };
+  const selfRendered = el.type === "nav" || el.type === "tabs";
+  if (!el.isContainer || el.children.length === 0 || selfRendered) {
+    node.height = getElementHeight(el);
+    return node;
+  }
+  const isInlineRow = el.metadata["_inlineRow"] === "true" || el.metadata["_labelField"] === "true";
+  const padTop = isInlineRow ? 0 : GROUP_PADDING_TOP;
+  const padBottom = isInlineRow ? 0 : GROUP_PADDING_BOTTOM;
+  const padX = isInlineRow ? 0 : GROUP_PADDING_X;
+  const innerWidth = width - padX * 2;
+  const innerX = padX;
+  if (el.orientation === "horizontal") {
+    const childWidths = allocateEqualWidths(el.children, innerWidth);
+    let cx = innerX;
+    let maxChildHeight = 0;
+    const horizChildren = [];
+    for (let i = 0; i < el.children.length; i++) {
+      const child = el.children[i];
+      const cw = childWidths[i];
+      const childNode = layoutElement(child, cx, padTop, cw);
+      horizChildren.push(childNode);
+      node.children.push(childNode);
+      maxChildHeight = Math.max(maxChildHeight, childNode.height);
+      cx += cw + 8;
+    }
+    for (const cn of horizChildren) {
+      cn.height = maxChildHeight;
+    }
+    node.height = padTop + maxChildHeight + padBottom;
+  } else {
+    let cy = padTop;
+    const fieldAlignX = computeFieldAlignX(el.children);
+    if (fieldAlignX > 0) {
+      node.fieldAlignX = fieldAlignX;
+    }
+    for (const child of el.children) {
+      const childNode = layoutElement(child, innerX, cy, innerWidth);
+      node.children.push(childNode);
+      cy += childNode.height + getSpacingAfter(child);
+    }
+    node.height = cy + padBottom;
+  }
+  if (el.states.includes("collapsed")) {
+    node.height = GROUP_PADDING_TOP;
+    node.children = [];
+  }
+  return node;
+}
+function allocateEqualWidths(children, totalWidth) {
+  const gap = 8;
+  const totalGaps = (children.length - 1) * gap;
+  const each = Math.max(40, (totalWidth - totalGaps) / children.length);
+  return children.map(() => each);
+}
+function getElementHeight(el) {
+  if (el.type === "heading") {
+    return el.headingLevel === 2 ? ELEMENT_HEIGHTS["subheading"] ?? 36 : ELEMENT_HEIGHTS["heading"] ?? 48;
+  }
+  if (el.type === "textInput" && el.fieldVariant === "textarea") {
+    return 80;
+  }
+  if (el.type === "table") {
+    const headerH = 32;
+    const rowH = 28;
+    const rows = el.tableData?.length || el.tableRows || 0;
+    return headerH + rows * rowH + 8;
+  }
+  if (el.type === "image") {
+    if (el.imageHint === "round") return 80;
+    if (el.imageHint === "wide") return 80;
+    return ELEMENT_HEIGHTS["image"] ?? 120;
+  }
+  if (el.metadata["_labelField"] === "true") {
+    return 36;
+  }
+  return ELEMENT_HEIGHTS[el.type] ?? 24;
+}
+function getSpacingAfter(el) {
+  if (el.type === "heading" && el.headingLevel === 2) {
+    return SPACING_AFTER["subheading"] ?? 12;
+  }
+  return SPACING_AFTER[el.type] ?? 8;
+}
+function computeFieldAlignX(children) {
+  let maxLabelWidth = 0;
+  let labelFieldCount = 0;
+  for (const child of children) {
+    if (child.metadata["_labelField"] === "true" && child.children.length >= 2) {
+      const labelEl = child.children[0];
+      const labelWidth = measureText(labelEl.label, LABEL_FIELD_FONT_SIZE);
+      maxLabelWidth = Math.max(maxLabelWidth, labelWidth);
+      labelFieldCount++;
+    }
+  }
+  if (labelFieldCount < 2) return 0;
+  return maxLabelWidth + LABEL_PADDING;
+}
+
+export {
+  layoutWireframe
+};
+//# sourceMappingURL=chunk-H6PI3KJT.js.map

package/dist/chunk-I46X5VUA.js

@@ -0,0 +1,59 @@
+// src/graph/diagnostics.ts
+var GRAPH_DX = {
+  INFRA_NO_ENTRY: {
+    // src/infra/parser.ts:1094 — makeDgmoError(..., 'warning', 'W_INFRA_NO_ENTRY')
+    code: "W_INFRA_NO_ENTRY",
+    severity: "warning",
+    chartType: "infra",
+    title: "Infra diagram has no entry point",
+    message: "Infra diagram has no 'internet' or 'edge' entry point \u2014 an infra diagram traces request traffic from an entry inward, so without one nothing carries traffic. Add an 'internet' or 'edge' node and route from it.",
+    hint: "Add an 'internet' or 'edge' node and draw an edge from it into the graph.",
+    example: `infra
+gw
+  -> svc
+svc
+`
+  },
+  INFRA_UNREACHABLE: {
+    // src/infra/parser.ts:1145 — makeDgmoError(..., 'warning', 'W_INFRA_UNREACHABLE')
+    code: "W_INFRA_UNREACHABLE",
+    severity: "warning",
+    chartType: "infra",
+    title: "Infra node is unreachable from an entry",
+    message: (p) => `'${String(p.label ?? "")}' is unreachable from an 'internet'/'edge' entry \u2014 no request traffic flows to it, so it's dead on an infra diagram. Connect it downstream of an entry, or remove it.`,
+    hint: "Connect the node downstream of an entry, or remove it.",
+    example: `infra
+
+edge
+  rps: 1000
+  -> A
+
+A
+  latency-ms: 10
+
+Orphan
+  latency-ms: 20
+`
+  },
+  FLOWCHART_NODE_SUFFIX: {
+    // src/graph/flowchart-parser.ts:329 — makeDgmoError(..., 'warning', 'W_FLOWCHART_NODE_SUFFIX')
+    code: "W_FLOWCHART_NODE_SUFFIX",
+    severity: "warning",
+    chartType: "flowchart",
+    title: "Unsupported text after a flowchart node shape",
+    message: (p) => `Ignored unsupported text after a node shape: "${String(
+      p.trailing ?? ""
+    )}". Flowcharts have no tag groups or node metadata; node colors are assigned automatically by shape (e.g. terminals green/red, decisions yellow). Remove the suffix.`,
+    hint: "Remove the trailing tag/metadata suffix \u2014 flowchart node colors come from shape.",
+    example: `flowchart
+(Start) -> (Denied) s: Denied
+`
+  }
+};
+var GRAPH_DIAGNOSTICS = Object.values(GRAPH_DX);
+
+export {
+  GRAPH_DX,
+  GRAPH_DIAGNOSTICS
+};
+//# sourceMappingURL=chunk-I46X5VUA.js.map