@diagrammo/dgmo 0.46.0 → 0.48.0

package/dist/chunk-33LCUH4H.js

@@ -0,0 +1,893 @@
+import {
+  INFRA_BEHAVIOR_KEY_SET,
+  INFRA_EDGE_ONLY_KEY_SET,
+  INFRA_TOP_LEVEL_OPTION_SET
+} from "./chunk-DKEPS5LH.js";
+import {
+  tryStripDescriptionKeyword
+} from "./chunk-IYULMRBE.js";
+import {
+  matchTagBlockHeading,
+  stripDefaultModifier,
+  tagAttrKey,
+  validateTagGroupNames
+} from "./chunk-QLCCJEJI.js";
+import {
+  GRAPH_DX
+} from "./chunk-I46X5VUA.js";
+import {
+  parseInArrowLabel
+} from "./chunk-FFUN5D66.js";
+import {
+  displayName,
+  normalizeName
+} from "./chunk-NOTA6TEI.js";
+import {
+  INFRA_REGISTRY,
+  OPTION_NOCOLON_RE,
+  measureIndent,
+  parseFirstLine,
+  tryParseSharedOption,
+  warnUnknownMetaKeys,
+  withTagAliases
+} from "./chunk-Y3J7VR52.js";
+import {
+  isRecognizedColorName
+} from "./chunk-TLVIHFRO.js";
+import {
+  NAME_DIAGNOSTIC_CODES,
+  emit,
+  formatDgmoError,
+  makeDgmoError,
+  nameMergedMessage,
+  suggest
+} from "./chunk-CXK4DZH3.js";
+
+// src/infra/types.ts
+var INFRA_BEHAVIOR_KEYS = INFRA_BEHAVIOR_KEY_SET;
+var EDGE_ONLY_KEYS = INFRA_EDGE_ONLY_KEY_SET;
+
+// src/infra/parser.ts
+var CONNECTION_RE = /^-(?:([^-].*?))?->\s*(.+?)\s*$/;
+var SIMPLE_CONNECTION_RE = /^->\s*(.+?)\s*$/;
+var ASYNC_CONNECTION_RE = /^~(?:([^~].*?))?~>\s*(.+?)\s*$/;
+var ASYNC_SIMPLE_CONNECTION_RE = /^~>\s*(.+?)\s*$/;
+var DEPRECATED_FANOUT_RE = /\bx(\d+)\s*$/;
+var GROUP_RE = /^\[([^\]]+)\]\s*(?:as\s+([A-Za-z][A-Za-z0-9_]{0,11})\s*)?((?:\|.*)|(?:[a-zA-Z_]\w*\s*:.*))?$/;
+var TAG_VALUE_RE = /^(\w[\w\s]+?)\s*$/;
+var COMPONENT_RE = /^(?:"(?<qname>[^"]+)"|(?<uname>[a-zA-Z_][\w -]*?))(?:\s+as\s+(?<alias>[A-Za-z][A-Za-z0-9_]{0,11}))?\s*(?<meta>(?:\|.*)|(?:[a-zA-Z_]\w*\s*:.*))?$/;
+var PIPE_META_RE = /[|,]\s*(\w+)\s*:\s*([^|,]+)/g;
+var SAMELINE_META_RE = /(?:^|[\s,])(\w+)\s*:\s*([^,]+?)(?=\s*,|\s*$)/g;
+var PROPERTY_RE = /^([\w-]+):\s*(.+)$/;
+var PERCENT_RE = /^([\d.]+)%$/;
+var RANGE_RE = /^(\d+)-(\d+)$/;
+var EDGE_NODE_NAMES = /* @__PURE__ */ new Set(["edge", "internet"]);
+var INFRA_TOP_LEVEL_OPTIONS = INFRA_TOP_LEVEL_OPTION_SET;
+var TOP_LEVEL_OPTIONS = INFRA_TOP_LEVEL_OPTIONS;
+function nodeId(name) {
+  return normalizeName(name);
+}
+function groupId(name) {
+  return `[${normalizeName(name)}]`;
+}
+function parsePropertyValue(raw) {
+  const pct = raw.match(PERCENT_RE);
+  if (pct) return parseFloat(pct[1]);
+  const num = parseFloat(raw);
+  if (!isNaN(num) && String(num) === raw.trim()) return num;
+  return raw.trim();
+}
+function extractPipeMetadata(rest) {
+  const tags = {};
+  let clean = rest;
+  let match;
+  const hadPipe = rest.includes("|");
+  if (hadPipe) {
+    PIPE_META_RE.lastIndex = 0;
+    while ((match = PIPE_META_RE.exec(rest)) !== null) {
+      tags[match[1].trim()] = match[2].trim();
+      clean = clean.replace(match[0], "");
+    }
+    return { tags, clean: clean.trim(), hadPipe: true };
+  }
+  SAMELINE_META_RE.lastIndex = 0;
+  let firstMatchIdx = -1;
+  while ((match = SAMELINE_META_RE.exec(rest)) !== null) {
+    tags[match[1].trim()] = match[2].trim();
+    if (firstMatchIdx === -1) firstMatchIdx = match.index;
+  }
+  if (firstMatchIdx >= 0) {
+    clean = rest.substring(0, firstMatchIdx).trim();
+  }
+  return { tags, clean: clean.trim(), hadPipe: false };
+}
+var UNPARSED_SPLIT_RE = /\bsplit\s+(\d+)%/;
+function warnUnparsedPipeMeta(targetName, lineNumber, warnFn) {
+  if (!targetName.includes("|")) return;
+  const splitMatch = targetName.match(UNPARSED_SPLIT_RE);
+  if (splitMatch) {
+    warnFn(
+      lineNumber,
+      `'split ${splitMatch[1]}%' needs a colon \u2014 use 'split: ${splitMatch[1]}%'`
+    );
+  } else {
+    warnFn(
+      lineNumber,
+      `Unparsed pipe metadata in target \u2014 pipe values use 'key: value' syntax`
+    );
+  }
+}
+function parseInfra(content) {
+  const lines = content.split("\n");
+  const options = {};
+  const result = {
+    type: "infra",
+    title: null,
+    titleLineNumber: null,
+    direction: "LR",
+    nodes: [],
+    edges: [],
+    groups: [],
+    tagGroups: [],
+    options,
+    diagnostics: [],
+    error: null
+  };
+  const nodeMap = /* @__PURE__ */ new Map();
+  const nodeMutableTags = /* @__PURE__ */ new Map();
+  function pushDescription(node, text) {
+    const existing = node.description ?? [];
+    existing.push(text);
+    node.description = existing;
+  }
+  const tagAliasSet = /* @__PURE__ */ new Set();
+  const EDGE_PIPE_REGISTRY = {
+    keys: /* @__PURE__ */ new Set(["split", "fanout"]),
+    tagAliases: /* @__PURE__ */ new Set()
+  };
+  const nameAliasMap = /* @__PURE__ */ new Map();
+  function peelAlias(label) {
+    const trimmed = label.trim();
+    const m = trimmed.match(/^(.*?)\s+as\s+([A-Za-z][A-Za-z0-9_]{0,11})\s*$/);
+    if (!m) return { label: trimmed };
+    return { label: m[1].trim(), ...m[2] !== void 0 && { alias: m[2] } };
+  }
+  const IS_A_SUFFIX = /^(.*?)\s+is\s+an?\s+[A-Za-z][\w-]*\s*$/i;
+  function peelInfraDecorations(rawName, lineNumber) {
+    const peeled = peelAlias(rawName);
+    const m = peeled.label.match(IS_A_SUFFIX);
+    if (!m) return peeled;
+    warn(
+      lineNumber,
+      `Infra nodes don't use 'is a <type>' \u2014 types are inferred from properties (cache-hit, buffer, drain-rate, \u2026). Drop the 'is a' suffix.`
+    );
+    return {
+      label: m[1].trim(),
+      ...peeled.alias !== void 0 && { alias: peeled.alias }
+    };
+  }
+  function resolveTargetId(rawName) {
+    const aliasResolved = nameAliasMap.get(rawName.trim());
+    if (aliasResolved !== void 0) return aliasResolved;
+    return nodeId(rawName);
+  }
+  const targetDisplays = /* @__PURE__ */ new Map();
+  const rememberTargetDisplay = (key, display) => {
+    if (!targetDisplays.has(key)) targetDisplays.set(key, display.trim());
+  };
+  const setError = (line, message) => {
+    const diag = makeDgmoError(line, message);
+    result.diagnostics.push(diag);
+    if (!result.error) result.error = formatDgmoError(diag);
+  };
+  const warn = (line, message) => {
+    result.diagnostics.push(makeDgmoError(line, message, "warning"));
+  };
+  let currentNode = null;
+  let currentGroup = null;
+  let currentTagGroup = null;
+  let baseIndent = 0;
+  let firstLineConsumed = false;
+  function finishCurrentNode() {
+    if (!currentNode) return;
+    const key = currentNode.id;
+    const existing = nodeMap.get(key);
+    if (existing) {
+      const incomingDisplay = displayName(currentNode.label);
+      const existingDisplay = displayName(existing.label);
+      const isAliasRef = nameAliasMap.get(currentNode.label) === key;
+      if (incomingDisplay !== existingDisplay && !isAliasRef) {
+        result.diagnostics.push(
+          makeDgmoError(
+            currentNode.lineNumber,
+            nameMergedMessage({
+              incomingDisplay,
+              incomingLine: currentNode.lineNumber,
+              existingDisplay,
+              existingLine: existing.lineNumber
+            }),
+            "warning",
+            NAME_DIAGNOSTIC_CODES.NAME_MERGED
+          )
+        );
+      }
+      currentNode = null;
+      return;
+    }
+    const keys = new Set(currentNode.properties.map((p) => p.key));
+    if (keys.has("concurrency") && (keys.has("instances") || keys.has("max-rps"))) {
+      const conflicting = [
+        keys.has("instances") ? "instances" : "",
+        keys.has("max-rps") ? "max-rps" : ""
+      ].filter(Boolean).join(", ");
+      warn(
+        currentNode.lineNumber,
+        `'concurrency' (serverless) is mutually exclusive with ${conflicting}. Serverless nodes scale via concurrency, not instances.`
+      );
+    }
+    if (keys.has("buffer") && keys.has("max-rps")) {
+      warn(
+        currentNode.lineNumber,
+        `'buffer' (queue) and 'max-rps' (service) represent different capacity models. A queue buffers messages; a service processes them.`
+      );
+    }
+    nodeMap.set(key, currentNode);
+    result.nodes.push(currentNode);
+    currentNode = null;
+  }
+  function finishCurrentTagGroup() {
+    if (currentTagGroup) {
+      result.tagGroups.push(currentTagGroup);
+    }
+    currentTagGroup = null;
+  }
+  for (let i = 0; i < lines.length; i++) {
+    const raw = lines[i];
+    const lineNumber = i + 1;
+    const trimmed = raw.trim();
+    const indent = measureIndent(raw);
+    if (!trimmed || trimmed.startsWith("//")) continue;
+    if (/^#{2,}\s+/.test(trimmed)) continue;
+    if (indent === 0) {
+      if (indent === 0 && currentNode && !trimmed.startsWith("-")) {
+        finishCurrentNode();
+      }
+      if (!firstLineConsumed) {
+        firstLineConsumed = true;
+        const firstLineResult = parseFirstLine(trimmed);
+        if (firstLineResult) {
+          if (firstLineResult.chartType !== "infra") {
+            setError(
+              lineNumber,
+              `Expected chart type 'infra', got '${firstLineResult.chartType}'`
+            );
+          }
+          if (firstLineResult.title) {
+            result.title = firstLineResult.title;
+            result.titleLineNumber = lineNumber;
+          }
+          continue;
+        }
+      }
+      if (/^direction-tb$/i.test(trimmed)) {
+        result.direction = "TB";
+        continue;
+      }
+      if (trimmed === "animate" || trimmed === "no-animate") {
+        warn(
+          lineNumber,
+          '"animate" / "no-animate" have been removed \u2014 animation is controlled by the rendering context.'
+        );
+        continue;
+      }
+      if (tryParseSharedOption(trimmed, options)) {
+        continue;
+      }
+      const optMatch = trimmed.match(OPTION_NOCOLON_RE);
+      if (optMatch && TOP_LEVEL_OPTIONS.has(optMatch[1].toLowerCase())) {
+        options[optMatch[1].toLowerCase()] = optMatch[2].trim();
+        continue;
+      }
+      const tagMatch = matchTagBlockHeading(trimmed);
+      if (tagMatch) {
+        finishCurrentNode();
+        finishCurrentTagGroup();
+        if (tagMatch.alias) tagAliasSet.add(normalizeName(tagMatch.alias));
+        currentTagGroup = {
+          name: tagMatch.name,
+          alias: tagMatch.alias ?? null,
+          values: [],
+          lineNumber
+        };
+        continue;
+      }
+      const groupMatch = trimmed.match(GROUP_RE);
+      if (groupMatch) {
+        finishCurrentNode();
+        finishCurrentTagGroup();
+        const gLabel = groupMatch[1].trim();
+        const groupAlias = groupMatch[2];
+        const gId = groupId(gLabel);
+        if (groupAlias) nameAliasMap.set(groupAlias, gId);
+        const groupMeta = groupMatch[3] ? extractPipeMetadata(groupMatch[3]).tags : void 0;
+        if (groupMeta) {
+          warnUnknownMetaKeys(
+            groupMeta,
+            withTagAliases(INFRA_REGISTRY, tagAliasSet),
+            (msg) => warn(lineNumber, msg)
+          );
+        }
+        const hasMeta = groupMeta && Object.keys(groupMeta).length > 0;
+        const newGroup = {
+          id: gId,
+          label: gLabel,
+          ...hasMeta && { metadata: groupMeta },
+          lineNumber
+        };
+        currentGroup = newGroup;
+        result.groups.push(newGroup);
+        continue;
+      }
+      const compMatch = trimmed.match(COMPONENT_RE);
+      if (compMatch) {
+        finishCurrentNode();
+        finishCurrentTagGroup();
+        const { qname, uname, alias: asAlias, meta } = compMatch.groups;
+        const rawName = (qname ?? uname ?? "").trim();
+        const peeled = peelInfraDecorations(rawName, lineNumber);
+        const name = peeled.label;
+        const alias = asAlias ?? peeled.alias;
+        const rest = meta ?? "";
+        const { tags } = extractPipeMetadata(rest);
+        warnUnknownMetaKeys(
+          tags,
+          withTagAliases(INFRA_REGISTRY, tagAliasSet),
+          (msg) => warn(lineNumber, msg)
+        );
+        const id = nameAliasMap.get(name) ?? nodeId(name);
+        if (alias) nameAliasMap.set(alias, id);
+        const isEdge = EDGE_NODE_NAMES.has(id.toLowerCase());
+        currentNode = {
+          id,
+          label: name,
+          properties: [],
+          groupId: null,
+          tags,
+          isEdge,
+          lineNumber
+        };
+        nodeMutableTags.set(id, tags);
+        currentGroup = null;
+        baseIndent = 0;
+        continue;
+      }
+    }
+    if (currentTagGroup && indent > 0) {
+      const { text: cleanEntry, isDefault } = stripDefaultModifier(trimmed);
+      const lastSpaceIdx = cleanEntry.lastIndexOf(" ");
+      let valueName = cleanEntry;
+      let rawColor;
+      if (lastSpaceIdx > 0) {
+        const trailing = cleanEntry.substring(lastSpaceIdx + 1);
+        if (isRecognizedColorName(trailing)) {
+          rawColor = trailing;
+          valueName = cleanEntry.substring(0, lastSpaceIdx).trimEnd();
+        }
+      }
+      const tvMatch = valueName.match(TAG_VALUE_RE);
+      if (tvMatch || /^\w+$/.test(valueName)) {
+        currentTagGroup.values.push({
+          name: valueName,
+          ...rawColor !== void 0 && { color: rawColor }
+        });
+        if (isDefault) {
+          currentTagGroup.defaultValue = valueName;
+        } else if (currentTagGroup.values.length === 1) {
+          currentTagGroup.defaultValue = valueName;
+        }
+        continue;
+      }
+      warn(
+        lineNumber,
+        `Invalid tag value '${trimmed}' in tag group '${currentTagGroup.name}' \u2014 a value is a bare word with an optional trailing color (e.g. 'Production red'); no ':' or '|'.`
+      );
+      continue;
+    }
+    if (currentGroup && !currentNode && indent > 0) {
+      const propMatch = trimmed.match(PROPERTY_RE);
+      if (propMatch) {
+        const key = propMatch[1].toLowerCase();
+        const val = propMatch[2].trim();
+        if (key === "instances") {
+          const rangeM = val.match(RANGE_RE);
+          if (rangeM) {
+            currentGroup.instances = val;
+          } else {
+            const num = parseInt(val, 10);
+            if (!isNaN(num)) currentGroup.instances = num;
+          }
+          continue;
+        }
+        if (key === "collapsed") {
+          currentGroup.collapsed = val.toLowerCase() === "true";
+          continue;
+        }
+      }
+      const compMatch = trimmed.match(COMPONENT_RE);
+      if (compMatch) {
+        finishCurrentTagGroup();
+        const { qname, uname, alias: asAlias, meta } = compMatch.groups;
+        const rawName = (qname ?? uname ?? "").trim();
+        const peeled = peelInfraDecorations(rawName, lineNumber);
+        const name = peeled.label;
+        const alias = asAlias ?? peeled.alias;
+        const rest = meta ?? "";
+        const { tags: nodeTags } = extractPipeMetadata(rest);
+        warnUnknownMetaKeys(
+          nodeTags,
+          withTagAliases(INFRA_REGISTRY, tagAliasSet),
+          (msg) => warn(lineNumber, msg)
+        );
+        const id = nameAliasMap.get(name) ?? nodeId(name);
+        if (alias) nameAliasMap.set(alias, id);
+        const tags = currentGroup.metadata ? { ...currentGroup.metadata, ...nodeTags } : nodeTags;
+        currentNode = {
+          id,
+          label: name,
+          properties: [],
+          groupId: currentGroup.id,
+          tags,
+          isEdge: false,
+          lineNumber
+        };
+        nodeMutableTags.set(id, tags);
+        baseIndent = indent;
+        continue;
+      }
+    }
+    if (currentNode && indent > baseIndent) {
+      const deprecatedFanout = trimmed.match(DEPRECATED_FANOUT_RE);
+      if (deprecatedFanout && (trimmed.startsWith("->") || trimmed.startsWith("-") || trimmed.startsWith("~"))) {
+        const n = deprecatedFanout[1];
+        setError(
+          lineNumber,
+          `'x${n}' fanout syntax is no longer supported \u2014 use 'fanout: ${n}' instead`
+        );
+        continue;
+      }
+      const asyncSimpleConn = trimmed.match(ASYNC_SIMPLE_CONNECTION_RE);
+      if (asyncSimpleConn) {
+        const targetRaw = asyncSimpleConn[1].trim();
+        const pipeMeta = extractPipeMetadata(targetRaw);
+        const targetName = pipeMeta.clean || targetRaw;
+        warnUnparsedPipeMeta(targetName, lineNumber, warn);
+        warnUnknownMetaKeys(
+          pipeMeta.tags,
+          EDGE_PIPE_REGISTRY,
+          (msg) => warn(lineNumber, msg)
+        );
+        const split = pipeMeta.tags["split"] ? parseFloat(pipeMeta.tags["split"]) : null;
+        const fanoutRaw = pipeMeta.tags["fanout"] ? parseInt(pipeMeta.tags["fanout"], 10) : null;
+        if (fanoutRaw !== null && fanoutRaw < 1) {
+          warn(
+            lineNumber,
+            `Fan-out multiplier must be at least 1 (got fanout: ${fanoutRaw}). Ignoring.`
+          );
+        }
+        const fanout = fanoutRaw !== null && fanoutRaw >= 1 ? fanoutRaw : null;
+        const targetIdAsync = resolveTargetId(targetName);
+        rememberTargetDisplay(targetIdAsync, targetName);
+        result.edges.push({
+          sourceId: currentNode.id,
+          targetId: targetIdAsync,
+          label: "",
+          async: true,
+          split,
+          fanout,
+          lineNumber
+        });
+        continue;
+      }
+      const asyncConnMatch = trimmed.match(ASYNC_CONNECTION_RE);
+      if (asyncConnMatch) {
+        const rawLabel = asyncConnMatch[1] ?? "";
+        const labelResult = parseInArrowLabel(rawLabel, lineNumber);
+        result.diagnostics.push(...labelResult.diagnostics);
+        const label = labelResult.label ?? "";
+        const targetRaw = asyncConnMatch[2].trim();
+        const pipeMeta = extractPipeMetadata(targetRaw);
+        const targetName = pipeMeta.clean || targetRaw;
+        warnUnparsedPipeMeta(targetName, lineNumber, warn);
+        warnUnknownMetaKeys(
+          pipeMeta.tags,
+          EDGE_PIPE_REGISTRY,
+          (msg) => warn(lineNumber, msg)
+        );
+        const split = pipeMeta.tags["split"] ? parseFloat(pipeMeta.tags["split"]) : null;
+        const fanoutRaw = pipeMeta.tags["fanout"] ? parseInt(pipeMeta.tags["fanout"], 10) : null;
+        if (fanoutRaw !== null && fanoutRaw < 1) {
+          warn(
+            lineNumber,
+            `Fan-out multiplier must be at least 1 (got fanout: ${fanoutRaw}). Ignoring.`
+          );
+        }
+        const fanout = fanoutRaw !== null && fanoutRaw >= 1 ? fanoutRaw : null;
+        let targetId;
+        const targetGroupMatch = targetName.match(/^\[([^\]]+)\]/);
+        if (targetGroupMatch) {
+          targetId = groupId(targetGroupMatch[1]);
+          rememberTargetDisplay(targetId, `[${targetGroupMatch[1]}]`);
+        } else {
+          targetId = resolveTargetId(targetName);
+          rememberTargetDisplay(targetId, targetName);
+        }
+        result.edges.push({
+          sourceId: currentNode.id,
+          targetId,
+          label,
+          async: true,
+          split,
+          fanout,
+          lineNumber
+        });
+        continue;
+      }
+      const simpleConn = trimmed.match(SIMPLE_CONNECTION_RE);
+      if (simpleConn) {
+        const targetRaw = simpleConn[1].trim();
+        const pipeMeta = extractPipeMetadata(targetRaw);
+        const targetName = pipeMeta.clean || targetRaw;
+        warnUnparsedPipeMeta(targetName, lineNumber, warn);
+        warnUnknownMetaKeys(
+          pipeMeta.tags,
+          EDGE_PIPE_REGISTRY,
+          (msg) => warn(lineNumber, msg)
+        );
+        const split = pipeMeta.tags["split"] ? parseFloat(pipeMeta.tags["split"]) : null;
+        const fanoutRaw = pipeMeta.tags["fanout"] ? parseInt(pipeMeta.tags["fanout"], 10) : null;
+        if (fanoutRaw !== null && fanoutRaw < 1) {
+          warn(
+            lineNumber,
+            `Fan-out multiplier must be at least 1 (got fanout: ${fanoutRaw}). Ignoring.`
+          );
+        }
+        const fanout = fanoutRaw !== null && fanoutRaw >= 1 ? fanoutRaw : null;
+        const targetIdSimple = resolveTargetId(targetName);
+        rememberTargetDisplay(targetIdSimple, targetName);
+        result.edges.push({
+          sourceId: currentNode.id,
+          targetId: targetIdSimple,
+          label: "",
+          async: false,
+          split,
+          fanout,
+          lineNumber
+        });
+        continue;
+      }
+      const connMatch = trimmed.match(CONNECTION_RE);
+      if (connMatch) {
+        const rawLabel = connMatch[1] ?? "";
+        const labelResult = parseInArrowLabel(rawLabel, lineNumber);
+        result.diagnostics.push(...labelResult.diagnostics);
+        const label = labelResult.label ?? "";
+        const targetRaw = connMatch[2].trim();
+        const pipeMeta = extractPipeMetadata(targetRaw);
+        const targetName = pipeMeta.clean || targetRaw;
+        warnUnparsedPipeMeta(targetName, lineNumber, warn);
+        warnUnknownMetaKeys(
+          pipeMeta.tags,
+          EDGE_PIPE_REGISTRY,
+          (msg) => warn(lineNumber, msg)
+        );
+        const split = pipeMeta.tags["split"] ? parseFloat(pipeMeta.tags["split"]) : null;
+        const fanoutRaw = pipeMeta.tags["fanout"] ? parseInt(pipeMeta.tags["fanout"], 10) : null;
+        if (fanoutRaw !== null && fanoutRaw < 1) {
+          warn(
+            lineNumber,
+            `Fan-out multiplier must be at least 1 (got fanout: ${fanoutRaw}). Ignoring.`
+          );
+        }
+        const fanout = fanoutRaw !== null && fanoutRaw >= 1 ? fanoutRaw : null;
+        let targetId;
+        const targetGroupMatch = targetName.match(/^\[([^\]]+)\]/);
+        if (targetGroupMatch) {
+          targetId = groupId(targetGroupMatch[1]);
+          rememberTargetDisplay(targetId, `[${targetGroupMatch[1]}]`);
+        } else {
+          targetId = resolveTargetId(targetName);
+          rememberTargetDisplay(targetId, targetName);
+        }
+        result.edges.push({
+          sourceId: currentNode.id,
+          targetId,
+          label,
+          async: false,
+          split,
+          fanout,
+          lineNumber
+        });
+        continue;
+      }
+      if (/^description\s*:?\s*$/i.test(trimmed)) continue;
+      const propMatch = trimmed.match(PROPERTY_RE);
+      if (propMatch) {
+        const key = propMatch[1].toLowerCase();
+        const rawVal = propMatch[2].trim();
+        if (key === "description" && currentNode) {
+          if (!currentNode.isEdge) {
+            pushDescription(currentNode, rawVal);
+          }
+          continue;
+        }
+        if (currentNode && tagAliasSet.has(normalizeName(key))) {
+          const mut = nodeMutableTags.get(currentNode.id);
+          if (mut) mut[tagAttrKey(key)] = rawVal;
+          continue;
+        }
+        if (!INFRA_BEHAVIOR_KEYS.has(key) && !EDGE_ONLY_KEYS.has(key)) {
+          const allKeys = [...INFRA_BEHAVIOR_KEYS, ...EDGE_ONLY_KEYS];
+          const hint = suggest(key, allKeys);
+          const valueLooksNumeric = /^[\d.]+%?$/.test(rawVal);
+          if (hint || valueLooksNumeric) {
+            let msg = `Unknown infra property '${key}'.`;
+            if (hint) msg += ` ${hint}`;
+            else
+              msg += ` Properties are colon-keyed 'key: value' from the known schema (e.g. latency-ms, max-rps, cache-hit, instances, concurrency).`;
+            warn(lineNumber, msg);
+          } else if (!currentNode.isEdge) {
+            pushDescription(currentNode, trimmed);
+            continue;
+          }
+          continue;
+        }
+        if (EDGE_ONLY_KEYS.has(key) && !currentNode.isEdge) {
+          warn(
+            lineNumber,
+            `Property '${key}' belongs on the entry point \u2014 declare it indented under an 'internet' or 'edge' node, not on '${currentNode.label}'.`
+          );
+        }
+        const value = parsePropertyValue(rawVal);
+        currentNode.properties.push({ key, value, lineNumber });
+        continue;
+      }
+      const descResult = tryStripDescriptionKeyword(trimmed);
+      if (descResult.isKeyword && !descResult.needsColon) {
+        if (currentNode.isEdge) {
+          continue;
+        }
+        pushDescription(currentNode, descResult.text);
+        continue;
+      }
+      warn(
+        lineNumber,
+        `Unexpected line inside component '${currentNode.label}'. Expected a property (key: value), connection (-> Target), or a description (description: text).`
+      );
+      continue;
+    }
+    if (currentGroup && indent > 0) {
+      finishCurrentNode();
+      const compMatch = trimmed.match(COMPONENT_RE);
+      if (compMatch) {
+        const { qname, uname, alias: asAlias, meta } = compMatch.groups;
+        const rawName = (qname ?? uname ?? "").trim();
+        const peeled = peelInfraDecorations(rawName, lineNumber);
+        const name = peeled.label;
+        const alias = asAlias ?? peeled.alias;
+        const rest = meta ?? "";
+        const { tags: nodeTags } = extractPipeMetadata(rest);
+        warnUnknownMetaKeys(
+          nodeTags,
+          withTagAliases(INFRA_REGISTRY, tagAliasSet),
+          (msg) => warn(lineNumber, msg)
+        );
+        const id = nameAliasMap.get(name) ?? nodeId(name);
+        if (alias) nameAliasMap.set(alias, id);
+        const tags = currentGroup.metadata ? { ...currentGroup.metadata, ...nodeTags } : nodeTags;
+        currentNode = {
+          id,
+          label: name,
+          properties: [],
+          groupId: currentGroup.id,
+          tags,
+          isEdge: false,
+          lineNumber
+        };
+        nodeMutableTags.set(id, tags);
+        baseIndent = indent;
+        continue;
+      }
+    }
+    if (indent === 0) {
+      const compMatch = trimmed.match(COMPONENT_RE);
+      if (compMatch) {
+        finishCurrentNode();
+        finishCurrentTagGroup();
+        currentGroup = null;
+        const { qname, uname, alias: asAlias, meta } = compMatch.groups;
+        const rawName = (qname ?? uname ?? "").trim();
+        const peeled = peelInfraDecorations(rawName, lineNumber);
+        const name = peeled.label;
+        const alias = asAlias ?? peeled.alias;
+        const rest = meta ?? "";
+        const { tags } = extractPipeMetadata(rest);
+        warnUnknownMetaKeys(
+          tags,
+          withTagAliases(INFRA_REGISTRY, tagAliasSet),
+          (msg) => warn(lineNumber, msg)
+        );
+        const id = nameAliasMap.get(name) ?? nodeId(name);
+        if (alias) nameAliasMap.set(alias, id);
+        currentNode = {
+          id,
+          label: name,
+          properties: [],
+          groupId: null,
+          tags,
+          isEdge: EDGE_NODE_NAMES.has(id.toLowerCase()),
+          lineNumber
+        };
+        nodeMutableTags.set(id, tags);
+        baseIndent = 0;
+        continue;
+      }
+    }
+    warn(
+      lineNumber,
+      currentGroup ? `Unexpected line: '${trimmed}'. Inside a group, indent a component name under the '[Group]'.` : `Unexpected line: '${trimmed}'. Expected a node ('Api Gateway'), a group ('[Backend]'), a tag group ('tag Tier as t'), or an option ('default-rps 100'); node properties go indented under a node as 'key: value'.`
+    );
+  }
+  finishCurrentNode();
+  finishCurrentTagGroup();
+  for (const edge of result.edges) {
+    if (!nodeMap.has(edge.targetId)) {
+      const isGroup = result.groups.some((g) => g.id === edge.targetId);
+      if (!isGroup) {
+        const stubDisplay = targetDisplays.get(edge.targetId) ?? edge.targetId;
+        const stubTags = {};
+        const stub = {
+          id: edge.targetId,
+          label: stubDisplay,
+          properties: [],
+          groupId: null,
+          tags: stubTags,
+          isEdge: false,
+          lineNumber: edge.lineNumber
+        };
+        nodeMap.set(stub.id, stub);
+        result.nodes.push(stub);
+        nodeMutableTags.set(stub.id, stubTags);
+      }
+    }
+  }
+  for (const tg of result.tagGroups) {
+    if (!tg.defaultValue) continue;
+    const key = tagAttrKey(tg.alias ?? tg.name);
+    for (const node of result.nodes) {
+      if (node.isEdge) continue;
+      if (!(key in node.tags)) {
+        const tags = nodeMutableTags.get(node.id);
+        if (tags) tags[key] = tg.defaultValue;
+      }
+    }
+  }
+  validateTagGroupNames(result.tagGroups, warn, setError);
+  checkReachability(result);
+  return result;
+}
+function checkReachability(result) {
+  if (result.nodes.length === 0) return;
+  const entries = result.nodes.filter((n) => n.isEdge);
+  if (entries.length === 0) {
+    const line = result.titleLineNumber ?? result.nodes[0]?.lineNumber ?? 1;
+    result.diagnostics.push(emit(GRAPH_DX.INFRA_NO_ENTRY, line));
+    return;
+  }
+  const groupChildMap = /* @__PURE__ */ new Map();
+  for (const node of result.nodes) {
+    if (node.groupId) {
+      const list = groupChildMap.get(node.groupId) ?? [];
+      list.push(node.id);
+      groupChildMap.set(node.groupId, list);
+    }
+  }
+  const outbound = /* @__PURE__ */ new Map();
+  for (const edge of result.edges) {
+    const targets = groupChildMap.get(edge.targetId) ?? [edge.targetId];
+    const list = outbound.get(edge.sourceId) ?? [];
+    list.push(...targets);
+    outbound.set(edge.sourceId, list);
+  }
+  const reachable = /* @__PURE__ */ new Set();
+  const queue = [];
+  for (const entry of entries) {
+    reachable.add(entry.id);
+    queue.push(entry.id);
+  }
+  while (queue.length > 0) {
+    const current = queue.shift();
+    for (const next of outbound.get(current) ?? []) {
+      if (!reachable.has(next)) {
+        reachable.add(next);
+        queue.push(next);
+      }
+    }
+  }
+  for (const node of result.nodes) {
+    if (node.isEdge || reachable.has(node.id)) continue;
+    result.diagnostics.push(
+      emit(GRAPH_DX.INFRA_UNREACHABLE, node.lineNumber, { label: node.label })
+    );
+  }
+}
+function stripNodeDecorations(name) {
+  let s = name.trim();
+  const aliasMatch = s.match(/^(.*?)\s+as\s+[A-Za-z][A-Za-z0-9_]{0,11}\s*$/);
+  if (aliasMatch) s = aliasMatch[1].trim();
+  const isAMatch = s.match(/^(.*?)\s+is\s+an?\s+[A-Za-z][\w-]*\s*$/i);
+  if (isAMatch) s = isAMatch[1].trim();
+  return s;
+}
+function extractSymbols(docText) {
+  const entities = [];
+  let inMetadata = true;
+  let inTagGroup = false;
+  for (const rawLine of docText.split("\n")) {
+    const line = rawLine.trim();
+    if (line.length === 0) continue;
+    const indented = /^\s/.test(rawLine);
+    if (inMetadata) {
+      if (!indented) {
+        const firstLine = parseFirstLine(line);
+        if (firstLine) continue;
+        if (/^(?:direction-tb|animate|no-animate|slo-|default-)/i.test(line))
+          continue;
+        if (/^[a-z-]+\s*:/i.test(line)) continue;
+        inMetadata = false;
+      } else {
+        continue;
+      }
+    }
+    if (!indented) {
+      if (/^tag\s/i.test(line)) {
+        inTagGroup = true;
+        continue;
+      }
+      if (/^tag\s*:/i.test(line)) {
+        inTagGroup = true;
+        continue;
+      }
+      inTagGroup = false;
+      if (/^\[/.test(line)) continue;
+      const m = COMPONENT_RE.exec(line);
+      if (m) {
+        const name = stripNodeDecorations((m[1] ?? m[2] ?? "").trim());
+        if (name && !entities.includes(name)) entities.push(name);
+      }
+    } else {
+      if (inTagGroup) continue;
+      if (/^->/.test(line)) continue;
+      if (/^~>/.test(line)) continue;
+      if (/^-[^>]+-?>/.test(line)) continue;
+      if (/^~[^~]+~>/.test(line)) continue;
+      if (/^\w[\w-]*\s*:/.test(line)) continue;
+      const firstToken = line.split(/\s/)[0].toLowerCase();
+      if ((INFRA_BEHAVIOR_KEYS.has(firstToken) || EDGE_ONLY_KEYS.has(firstToken) || firstToken === "description" || firstToken === "instances" || firstToken === "collapsed") && /\s/.test(line))
+        continue;
+      const m = COMPONENT_RE.exec(line);
+      if (m) {
+        const name = stripNodeDecorations((m[1] ?? m[2] ?? "").trim());
+        if (name && !entities.includes(name)) entities.push(name);
+      }
+    }
+  }
+  return { kind: "infra", entities };
+}
+
+export {
+  INFRA_BEHAVIOR_KEYS,
+  INFRA_TOP_LEVEL_OPTIONS,
+  parseInfra,
+  extractSymbols
+};
+//# sourceMappingURL=chunk-33LCUH4H.js.map