@markdy/compat 1.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Hoang Yell (https://hoangyell.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,64 @@
+# @markdy/compat
+
+Universal Ingestion Transpilers & Backwards-Compatibility Gate for Markdy.
+
+`@markdy/compat` enables seamless migration from existing diagramming and infrastructure tools into animated, diagram-native MarkdyScript scenes.
+
+---
+
+## Features
+
+- **Mermaid Transpiler**: Converts Mermaid Flowcharts (`flowchart LR/TB/TD`) and Sequence Diagrams (`sequenceDiagram`) into animated Markdy scenes.
+- **Draw.io Ingestion**: Converts `.drawio` / `.xml` diagram graphs into structured MarkdyScript scenes with port attachments and label preservation.
+- **Docker Compose Ingestion**: Parses `docker-compose.yml` into connected service topologies with port allocations and dependency order.
+- **Kubernetes Manifests Transpiler**: Converts multi-document K8s manifests into namespace groups, ingresses, load balancers, and workloads.
+- **Terraform State Ingestion**: Converts `.tfstate` files into VPC-clustered infrastructure diagrams.
+- **Backwards-Compatibility Snapshot Gate**: Automated regression test suite ensuring Markdy parser stability across releases.
+
+<p align="center">
+  <a href="https://markdy.com/playground/">
+    <img src="https://raw.githubusercontent.com/HoangYell/markdy-com/main/website/public/images/markdy-universal-ingestion.webp" alt="Universal Ingestion Transpilers" width="900" />
+  </a>
+</p>
+<p align="center">
+  <a href="https://markdy.com/playground/">
+    <img src="https://raw.githubusercontent.com/HoangYell/markdy-com/main/website/public/images/scene-nested-security.webp" alt="Kubernetes Manifest Ingestion Preview" width="900" />
+  </a>
+</p>
+
+---
+
+## Programmatic API
+
+```typescript
+import {
+  transpileMermaidToMarkdy,
+  transpileDrawioToMarkdy,
+  transpileDockerComposeToMarkdy,
+  transpileKubernetesManifestsToMarkdy,
+  transpileTerraformStateToMarkdy,
+} from "@markdy/compat";
+
+// 1. Mermaid Flowchart
+const mermaidResult = transpileMermaidToMarkdy(`
+  flowchart LR
+    Client --> Gateway[API Gateway]
+    Gateway --> DB[(Database)]
+`);
+console.log(mermaidResult.code);
+
+// 2. Docker Compose
+const composeCode = transpileDockerComposeToMarkdy(dockerComposeYamlString);
+
+// 3. Kubernetes Manifests
+const k8sCode = transpileKubernetesManifestsToMarkdy(k8sManifestYamlString);
+
+// 4. Terraform State
+const tfCode = transpileTerraformStateToMarkdy(tfstateJsonString);
+```
+
+---
+
+## License
+
+MIT © [Hoang Yell](https://hoangyell.com)

package/dist/chunk-UQF5UJH6.js

@@ -0,0 +1,185 @@
+// src/mermaid/mermaid-transpiler.ts
+function sanitizeId(id) {
+  return id.trim().replace(/[^a-zA-Z0-9_]/g, "_");
+}
+function cleanLabel(raw) {
+  return raw.trim().replace(/^["'\[\(\{]+/, "").replace(/["'\]\)\}]+$/, "").replace(/<br\s*\/?>/gi, " ");
+}
+function inferKindFromMermaid(id, label, shapeBracket) {
+  const text = `${id} ${label}`.toLowerCase();
+  if (shapeBracket === "[(" || shapeBracket === ")]" || /(db|database|sql|postgres|mongo|dynamo|redis)/.test(text)) {
+    return "database";
+  }
+  if (shapeBracket === "{{" || shapeBracket === "}}" || /(queue|kafka|rabbitmq|sqs|event|bus)/.test(text)) {
+    return "queue";
+  }
+  if (shapeBracket === "{" || shapeBracket === "}" || /(decision|check|valid|auth|gate)/.test(text)) {
+    return "gateway";
+  }
+  if (shapeBracket === "([" || shapeBracket === "])" || /(client|user|browser|ui|app|web|frontend)/.test(text)) {
+    return "browser";
+  }
+  if (/(cache|memcached|varnish)/.test(text)) return "cache";
+  if (/(storage|s3|bucket|blob)/.test(text)) return "storage";
+  if (/(worker|cron|job|lambda|function)/.test(text)) return "worker";
+  return "service";
+}
+function transpileMermaidToMarkdy(mermaidSource, sceneTitle = "Imported Diagram") {
+  const lines = mermaidSource.split(/\r?\n/).map((l) => l.trim()).filter((l) => l && !l.startsWith("%%"));
+  if (lines.length === 0) {
+    return {
+      code: `scene theme=paper
+layout LR
+`,
+      diagramType: "architecture",
+      nodeCount: 0,
+      edgeCount: 0
+    };
+  }
+  const firstLine = lines[0].toLowerCase();
+  if (firstLine.startsWith("sequencediagram")) {
+    return transpileSequenceDiagram(lines.slice(1), sceneTitle);
+  }
+  return transpileFlowchart(lines, sceneTitle);
+}
+function transpileSequenceDiagram(lines, title) {
+  const participants = /* @__PURE__ */ new Map();
+  const messages = [];
+  for (const line of lines) {
+    const partMatch = /^(?:participant|actor)\s+([^\s]+)(?:\s+as\s+(.+))?$/i.exec(line);
+    if (partMatch) {
+      const id = sanitizeId(partMatch[1]);
+      const label = partMatch[2] ? cleanLabel(partMatch[2]) : id;
+      const kind = inferKindFromMermaid(id, label);
+      participants.set(id, { id, label, kind });
+      continue;
+    }
+    const msgMatch = /^([a-zA-Z0-9_]+)\s*(-->>|->>|->|-->|-\)|~>)\s*([a-zA-Z0-9_]+)\s*:\s*(.+)$/.exec(line);
+    if (msgMatch) {
+      const from = sanitizeId(msgMatch[1]);
+      const arrow = msgMatch[2];
+      const to = sanitizeId(msgMatch[3]);
+      const label = cleanLabel(msgMatch[4]);
+      if (!participants.has(from)) participants.set(from, { id: from, label: from, kind: inferKindFromMermaid(from, from) });
+      if (!participants.has(to)) participants.set(to, { id: to, label: to, kind: inferKindFromMermaid(to, to) });
+      let kind = "->";
+      if (arrow === "-->>" || arrow === "-->" || arrow === "-.->") kind = "~>";
+      messages.push({ from, to, label, kind });
+    }
+  }
+  const out = [];
+  out.push(title ? `scene "${title}" type=sequence theme=paper` : `scene type=sequence theme=paper`);
+  out.push("");
+  for (const p of participants.values()) {
+    out.push(`${p.kind} ${p.id} "${p.label}"`);
+  }
+  out.push("");
+  out.push('beat main "Sequence Flow":');
+  out.push("  show $nodes");
+  for (const msg of messages) {
+    out.push(`  ${msg.from} ${msg.kind} ${msg.to} "${msg.label}"`);
+  }
+  return {
+    code: out.join("\n"),
+    diagramType: "sequence",
+    nodeCount: participants.size,
+    edgeCount: messages.length
+  };
+}
+function transpileFlowchart(lines, title) {
+  let direction = "LR";
+  const first = lines[0].toLowerCase();
+  if (first.startsWith("graph") || first.startsWith("flowchart")) {
+    const dirMatch = /\b(lr|rl|tb|td|bt)\b/i.exec(first);
+    if (dirMatch) {
+      direction = dirMatch[1].toUpperCase();
+      if (direction === "TD") direction = "TB";
+    }
+    lines = lines.slice(1);
+  }
+  const nodes = /* @__PURE__ */ new Map();
+  const groups = /* @__PURE__ */ new Map();
+  const flows = [];
+  let currentSubgraph = null;
+  const explicitNodeRe = /([a-zA-Z0-9_-]+)\s*(\[\([^\n]*?\)\]|\[\[[^\n]*?\]\]|\(\[[^\n]*?\]\)|\(\([^\n]*?\)\)|\[[^\n]*?\]|\{[^\n]*?\}|\([^\n]*?\))/g;
+  const flowPattern = /([a-zA-Z0-9_-]+)\s*(?:\[[^\]]*\]|\([^)]*\)|\{[^}]*\})?\s*(-->|->|==>|-.->|--\s*([^-]+)\s*-->)\s*(?:\|([^|]+)\|)?\s*([a-zA-Z0-9_-]+)/;
+  for (const line of lines) {
+    const subMatch = /^subgraph\s+([a-zA-Z0-9_]+)?\s*(\[.*\]|".*")?/i.exec(line);
+    if (subMatch) {
+      const rawId = subMatch[1] || `group_${groups.size + 1}`;
+      const id = sanitizeId(rawId);
+      const label = subMatch[2] ? cleanLabel(subMatch[2]) : id;
+      currentSubgraph = { id, label, members: [] };
+      groups.set(id, currentSubgraph);
+      continue;
+    }
+    if (line === "end" && currentSubgraph) {
+      currentSubgraph = null;
+      continue;
+    }
+    let match;
+    while ((match = explicitNodeRe.exec(line)) !== null) {
+      const rawId = match[1];
+      const rawBody = match[2];
+      const id = sanitizeId(rawId);
+      const bracket = rawBody.slice(0, 2);
+      const label = cleanLabel(rawBody) || id;
+      const kind = inferKindFromMermaid(id, label, bracket);
+      nodes.set(id, { id, label, kind });
+      if (currentSubgraph && !currentSubgraph.members.includes(id)) {
+        currentSubgraph.members.push(id);
+      }
+    }
+    let remainingLine = line;
+    while (true) {
+      const fMatch = flowPattern.exec(remainingLine);
+      if (!fMatch) break;
+      const from = sanitizeId(fMatch[1]);
+      const arrow = fMatch[2];
+      const inlineLabel = fMatch[3];
+      const pipeLabel = fMatch[4];
+      const to = sanitizeId(fMatch[5]);
+      const label = pipeLabel ? cleanLabel(pipeLabel) : inlineLabel ? cleanLabel(inlineLabel) : void 0;
+      if (!nodes.has(from)) nodes.set(from, { id: from, label: from, kind: inferKindFromMermaid(from, from) });
+      if (!nodes.has(to)) nodes.set(to, { id: to, label: to, kind: inferKindFromMermaid(to, to) });
+      let op = "->";
+      if (arrow.includes("-.->") || arrow.includes("~")) op = "~>";
+      flows.push({ from, to, op, label });
+      const toIndex = fMatch.index + fMatch[0].lastIndexOf(fMatch[5]);
+      if (toIndex === 0) break;
+      remainingLine = remainingLine.substring(toIndex);
+    }
+  }
+  const out = [];
+  out.push(title ? `scene "${title}" theme=paper` : `scene theme=paper`);
+  out.push(`layout ${direction}`);
+  out.push("");
+  for (const g of groups.values()) {
+    if (g.members.length > 0) {
+      out.push(`group ${g.id} "${g.label}": ${g.members.join(" ")}`);
+    }
+  }
+  for (const n of nodes.values()) {
+    out.push(`${n.kind} ${n.id} "${n.label}"`);
+  }
+  out.push("");
+  out.push('beat main "Render Diagram":');
+  out.push("  show $nodes stagger=60ms");
+  for (const flow of flows) {
+    if (flow.label) {
+      out.push(`  ${flow.from} ${flow.op} ${flow.to} "${flow.label}"`);
+    } else {
+      out.push(`  ${flow.from} ${flow.op} ${flow.to}`);
+    }
+  }
+  return {
+    code: out.join("\n"),
+    diagramType: "architecture",
+    nodeCount: nodes.size,
+    edgeCount: flows.length
+  };
+}
+
+export {
+  transpileMermaidToMarkdy
+};

package/dist/index.d.ts

@@ -0,0 +1,125 @@
+export { MermaidTranspileResult, transpileMermaidToMarkdy } from './mermaid/mermaid-transpiler.js';
+
+/**
+ * packages/compat/src/infra/docker-compose-transpiler.ts
+ * Ingests Docker Compose configurations and transpiles to animated MarkdyScript scenes.
+ * Zero external dependencies.
+ */
+interface ComposeServiceSpec {
+    name: string;
+    image?: string;
+    ports?: string[];
+    dependsOn?: string[];
+    networks?: string[];
+}
+declare function parseSimpleYaml(content: string): Record<string, unknown>;
+declare function transpileDockerComposeToMarkdy(yamlContent: string, title?: string): string;
+
+/**
+ * packages/compat/src/infra/k8s-transpiler.ts
+ * Transpiles Kubernetes YAML manifests into animated Markdy architecture scenes.
+ * Zero external dependencies.
+ */
+interface K8sManifest {
+    kind: string;
+    name: string;
+    namespace?: string;
+    selectorLabels?: Record<string, string>;
+    podLabels?: Record<string, string>;
+    services?: string[];
+}
+declare function transpileKubernetesManifestsToMarkdy(manifestContent: string, title?: string): string;
+
+/**
+ * packages/compat/src/infra/terraform-transpiler.ts
+ * Ingests Terraform state files (.tfstate) and emits structured MarkdyScript scenes.
+ * Zero external dependencies.
+ */
+interface TfResourceAttributes {
+    id?: string;
+    name?: string;
+    arn?: string;
+    tags?: Record<string, string>;
+    vpc_id?: string;
+    subnet_id?: string;
+    cluster_id?: string;
+    load_balancer_arn?: string;
+    [key: string]: unknown;
+}
+interface TfResourceInstance {
+    attributes: TfResourceAttributes;
+}
+interface TfResource {
+    type: string;
+    name: string;
+    provider: string;
+    instances: TfResourceInstance[];
+}
+interface TerraformStateJSON {
+    version: number;
+    terraform_version?: string;
+    resources: TfResource[];
+}
+declare function transpileTerraformStateToMarkdy(tfstateContent: string, sceneTitle?: string): string;
+
+/**
+ * packages/compat/src/infra/drawio-transpiler.ts
+ * Transpiles Draw.io / diagrams.net XML and compressed model files into animated MarkdyScript scenes.
+ * Zero external dependencies.
+ */
+interface DrawioCell {
+    id: string;
+    value: string;
+    style: string;
+    isVertex: boolean;
+    isEdge: boolean;
+    source?: string;
+    target?: string;
+    parent?: string;
+}
+interface DrawioModel {
+    title: string;
+    cells: DrawioCell[];
+}
+/**
+ * Parses XML string extracting mxCell elements.
+ */
+declare function parseDrawioXml(xml: string, defaultTitle?: string): DrawioModel;
+/**
+ * Transpiles Draw.io XML or model into MarkdyScript.
+ */
+declare function transpileDrawioToMarkdy(source: string, customTitle?: string): Promise<{
+    code: string;
+    nodeCount: number;
+    edgeCount: number;
+}>;
+
+/**
+ * packages/compat/src/infra/d2-transpiler.ts
+ * Transpiles D2 declarative diagram scripts into MarkdyScript DSL.
+ * Zero external dependencies.
+ */
+interface D2TranspileResult {
+    markdyScript: string;
+    nodeCount: number;
+    edgeCount: number;
+    containerCount: number;
+    warnings: string[];
+}
+declare function transpileD2ToMarkdy(d2Source: string): D2TranspileResult;
+
+/**
+ * packages/compat/src/infra/plantuml-transpiler.ts
+ * Transpiles PlantUML architecture & component diagrams into MarkdyScript DSL.
+ * Zero external dependencies.
+ */
+interface PlantUmlTranspileResult {
+    markdyScript: string;
+    nodeCount: number;
+    edgeCount: number;
+    groupCount: number;
+    warnings: string[];
+}
+declare function transpilePlantUmlToMarkdy(pumlSource: string): PlantUmlTranspileResult;
+
+export { type ComposeServiceSpec, type D2TranspileResult, type DrawioCell, type DrawioModel, type K8sManifest, type PlantUmlTranspileResult, type TerraformStateJSON, type TfResource, type TfResourceAttributes, type TfResourceInstance, parseDrawioXml, parseSimpleYaml, transpileD2ToMarkdy, transpileDockerComposeToMarkdy, transpileDrawioToMarkdy, transpileKubernetesManifestsToMarkdy, transpilePlantUmlToMarkdy, transpileTerraformStateToMarkdy };

package/dist/index.js

@@ -0,0 +1,835 @@
+import {
+  transpileMermaidToMarkdy
+} from "./chunk-UQF5UJH6.js";
+
+// src/infra/docker-compose-transpiler.ts
+function sanitizeIdentifier(name) {
+  return name.replace(/[^a-zA-Z0-9_]/g, "_");
+}
+function inferSemanticKind(serviceName, image) {
+  const combined = `${serviceName} ${image ?? ""}`.toLowerCase();
+  if (/(postgres|mysql|mongo|mariadb|sqlite|cockroach|db)/.test(combined)) return "database";
+  if (/(redis|memcache)/.test(combined)) return "cache";
+  if (/(kafka|rabbitmq|sqs|pulsar|nats|queue)/.test(combined)) return "queue";
+  if (/(nginx|envoy|traefik|caddy|gateway|haproxy)/.test(combined)) return "gateway";
+  if (/(web|frontend|client|ui|react|vue|next)/.test(combined)) return "browser";
+  if (/(worker|job|cron|consumer)/.test(combined)) return "worker";
+  if (/(minio|s3|storage|blob)/.test(combined)) return "storage";
+  return "service";
+}
+function parseSimpleYaml(content) {
+  const result = {};
+  const lines = content.split(/\r?\n/);
+  const stack = [
+    { indent: -1, obj: result }
+  ];
+  for (let i = 0; i < lines.length; i++) {
+    const rawLine = lines[i];
+    if (!rawLine.trim() || rawLine.trim().startsWith("#")) continue;
+    const indent = rawLine.length - rawLine.trimStart().length;
+    const trimmed = rawLine.trim();
+    while (stack.length > 1 && stack[stack.length - 1].indent >= indent) {
+      stack.pop();
+    }
+    if (trimmed.startsWith("- ")) {
+      const val = trimmed.slice(2).trim().replace(/^['"]|['"]$/g, "");
+      const parent2 = stack[stack.length - 1].obj;
+      if (Array.isArray(parent2)) {
+        parent2.push(val);
+      }
+      continue;
+    }
+    const colonIdx = trimmed.indexOf(":");
+    if (colonIdx === -1) continue;
+    const key = trimmed.slice(0, colonIdx).trim().replace(/^['"]|['"]$/g, "");
+    const valRaw = trimmed.slice(colonIdx + 1).trim();
+    const parent = stack[stack.length - 1].obj;
+    if (valRaw === "" || valRaw === "|" || valRaw === ">") {
+      let isArray = false;
+      for (let j = i + 1; j < lines.length; j++) {
+        const nextLine = lines[j];
+        if (!nextLine.trim() || nextLine.trim().startsWith("#")) continue;
+        const nextIndent = nextLine.length - nextLine.trimStart().length;
+        if (nextIndent > indent && nextLine.trim().startsWith("- ")) {
+          isArray = true;
+        }
+        break;
+      }
+      if (isArray) {
+        const child = [];
+        parent[key] = child;
+        stack.push({ indent, obj: child });
+      } else {
+        const child = {};
+        parent[key] = child;
+        stack.push({ indent, obj: child });
+      }
+    } else if (valRaw.startsWith("[") && valRaw.endsWith("]")) {
+      const inner = valRaw.slice(1, -1).trim();
+      const items = inner ? inner.split(",").map((s) => s.trim().replace(/^['"]|['"]$/g, "")).filter(Boolean) : [];
+      parent[key] = items;
+    } else {
+      parent[key] = valRaw.replace(/^['"]|['"]$/g, "");
+    }
+  }
+  return result;
+}
+function transpileDockerComposeToMarkdy(yamlContent, title = "Container Topology") {
+  const parsed = parseSimpleYaml(yamlContent);
+  const rawServices = parsed["services"] ?? {};
+  const serviceList = [];
+  for (const [svcName, svcConfig] of Object.entries(rawServices)) {
+    if (typeof svcConfig !== "object" || svcConfig === null) continue;
+    const cfg = svcConfig;
+    let ports = [];
+    if (Array.isArray(cfg["ports"])) {
+      ports = cfg["ports"].map((p) => String(p).replace(/^['"]|['"]$/g, ""));
+    } else if (typeof cfg["ports"] === "string") {
+      const pStr = cfg["ports"].trim();
+      if (pStr.startsWith("[") && pStr.endsWith("]")) {
+        ports = pStr.slice(1, -1).split(",").map((s) => s.trim().replace(/^['"]|['"]$/g, "")).filter(Boolean);
+      } else {
+        ports = [pStr.replace(/^['"]|['"]$/g, "")];
+      }
+    }
+    let dependsOn = [];
+    if (Array.isArray(cfg["depends_on"])) {
+      dependsOn = cfg["depends_on"].map((d) => String(d).replace(/^['"]|['"]$/g, ""));
+    } else if (typeof cfg["depends_on"] === "object" && cfg["depends_on"] !== null) {
+      dependsOn = Object.keys(cfg["depends_on"]);
+    } else if (typeof cfg["depends_on"] === "string") {
+      const dStr = cfg["depends_on"].trim();
+      if (dStr.startsWith("[") && dStr.endsWith("]")) {
+        dependsOn = dStr.slice(1, -1).split(",").map((s) => s.trim().replace(/^['"]|['"]$/g, "")).filter(Boolean);
+      } else {
+        dependsOn = [dStr.replace(/^['"]|['"]$/g, "")];
+      }
+    }
+    serviceList.push({
+      name: svcName,
+      image: typeof cfg["image"] === "string" ? cfg["image"] : void 0,
+      ports,
+      dependsOn
+    });
+  }
+  const out = [];
+  out.push(title ? `scene "${title}" theme=paper` : `scene theme=paper`);
+  out.push("layout LR");
+  out.push("");
+  for (const svc of serviceList) {
+    const id = sanitizeIdentifier(svc.name);
+    const kind = inferSemanticKind(svc.name, svc.image);
+    const ports = svc.ports ?? [];
+    const label = ports.length > 0 ? `${svc.name} :${ports[0]}` : svc.name;
+    out.push(`${kind} ${id} "${label}"`);
+  }
+  out.push("");
+  out.push('beat main "Initialize and connect services":');
+  out.push("  show $nodes stagger=60ms");
+  for (const svc of serviceList) {
+    const sourceId = sanitizeIdentifier(svc.name);
+    for (const dep of svc.dependsOn ?? []) {
+      const targetId = sanitizeIdentifier(dep);
+      out.push(`  ${sourceId} -> ${targetId} "depends on"`);
+    }
+  }
+  return out.join("\n");
+}
+
+// src/infra/k8s-transpiler.ts
+function sanitize(id) {
+  return id.replace(/[^a-zA-Z0-9_]/g, "_");
+}
+function transpileKubernetesManifestsToMarkdy(manifestContent, title = "Kubernetes Cluster Topology") {
+  const docs = manifestContent.split(/^---/m).map((d) => d.trim()).filter((d) => d.length > 0);
+  const manifests = [];
+  for (const doc of docs) {
+    const raw = parseSimpleYaml(doc);
+    const kind = typeof raw["kind"] === "string" ? raw["kind"] : "";
+    const meta = raw["metadata"] || {};
+    const name = typeof meta["name"] === "string" ? meta["name"] : "";
+    const namespace = typeof meta["namespace"] === "string" ? meta["namespace"] : "default";
+    if (!kind || !name) continue;
+    manifests.push({
+      kind,
+      name,
+      namespace
+    });
+  }
+  const out = [];
+  out.push(title ? `scene "${title}" theme=paper` : `scene theme=paper`);
+  out.push("layout TB");
+  out.push("");
+  const namespaces = new Set(manifests.map((m) => m.namespace || "default"));
+  for (const ns of namespaces) {
+    const nsMembers = manifests.filter((m) => (m.namespace || "default") === ns).map((m) => sanitize(`${m.kind}_${m.name}`));
+    if (nsMembers.length > 0) {
+      out.push(`group ns_${sanitize(ns)} "Namespace: ${ns}": ${nsMembers.join(" ")}`);
+    }
+  }
+  out.push("");
+  for (const m of manifests) {
+    const id = sanitize(`${m.kind}_${m.name}`);
+    let kind = "service";
+    if (m.kind === "Ingress") kind = "gateway";
+    else if (m.kind === "Service") kind = "load_balancer";
+    else if (m.kind === "StatefulSet") kind = "database";
+    else if (m.kind === "CronJob" || m.kind === "Job") kind = "worker";
+    else if (m.kind === "PersistentVolumeClaim") kind = "storage";
+    out.push(`${kind} ${id} "${m.name} (${m.kind})"`);
+  }
+  out.push("");
+  out.push('beat main "Cluster Ingress & Service Mesh":');
+  out.push("  show $nodes stagger=50ms");
+  const ingresses = manifests.filter((m) => m.kind === "Ingress");
+  const services = manifests.filter((m) => m.kind === "Service");
+  const workloads = manifests.filter((m) => ["Deployment", "StatefulSet", "DaemonSet"].includes(m.kind));
+  for (const ing of ingresses) {
+    for (const svc of services) {
+      out.push(`  ${sanitize(`${ing.kind}_${ing.name}`)} -> ${sanitize(`${svc.kind}_${svc.name}`)} "route"`);
+    }
+  }
+  for (const svc of services) {
+    for (const wl of workloads) {
+      out.push(`  ${sanitize(`${svc.kind}_${svc.name}`)} -> ${sanitize(`${wl.kind}_${wl.name}`)} "balance"`);
+    }
+  }
+  return out.join("\n");
+}
+
+// src/infra/terraform-transpiler.ts
+function sanitizeId(raw) {
+  return raw.replace(/[^a-zA-Z0-9_]/g, "_");
+}
+function inferKindFromTfType(type) {
+  if (type.includes("database") || type.includes("db_instance") || type.includes("rds") || type.includes("dynamodb")) {
+    return "database";
+  }
+  if (type.includes("elasticache") || type.includes("redis") || type.includes("memcached")) {
+    return "cache";
+  }
+  if (type.includes("sqs") || type.includes("pubsub") || type.includes("servicebus") || type.includes("queue")) {
+    return "queue";
+  }
+  if (type.includes("s3_bucket") || type.includes("storage_bucket") || type.includes("blob")) {
+    return "storage";
+  }
+  if (type.includes("lb") || type.includes("alb") || type.includes("apigateway") || type.includes("gateway")) {
+    return "gateway";
+  }
+  if (type.includes("cloudfront") || type.includes("cdn")) {
+    return "cdn";
+  }
+  if (type.includes("lambda") || type.includes("cloudfunctions") || type.includes("function_app")) {
+    return "worker";
+  }
+  if (type.includes("eks") || type.includes("gke") || type.includes("aks") || type.includes("cluster")) {
+    return "cluster";
+  }
+  return "service";
+}
+function transpileTerraformStateToMarkdy(tfstateContent, sceneTitle = "Cloud Infrastructure Architecture") {
+  let parsed;
+  try {
+    parsed = JSON.parse(tfstateContent);
+  } catch {
+    throw new Error("Invalid Terraform state JSON");
+  }
+  if (!parsed.resources || !Array.isArray(parsed.resources)) {
+    return sceneTitle ? `scene "${sceneTitle}" theme=paper
+layout LR
+` : `scene theme=paper
+layout LR
+`;
+  }
+  const nodes = [];
+  const edges = [];
+  const vpcGroups = /* @__PURE__ */ new Map();
+  const arnToResId = /* @__PURE__ */ new Map();
+  for (const res of parsed.resources) {
+    if (res.type.startsWith("aws_iam_") || res.type.includes("route_table") || res.type.includes("security_group")) {
+      continue;
+    }
+    const firstInst = res.instances?.[0]?.attributes;
+    const resId = sanitizeId(`${res.type}_${res.name}`);
+    const kind = inferKindFromTfType(res.type);
+    const label = firstInst?.tags?.["Name"] || firstInst?.name || `${res.type.split("_").slice(-1)[0]}: ${res.name}`;
+    const vpcId = typeof firstInst?.vpc_id === "string" ? sanitizeId(firstInst.vpc_id) : void 0;
+    nodes.push({ id: resId, kind, label, vpcId });
+    if (typeof firstInst?.arn === "string") {
+      arnToResId.set(firstInst.arn, resId);
+    }
+    if (vpcId) {
+      if (!vpcGroups.has(vpcId)) vpcGroups.set(vpcId, []);
+      vpcGroups.get(vpcId).push(resId);
+    }
+    if (typeof firstInst?.load_balancer_arn === "string") {
+      edges.push({ from: firstInst.load_balancer_arn, to: resId, label: "routes" });
+    }
+  }
+  for (let i = 0; i < edges.length; i++) {
+    const edge = edges[i];
+    if (edge.from.startsWith("arn:") && arnToResId.has(edge.from)) {
+      edge.from = arnToResId.get(edge.from);
+    } else if (edge.from.startsWith("arn:")) {
+      edge.from = sanitizeId(edge.from);
+    }
+  }
+  const out = [];
+  out.push(sceneTitle ? `scene "${sceneTitle}" theme=paper` : `scene theme=paper`);
+  out.push("layout LR");
+  out.push("");
+  for (const [vpc, members] of vpcGroups) {
+    if (members.length > 1) {
+      out.push(`group ${vpc} "VPC Network": ${members.join(" ")}`);
+    }
+  }
+  for (const n of nodes) {
+    out.push(`${n.kind} ${n.id} "${n.label}"`);
+  }
+  out.push("");
+  out.push('beat main "Provisioned Infrastructure Flow":');
+  out.push("  show $nodes stagger=40ms");
+  if (edges.length > 0) {
+    for (const e of edges) {
+      out.push(`  ${e.from} -> ${e.to} "${e.label || "connect"}"`);
+    }
+  } else if (nodes.length >= 2) {
+    out.push(`  ${nodes[0].id} -> ${nodes[1].id} "traffic"`);
+  }
+  return out.join("\n");
+}
+
+// src/infra/drawio-transpiler.ts
+import { classifyTechnology } from "@markdy/core";
+function sanitizeId2(raw, fallback) {
+  const cleaned = raw.replace(/[^a-zA-Z0-9_]/g, "");
+  if (/^[0-9]/.test(cleaned) || cleaned.length === 0) {
+    return `${fallback}_${cleaned}`;
+  }
+  return cleaned;
+}
+function stripHtml(raw) {
+  return raw.replace(/<br\s*\/?>/gi, " ").replace(/<\/?[^>]+(>|$)/g, "").replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').trim();
+}
+function inferKindFromStyleAndLabel(style, label) {
+  const styleLower = style.toLowerCase();
+  const labelLower = label.toLowerCase();
+  if (styleLower.includes("shape=cylinder") || styleLower.includes("datastore") || styleLower.includes("database")) {
+    return "database";
+  }
+  if (styleLower.includes("shape=cloud") || styleLower.includes("network")) {
+    return "cloud";
+  }
+  if (styleLower.includes("shape=actor") || styleLower.includes("person") || styleLower.includes("user")) {
+    return "user";
+  }
+  if (styleLower.includes("shape=hexagon") || styleLower.includes("gateway")) {
+    return "gateway";
+  }
+  if (styleLower.includes("queue") || styleLower.includes("message") || styleLower.includes("kafka") || styleLower.includes("sqs")) {
+    return "queue";
+  }
+  if (styleLower.includes("cache") || styleLower.includes("redis")) {
+    return "cache";
+  }
+  if (styleLower.includes("storage") || styleLower.includes("bucket") || styleLower.includes("s3")) {
+    return "storage";
+  }
+  const profile = classifyTechnology(labelLower);
+  if (profile.kind && profile.kind !== "service") {
+    return profile.kind;
+  }
+  return "service";
+}
+function parseDrawioXml(xml, defaultTitle = "Imported Draw.io") {
+  const cells = [];
+  const diagramTitleMatch = xml.match(/<diagram[^>]*name="([^"]+)"/i);
+  const title = diagramTitleMatch ? diagramTitleMatch[1] : defaultTitle;
+  const cellRegex = /<mxCell\s+([^>]+)(?:\/>|>([\s\S]*?)<\/mxCell>)/gi;
+  let match;
+  while ((match = cellRegex.exec(xml)) !== null) {
+    const attrStr = match[1];
+    const innerContent = match[2] || "";
+    const idMatch = attrStr.match(/id="([^"]+)"/i);
+    if (!idMatch) continue;
+    const id = idMatch[1];
+    if (id === "0" || id === "1") continue;
+    const valueAttrMatch = attrStr.match(/value="([^"]*)"/i);
+    let rawValue = valueAttrMatch ? valueAttrMatch[1] : "";
+    if (!rawValue && innerContent) {
+      rawValue = innerContent;
+    }
+    const cleanValue = stripHtml(rawValue);
+    const styleMatch = attrStr.match(/style="([^"]*)"/i);
+    const style = styleMatch ? styleMatch[1] : "";
+    const isVertex = /vertex="1"/i.test(attrStr);
+    const isEdge = /edge="1"/i.test(attrStr);
+    const sourceMatch = attrStr.match(/source="([^"]+)"/i);
+    const targetMatch = attrStr.match(/target="([^"]+)"/i);
+    const parentMatch = attrStr.match(/parent="([^"]+)"/i);
+    cells.push({
+      id,
+      value: cleanValue,
+      style,
+      isVertex,
+      isEdge,
+      source: sourceMatch ? sourceMatch[1] : void 0,
+      target: targetMatch ? targetMatch[1] : void 0,
+      parent: parentMatch ? parentMatch[1] : void 0
+    });
+  }
+  return { title, cells };
+}
+async function transpileDrawioToMarkdy(source, customTitle) {
+  let xml = source.trim();
+  if (xml.includes("<diagram") && !xml.includes("<mxGraphModel>")) {
+    const diagramMatch = xml.match(/<diagram[^>]*>([\s\S]*?)<\/diagram>/i);
+    if (diagramMatch) {
+      const payload = diagramMatch[1].trim();
+      try {
+        const binaryStr = atob(payload);
+        if (binaryStr.includes("<mxGraphModel")) {
+          xml = binaryStr;
+        } else if (typeof DecompressionStream !== "undefined") {
+          const uint8 = new Uint8Array(binaryStr.length);
+          for (let i = 0; i < binaryStr.length; i++) {
+            uint8[i] = binaryStr.charCodeAt(i);
+          }
+          try {
+            const ds = new DecompressionStream("deflate-raw");
+            const writer = ds.writable.getWriter();
+            writer.write(uint8);
+            writer.close();
+            const reader = ds.readable.getReader();
+            const chunks = [];
+            let totalLen = 0;
+            while (true) {
+              const { done, value } = await reader.read();
+              if (done) break;
+              if (value) {
+                chunks.push(value);
+                totalLen += value.length;
+              }
+            }
+            const decompressed = new Uint8Array(totalLen);
+            let offset = 0;
+            for (const c of chunks) {
+              decompressed.set(c, offset);
+              offset += c.length;
+            }
+            const decodedStr = new TextDecoder().decode(decompressed);
+            xml = decodeURIComponent(decodedStr);
+          } catch (e) {
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  const model = parseDrawioXml(xml, customTitle);
+  const vertexCells = model.cells.filter((c) => c.isVertex);
+  const edgeCells = model.cells.filter((c) => c.isEdge);
+  const cellIdToNodeId = /* @__PURE__ */ new Map();
+  const nodes = [];
+  for (const cell of vertexCells) {
+    const rawLabel = cell.value || `Component_${cell.id}`;
+    const rawIdentifier = isNaN(Number(cell.id)) && cell.id.length > 0 ? cell.id : cell.value || `node_${cell.id}`;
+    const nodeId = sanitizeId2(rawIdentifier, `node_${cell.id}`);
+    const kind = inferKindFromStyleAndLabel(cell.style, rawLabel);
+    cellIdToNodeId.set(cell.id, nodeId);
+    nodes.push({ id: nodeId, kind, label: rawLabel });
+  }
+  const lines = [];
+  const sceneName = customTitle || model.title;
+  lines.push(sceneName ? `scene "${sceneName}" theme=paper` : `scene theme=paper`);
+  lines.push(`layout LR`);
+  lines.push(``);
+  if (nodes.length > 0) {
+    for (const node of nodes) {
+      lines.push(`${node.kind} ${node.id} "${node.label}"`);
+    }
+    lines.push(``);
+  }
+  const flows = [];
+  for (const edge of edgeCells) {
+    if (edge.source && edge.target) {
+      const sourceId = cellIdToNodeId.get(edge.source);
+      const targetId = cellIdToNodeId.get(edge.target);
+      if (sourceId && targetId) {
+        flows.push({
+          from: sourceId,
+          to: targetId,
+          label: edge.value || void 0
+        });
+      }
+    }
+  }
+  lines.push(`beat main "System Flow":`);
+  lines.push(`  show $nodes stagger=60ms`);
+  if (flows.length > 0) {
+    for (const flow of flows) {
+      if (flow.label) {
+        lines.push(`  ${flow.from} -> ${flow.to} "${flow.label}"`);
+      } else {
+        lines.push(`  ${flow.from} -> ${flow.to}`);
+      }
+    }
+  }
+  return {
+    code: lines.join("\n"),
+    nodeCount: nodes.length,
+    edgeCount: flows.length
+  };
+}
+
+// src/infra/d2-transpiler.ts
+function transpileD2ToMarkdy(d2Source) {
+  const lines = d2Source.split("\n");
+  const warnings = [];
+  const nodes = /* @__PURE__ */ new Map();
+  const edges = [];
+  const containers = /* @__PURE__ */ new Map();
+  let currentContainer = null;
+  let sceneTitle = "Architecture Diagram";
+  function sanitizeId3(raw) {
+    return raw.trim().replace(/[^a-zA-Z0-9_]/g, "_");
+  }
+  function inferNodeKind(labelOrId, shape) {
+    const lower = (labelOrId + " " + (shape || "")).toLowerCase();
+    if (lower.includes("db") || lower.includes("database") || lower.includes("postgres") || lower.includes("sql") || lower.includes("cylinder")) {
+      return "database";
+    }
+    if (lower.includes("cache") || lower.includes("redis") || lower.includes("memcached")) {
+      return "cache";
+    }
+    if (lower.includes("browser") || lower.includes("client") || lower.includes("web") || lower.includes("ui") || lower.includes("mobile")) {
+      return "browser";
+    }
+    if (lower.includes("gateway") || lower.includes("proxy") || lower.includes("nginx") || lower.includes("envoy") || lower.includes("ingress")) {
+      return "gateway";
+    }
+    if (lower.includes("queue") || lower.includes("kafka") || lower.includes("rabbit") || lower.includes("sqs") || lower.includes("stream")) {
+      return "queue";
+    }
+    if (lower.includes("storage") || lower.includes("s3") || lower.includes("bucket")) {
+      return "storage";
+    }
+    return "service";
+  }
+  for (let idx = 0; idx < lines.length; idx++) {
+    const rawLine = lines[idx].trim();
+    if (!rawLine || rawLine.startsWith("#")) continue;
+    const titleMatch = rawLine.match(/^title\s*:\s*["']?([^"']+)["']?$/i);
+    if (titleMatch) {
+      sceneTitle = titleMatch[1].trim();
+      continue;
+    }
+    const containerOpenMatch = rawLine.match(/^([a-zA-Z0-9_-]+)\s*:\s*\{$/);
+    if (containerOpenMatch) {
+      currentContainer = sanitizeId3(containerOpenMatch[1]);
+      containers.set(currentContainer, []);
+      continue;
+    }
+    if (rawLine === "}") {
+      currentContainer = null;
+      continue;
+    }
+    const connMatch = rawLine.match(/^([a-zA-Z0-9_.-]+)\s*(->|<-|<->|--|\.\.>|\.\.)\s*([a-zA-Z0-9_.-]+)(?:\s*:\s*(.*))?$/);
+    if (connMatch) {
+      const fromId = sanitizeId3(connMatch[1]);
+      const rawOp = connMatch[2];
+      const toId = sanitizeId3(connMatch[3]);
+      let label = connMatch[4]?.trim();
+      if (label?.startsWith('"') && label.endsWith('"')) {
+        label = label.slice(1, -1);
+      }
+      if (!nodes.has(fromId)) {
+        nodes.set(fromId, { id: fromId, label: fromId, kind: inferNodeKind(fromId) });
+      }
+      if (!nodes.has(toId)) {
+        nodes.set(toId, { id: toId, label: toId, kind: inferNodeKind(toId) });
+      }
+      if (rawOp === "<->") {
+        edges.push({ from: fromId, to: toId, op: "->", label });
+        edges.push({ from: toId, to: fromId, op: "<-", label });
+        continue;
+      }
+      let op = "->";
+      if (rawOp === "<-") op = "<-";
+      else if (rawOp === "--" || rawOp === ".." || rawOp === "..>") op = "..>";
+      edges.push({ from: fromId, to: toId, op, label });
+      continue;
+    }
+    const propMatch = rawLine.match(/^([a-zA-Z0-9_.-]+)\.(shape|icon|style\.fill)\s*:\s*(.*)$/i);
+    if (propMatch) {
+      const id = sanitizeId3(propMatch[1]);
+      const propKey = propMatch[2].toLowerCase();
+      let propVal = propMatch[3].trim();
+      if (propVal.startsWith('"') && propVal.endsWith('"')) {
+        propVal = propVal.slice(1, -1);
+      }
+      const existing = nodes.get(id) || { id, label: id, kind: inferNodeKind(id) };
+      if (propKey === "shape") {
+        existing.kind = inferNodeKind(existing.label, propVal);
+      } else if (propKey === "icon") {
+        existing.icon = propVal.toLowerCase().replace(/[^a-z0-9]/g, "");
+      }
+      nodes.set(id, existing);
+      continue;
+    }
+    const nodeMatch = rawLine.match(/^([a-zA-Z0-9_.-]+)\s*:\s*(.*)$/);
+    if (nodeMatch) {
+      const rawKey = nodeMatch[1];
+      let label = nodeMatch[2].trim();
+      if (label.startsWith('"') && label.endsWith('"')) {
+        label = label.slice(1, -1);
+      }
+      if (rawKey.includes(".")) {
+        const parts = rawKey.split(".");
+        const parent = sanitizeId3(parts[0]);
+        const childId = sanitizeId3(rawKey);
+        if (!containers.has(parent)) {
+          containers.set(parent, []);
+        }
+        containers.get(parent).push(childId);
+        const kind2 = inferNodeKind(label || childId);
+        nodes.set(childId, { id: childId, label: label || childId, kind: kind2 });
+        continue;
+      }
+      const id = sanitizeId3(rawKey);
+      const kind = inferNodeKind(label || id);
+      nodes.set(id, { id, label: label || id, kind });
+      if (currentContainer) {
+        containers.get(currentContainer)?.push(id);
+      }
+      continue;
+    }
+    if (/^[a-zA-Z0-9_.-]+$/.test(rawLine)) {
+      const id = sanitizeId3(rawLine);
+      if (!nodes.has(id)) {
+        nodes.set(id, { id, label: id, kind: inferNodeKind(id) });
+      }
+      if (currentContainer) {
+        containers.get(currentContainer)?.push(id);
+      }
+    }
+  }
+  const outLines = [
+    `scene "${sceneTitle}" theme=midnight`,
+    `layout LR`,
+    ""
+  ];
+  for (const [, node] of nodes) {
+    const iconAttr = node.icon ? ` icon=${node.icon}` : "";
+    outLines.push(`${node.kind} ${node.id} "${node.label}"${iconAttr}`);
+  }
+  if (containers.size > 0) {
+    outLines.push("");
+    for (const [containerId, members] of containers) {
+      if (members.length > 0) {
+        outLines.push(`group ${containerId} "${containerId}": ${members.join(" ")}`);
+      }
+    }
+  }
+  outLines.push("");
+  outLines.push(`beat main_flow "1. Architecture Dataflow":`);
+  outLines.push(`  show $nodes stagger=40ms`);
+  for (const edge of edges) {
+    const lbl = edge.label ? ` "${edge.label}"` : "";
+    outLines.push(`  ${edge.from} ${edge.op} ${edge.to}${lbl}`);
+  }
+  return {
+    markdyScript: outLines.join("\n") + "\n",
+    nodeCount: nodes.size,
+    edgeCount: edges.length,
+    containerCount: containers.size,
+    warnings
+  };
+}
+
+// src/infra/plantuml-transpiler.ts
+function transpilePlantUmlToMarkdy(pumlSource) {
+  const lines = pumlSource.split("\n");
+  const warnings = [];
+  const nodes = /* @__PURE__ */ new Map();
+  const edges = [];
+  const groups = /* @__PURE__ */ new Map();
+  let currentGroup = null;
+  let sceneTitle = "PlantUML System Architecture";
+  function sanitizeId3(raw) {
+    return raw.trim().replace(/[^a-zA-Z0-9_]/g, "_");
+  }
+  function mapPlantUmlKind(rawType, label) {
+    const type = rawType.toLowerCase();
+    const lbl = label.toLowerCase();
+    if (type === "database" || lbl.includes("database") || lbl.includes("postgres") || lbl.includes("mysql") || lbl.includes("sql")) {
+      return "database";
+    }
+    if (type === "queue" || lbl.includes("queue") || lbl.includes("kafka") || lbl.includes("rabbitmq")) {
+      return "queue";
+    }
+    if (type === "boundary" || lbl.includes("gateway") || lbl.includes("proxy") || lbl.includes("ingress")) {
+      return "gateway";
+    }
+    if (type === "actor" || lbl.includes("user") || lbl.includes("client") || lbl.includes("browser")) {
+      return "browser";
+    }
+    if (lbl.includes("cache") || lbl.includes("redis")) {
+      return "cache";
+    }
+    if (lbl.includes("s3") || lbl.includes("storage") || lbl.includes("blob")) {
+      return "storage";
+    }
+    return "service";
+  }
+  for (let idx = 0; idx < lines.length; idx++) {
+    let line = lines[idx].trim();
+    if (!line || line.startsWith("'") || line.startsWith("@startuml") || line.startsWith("@enduml")) {
+      continue;
+    }
+    const titleMatch = line.match(/^title\s+["']?([^"']+)["']?$/i);
+    if (titleMatch) {
+      sceneTitle = titleMatch[1].trim();
+      continue;
+    }
+    const groupOpenMatch = line.match(/^(?:package|rectangle|node|cloud|frame)\s+(?:"([^"]+)"|(\w+))(?:\s+as\s+(\w+))?\s*\{/i);
+    if (groupOpenMatch) {
+      const label = groupOpenMatch[1] || groupOpenMatch[2];
+      const id = sanitizeId3(groupOpenMatch[3] || label);
+      currentGroup = id;
+      groups.set(id, { id, label, members: [] });
+      continue;
+    }
+    if (line === "}") {
+      currentGroup = null;
+      continue;
+    }
+    const c4NodeMatch = line.match(/^(Person|Person_Ext|System|System_Ext|SystemDb|Container|ContainerDb|ContainerQueue|Component|ComponentDb)\s*\(\s*([a-zA-Z0-9_]+)\s*,\s*["']([^"']+)["'](?:\s*,\s*["']([^"']*)["'])?(?:\s*,\s*["']([^"']*)["'])?\s*\)/i);
+    if (c4NodeMatch) {
+      const macro = c4NodeMatch[1].toLowerCase();
+      const id = sanitizeId3(c4NodeMatch[2]);
+      const label = c4NodeMatch[3];
+      const techOrDesc = c4NodeMatch[4] || "";
+      let kind = "service";
+      let icon = "nodejs";
+      if (macro.includes("person")) {
+        kind = "browser";
+        icon = "chrome";
+      } else if (macro.includes("db")) {
+        kind = "database";
+        icon = "postgresql";
+      } else if (macro.includes("queue")) {
+        kind = "queue";
+        icon = "kafka";
+      } else if (macro.includes("gateway") || techOrDesc.toLowerCase().includes("gateway") || techOrDesc.toLowerCase().includes("proxy")) {
+        kind = "gateway";
+        icon = "nginx";
+      }
+      nodes.set(id, { id, label, kind, icon });
+      if (currentGroup && groups.has(currentGroup)) {
+        groups.get(currentGroup).members.push(id);
+      }
+      continue;
+    }
+    const c4RelMatch = line.match(/^Rel(?:_[RLDUB]|_Neighbor|_Back)?\s*\(\s*([a-zA-Z0-9_]+)\s*,\s*([a-zA-Z0-9_]+)\s*,\s*["']([^"']+)["'](?:\s*,\s*["']([^"']*)["'])?\s*\)/i);
+    if (c4RelMatch) {
+      const fromId = sanitizeId3(c4RelMatch[1]);
+      const toId = sanitizeId3(c4RelMatch[2]);
+      const desc = c4RelMatch[3];
+      const tech = c4RelMatch[4];
+      const fullLabel = tech ? `${desc} (${tech})` : desc;
+      if (!nodes.has(fromId)) {
+        nodes.set(fromId, { id: fromId, label: fromId, kind: mapPlantUmlKind("service", fromId) });
+      }
+      if (!nodes.has(toId)) {
+        nodes.set(toId, { id: toId, label: toId, kind: mapPlantUmlKind("service", toId) });
+      }
+      edges.push({ from: fromId, to: toId, op: "->", label: fullLabel });
+      continue;
+    }
+    const declMatch = line.match(/^(component|interface|database|queue|actor|boundary|control|entity|participant|node)\s+(?:"([^"]+)"\s+as\s+(\w+)|(\w+)(?:\s+as\s+(\w+))?|(\w+))/i);
+    if (declMatch) {
+      const rawType = declMatch[1];
+      const label = declMatch[2] || declMatch[4] || declMatch[6];
+      const id = sanitizeId3(declMatch[3] || declMatch[5] || declMatch[6] || label);
+      nodes.set(id, {
+        id,
+        label,
+        kind: mapPlantUmlKind(rawType, label)
+      });
+      if (currentGroup && groups.has(currentGroup)) {
+        groups.get(currentGroup).members.push(id);
+      }
+      continue;
+    }
+    const connMatch = line.match(/^([a-zA-Z0-9_.-]+)\s*(<[-.]+>|[-.]+>|<[-.]+|[-.]+)\s*([a-zA-Z0-9_.-]+)(?:\s*:\s*(.*))?$/);
+    if (connMatch) {
+      const fromId = sanitizeId3(connMatch[1]);
+      const arrow = connMatch[2];
+      const toId = sanitizeId3(connMatch[3]);
+      let label = connMatch[4]?.trim();
+      if (label?.startsWith('"') && label.endsWith('"')) {
+        label = label.slice(1, -1);
+      }
+      if (!nodes.has(fromId)) {
+        nodes.set(fromId, { id: fromId, label: fromId, kind: mapPlantUmlKind("service", fromId) });
+      }
+      if (!nodes.has(toId)) {
+        nodes.set(toId, { id: toId, label: toId, kind: mapPlantUmlKind("service", toId) });
+      }
+      if (arrow.startsWith("<") && arrow.endsWith(">")) {
+        edges.push({ from: fromId, to: toId, op: "->", label });
+        edges.push({ from: toId, to: fromId, op: "<-", label });
+        continue;
+      }
+      let op = "->";
+      if (arrow.startsWith("<")) op = "<-";
+      else if (arrow.includes(".") || arrow.startsWith("--") || arrow === "-") op = "..>";
+      edges.push({ from: fromId, to: toId, op, label });
+      continue;
+    }
+    warnings.push(`Ignored unsupported PlantUML syntax at line ${idx + 1}: ${line.slice(0, 40)}`);
+  }
+  const scriptLines = [];
+  scriptLines.push(`scene "${sceneTitle}" theme=auto`);
+  scriptLines.push(`layout LR`);
+  scriptLines.push(``);
+  for (const node of nodes.values()) {
+    const iconProp = node.icon ? ` icon=${node.icon}` : "";
+    scriptLines.push(`${node.kind} ${node.id} "${node.label}"${iconProp}`);
+  }
+  if (groups.size > 0) {
+    scriptLines.push(``);
+    for (const group of groups.values()) {
+      if (group.members.length > 0) {
+        scriptLines.push(`group ${group.id} "${group.label}": ${group.members.join(" ")}`);
+      }
+    }
+  }
+  scriptLines.push(``);
+  scriptLines.push(`beat system_flow "Imported PlantUML Flow":`);
+  scriptLines.push(`  show $nodes stagger=50ms`);
+  for (const edge of edges) {
+    const label = edge.label ? ` "${edge.label}"` : "";
+    scriptLines.push(`  ${edge.from} ${edge.op} ${edge.to}${label}`);
+  }
+  return {
+    markdyScript: scriptLines.join("\n") + "\n",
+    nodeCount: nodes.size,
+    edgeCount: edges.length,
+    groupCount: groups.size,
+    warnings
+  };
+}
+export {
+  parseDrawioXml,
+  parseSimpleYaml,
+  transpileD2ToMarkdy,
+  transpileDockerComposeToMarkdy,
+  transpileDrawioToMarkdy,
+  transpileKubernetesManifestsToMarkdy,
+  transpileMermaidToMarkdy,
+  transpilePlantUmlToMarkdy,
+  transpileTerraformStateToMarkdy
+};

package/dist/mermaid/mermaid-transpiler.d.ts

@@ -0,0 +1,14 @@
+/**
+ * packages/compat/src/mermaid/mermaid-transpiler.ts
+ * Transpiles Mermaid Flowcharts and Sequence Diagrams into animated MarkdyScript.
+ * Zero external dependencies.
+ */
+interface MermaidTranspileResult {
+    code: string;
+    diagramType: "architecture" | "sequence" | "flowchart";
+    nodeCount: number;
+    edgeCount: number;
+}
+declare function transpileMermaidToMarkdy(mermaidSource: string, sceneTitle?: string): MermaidTranspileResult;
+
+export { type MermaidTranspileResult, transpileMermaidToMarkdy };

package/dist/mermaid/mermaid-transpiler.js

@@ -0,0 +1,6 @@
+import {
+  transpileMermaidToMarkdy
+} from "../chunk-UQF5UJH6.js";
+export {
+  transpileMermaidToMarkdy
+};

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "@markdy/compat",
+  "version": "1.3.0",
+  "description": "Universal ingestion transpilers (D2, PlantUML, Mermaid, Docker Compose, Kubernetes, Terraform, Draw.io) and backwards-compatibility gate for Markdy.",
+  "license": "MIT",
+  "type": "module",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./mermaid": {
+      "types": "./dist/mermaid/mermaid-transpiler.d.ts",
+      "import": "./dist/mermaid/mermaid-transpiler.js"
+    },
+    "./infra": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "keywords": [
+    "markdy",
+    "diagram-native",
+    "diagram-as-code",
+    "transpiler",
+    "ingestion",
+    "d2",
+    "plantuml",
+    "mermaid",
+    "architecture-diagram"
+  ],
+  "author": "Hoang Yell <hoangyell@gmail.com> (https://hoangyell.com)",
+  "homepage": "https://markdy.com",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/HoangYell/markdy-com.git",
+    "directory": "packages/compat"
+  },
+  "bugs": {
+    "url": "https://github.com/HoangYell/markdy-com/issues"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "dependencies": {
+    "@markdy/core": "1.3.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.9.5",
+    "tsup": "^8.5.1",
+    "tsx": "^4.23.1",
+    "typescript": "^5.9.3",
+    "vitest": "^4.1.7"
+  },
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run",
+    "gate": "tsx src/gate.ts",
+    "gate:update": "tsx src/gate.ts --update",
+    "typecheck": "tsc --noEmit",
+    "lint": "tsc --noEmit"
+  }
+}