bc-atlas 0.5.0

package/src/cli.js

@@ -0,0 +1,357 @@
+#!/usr/bin/env node
+
+import { watch as fsWatch } from "node:fs";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { spawn } from "node:child_process";
+import { parseArgs } from "node:util";
+import { analyze } from "./analyzer.js";
+import { loadConfig } from "./config.js";
+import { renderD2 } from "./d2.js";
+import { addInsights } from "./insights.js";
+import { resolveModel } from "./resolver.js";
+import { renderSvg } from "./svg.js";
+import { createView, filterModel } from "./views.js";
+import { docsMain } from "./docs/cli.js";
+
+const HELP = `BC Atlas - generate architecture diagrams from AL source
+
+Usage:
+  bca [graph] [options] <file-or-directory>
+  bca inspect [options] <file-or-directory>
+  bca watch [options] <directory>
+  bca docs generate [options] <ui-test.al>
+
+Views:
+  project (default)   AL objects grouped by namespace
+  module              Aggregated namespace dependencies
+  object              One object plus incoming/outgoing neighbors
+  data                Tables and table-oriented dependencies
+  call                Procedure and trigger call graph
+  boundary            Dependencies crossing a selected scope
+  contracts           Interfaces and direct/enum implementations
+  events              Event publishers and subscribers
+  ui                  Pages, source tables, parts, actions, and navigation
+  workflow            Trace calls, events, and data mutations from entry points
+
+Options:
+  -o, --output <path>       Output path (default: bc-atlas.d2)
+  -f, --format <format>     d2, json, svg, png, or pdf
+      --view <view>         project, module, object, data, call, boundary,
+                            contracts, events, ui, or workflow
+      --entry <selector>    Workflow entry procedure, trigger, action, or event
+                            (repeatable)
+      --workflow-depth <n>  Workflow traversal depth (default: 8)
+      --workflow-max-nodes <n>
+                            Workflow node cap (default: 100)
+      --workflow-edge-types <types>
+                            calls,events,writes,reads (default: calls,events,writes)
+      --object <selector>   Object selector, e.g. codeunit:50100
+      --scope <selector>    Boundary scope: namespace:, folder:, app:, or
+                            object: (repeatable)
+      --focus <text>        Focus contracts, events, or UI on a matching name
+      --namespace <glob>    Namespace filter (repeatable)
+      --type <types>        Object type filter, comma-separated/repeatable
+      --include <glob>      Include file/object glob (repeatable)
+      --exclude <glob>      Exclude file/object glob (repeatable)
+      --group-by <mode>     namespace, folder, type, or role
+      --module-depth <n>    Namespace segments, or auto (default: auto)
+      --folder-depth <n>    Folder segments in module view (default: 1)
+      --include-unresolved-calls
+                            Include unresolved calls and isolated procedures
+      --max-edges <n>       Diagram edge density cap (default: 500)
+      --direction <value>   right, down, left, or up
+      --title <text>        Diagram title
+      --source-url <tmpl>   Node link template with {file} and {line}
+      --details             Show member counts in nodes
+      --no-external         Hide unresolved/external dependencies
+      --config <path>       Configuration file (default: .bca.json)
+      --strict              Fail on parse or resolution diagnostics
+      --debounce <ms>       Watch rebuild debounce (default: 250)
+  -h, --help                Show help
+  -V, --version             Show version
+
+SVG is rendered by the bundled D2 WebAssembly package.
+PNG and PDF rendering require the d2 executable on PATH.
+`;
+
+const OPTIONS = {
+  output: { type: "string", short: "o" },
+  format: { type: "string", short: "f" },
+  view: { type: "string" },
+  entry: { type: "string", multiple: true },
+  object: { type: "string" },
+  scope: { type: "string", multiple: true },
+  focus: { type: "string" },
+  namespace: { type: "string", multiple: true },
+  type: { type: "string", multiple: true },
+  include: { type: "string", multiple: true },
+  exclude: { type: "string", multiple: true },
+  "group-by": { type: "string" },
+  "module-depth": { type: "string" },
+  "folder-depth": { type: "string" },
+  "include-unresolved-calls": { type: "boolean" },
+  "workflow-depth": { type: "string" },
+  "workflow-max-nodes": { type: "string" },
+  "workflow-edge-types": { type: "string" },
+  "max-edges": { type: "string" },
+  direction: { type: "string" },
+  title: { type: "string" },
+  "source-url": { type: "string" },
+  details: { type: "boolean" },
+  "no-external": { type: "boolean" },
+  config: { type: "string" },
+  strict: { type: "boolean" },
+  debounce: { type: "string" },
+  help: { type: "boolean", short: "h" },
+  version: { type: "boolean", short: "V" }
+};
+
+function fail(message, code = 1) {
+  console.error(`bca: ${message}`);
+  process.exitCode = code;
+}
+
+function positiveInteger(value, name, fallback) {
+  const number = value === undefined ? fallback : Number(value);
+  if (!Number.isInteger(number) || number < 1) {
+    throw new Error(`${name} must be a positive integer`);
+  }
+  return number;
+}
+
+function mergeOptions(config, values) {
+  return {
+    ...config,
+    ...Object.fromEntries(Object.entries(values).filter(([, value]) => value !== undefined)),
+    namespaces: values.namespace ?? config.namespaces ?? [],
+    types: values.type ?? config.types ?? [],
+    include: values.include ?? config.include ?? [],
+    exclude: values.exclude ?? config.exclude ?? [],
+    scope: values.scope ?? config.scope ?? [],
+    entry: values.entry ?? config.entry ?? config.entries
+  };
+}
+
+function runD2(source, output, options) {
+  return new Promise((resolve, reject) => {
+    const args = [];
+    if (options.layout) args.push("--layout", options.layout);
+    if (options.theme !== undefined) args.push("--theme", String(options.theme));
+    args.push(source, output);
+    const child = spawn("d2", args, { stdio: "inherit", shell: false });
+    child.on("error", (error) => {
+      reject(
+        error.code === "ENOENT"
+          ? new Error("D2 is not installed or is not on PATH; use --format d2 or install D2")
+          : error
+      );
+    });
+    child.on("exit", (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(`D2 renderer exited with code ${code}`));
+    });
+  });
+}
+
+function outputPaths(options, command) {
+  const requested = options.output ? path.resolve(options.output) : undefined;
+  const inferred = requested ? path.extname(requested).slice(1).toLowerCase() : "";
+  const format = (
+    options.format ?? (inferred || (command === "inspect" ? "json" : "d2"))
+  ).toLowerCase();
+  if (!["d2", "json", "svg", "png", "pdf"].includes(format)) {
+    throw new Error(`unsupported format: ${format}`);
+  }
+  let finalOutput = requested ?? (
+    command === "inspect" && !options.output
+      ? undefined
+      : path.resolve(`bc-atlas.${format}`)
+  );
+  if (finalOutput && options.format && inferred !== format) {
+    finalOutput = inferred
+      ? finalOutput.slice(0, -path.extname(finalOutput).length) + `.${format}`
+      : `${finalOutput}.${format}`;
+  }
+  const d2Output = format === "d2"
+    ? finalOutput
+    : finalOutput?.replace(/\.[^.]+$/u, "") + ".d2";
+  return { format, finalOutput, d2Output };
+}
+
+async function build(input, command, cliValues, quiet = false) {
+  const config = await loadConfig(input, cliValues.config);
+  const options = mergeOptions(config.values, cliValues);
+  const direction = options.direction ?? "right";
+  const view = options.view ?? "project";
+  const groupBy = options["group-by"] ?? options.groupBy ?? (
+    view === "project" ? "role" : "namespace"
+  );
+  if (!["right", "down", "left", "up"].includes(direction)) {
+    throw new Error(`unsupported direction: ${direction}`);
+  }
+  if (!["namespace", "folder", "type", "role"].includes(groupBy)) {
+    throw new Error(`unsupported group-by mode: ${groupBy}`);
+  }
+  if (view === "module" && !["namespace", "folder"].includes(groupBy)) {
+    throw new Error("module view supports --group-by namespace or folder");
+  }
+  const requestedModuleDepth = options["module-depth"] ?? options.moduleDepth ?? "auto";
+  const moduleDepth = requestedModuleDepth === "auto"
+    ? "auto"
+    : positiveInteger(requestedModuleDepth, "module-depth");
+
+  let model = resolveModel(await analyze(input));
+  model = filterModel(model, options);
+  model = addInsights(model, options.forbiddenDependencies ?? []);
+  const workflow = options.workflow ?? {};
+  model = createView(model, view, {
+    object: options.object,
+    groupBy,
+    moduleDepth,
+    folderDepth: positiveInteger(
+      options["folder-depth"] ?? options.folderDepth,
+      "folder-depth",
+      1
+    ),
+    includeUnresolvedCalls:
+      options["include-unresolved-calls"] ?? options.includeUnresolvedCalls ?? false,
+    scope: options.scope,
+    focus: options.focus,
+    entry: options.entry ?? workflow.entry ?? workflow.entries,
+    depth: options["workflow-depth"] ?? options.workflowDepth ?? workflow.depth,
+    maxNodes:
+      options["workflow-max-nodes"] ?? options.workflowMaxNodes ?? workflow.maxNodes,
+    maxEdges:
+      cliValues["max-edges"] ?? workflow.maxEdges ??
+      options["max-edges"] ?? options.maxEdges,
+    edgeTypes:
+      options["workflow-edge-types"] ?? options.workflowEdgeTypes ?? workflow.edgeTypes,
+    phases: options.phases ?? workflow.phases,
+    stop: options.stop ?? options.stopConditions ?? workflow.stop ?? workflow.stopConditions,
+    collapse:
+      options.collapse ?? options.collapseUtilities ??
+      workflow.collapse ?? workflow.collapseUtilities
+  });
+  model = addInsights(model);
+  if (!model.objects.length && !model.emptyMessage) {
+    throw new Error("no AL objects matched");
+  }
+
+  const seriousDiagnostics = model.diagnostics.filter(
+    ({ severity }) => severity === "error" || severity === "warning"
+  );
+  if (options.strict && seriousDiagnostics.length) {
+    throw new Error(
+      `${seriousDiagnostics.length} diagnostic(s) in strict mode; run inspect for details`
+    );
+  }
+
+  const paths = outputPaths(options, command);
+  if (paths.format === "json") {
+    const json = JSON.stringify(model, null, 2) + "\n";
+    if (paths.finalOutput) {
+      await fs.mkdir(path.dirname(paths.finalOutput), { recursive: true });
+      await fs.writeFile(paths.finalOutput, json);
+    } else {
+      process.stdout.write(json);
+    }
+  } else {
+    const source = renderD2(model, {
+      direction,
+      title: options.title ?? `AL ${view} architecture`,
+      includeExternal: !(options["no-external"] ?? options.noExternal ?? false),
+      details: options.details ?? false,
+      memberNames: view === "object",
+      groupBy: view === "module" ? "namespace" : groupBy,
+      sourceUrlTemplate: options["source-url"] ?? options.sourceUrl,
+      maxEdges: positiveInteger(options["max-edges"] ?? options.maxEdges, "max-edges", 500)
+    });
+    await fs.mkdir(path.dirname(paths.d2Output), { recursive: true });
+    await fs.writeFile(paths.d2Output, source);
+    if (paths.format === "svg") {
+      const svg = await renderSvg(source, options);
+      await fs.mkdir(path.dirname(paths.finalOutput), { recursive: true });
+      await fs.writeFile(paths.finalOutput, svg);
+    } else if (paths.format !== "d2") {
+      await fs.mkdir(path.dirname(paths.finalOutput), { recursive: true });
+      await runD2(paths.d2Output, paths.finalOutput, options);
+    }
+  }
+
+  if (!quiet && command !== "inspect") {
+    const warnings = seriousDiagnostics.length
+      ? `, ${seriousDiagnostics.length} diagnostic(s)`
+      : "";
+    console.log(
+      `Analyzed ${model.files} file(s); ${model.objects.length} ${view} node(s), ${model.edges.length} edge(s)${warnings}.`
+    );
+    if (paths.finalOutput) console.log(`Wrote ${paths.finalOutput}`);
+    if (paths.format !== "d2" && paths.format !== "json") {
+      console.log(`Kept D2 source at ${paths.d2Output}`);
+    }
+  }
+  return { model, paths, options };
+}
+
+async function watch(input, values) {
+  const initial = await build(input, "graph", values);
+  const debounce = positiveInteger(values.debounce ?? initial.options.debounce, "debounce", 250);
+  let timer;
+  let building = false;
+  let pending = false;
+
+  const rebuild = async () => {
+    if (building) {
+      pending = true;
+      return;
+    }
+    building = true;
+    try {
+      await build(input, "graph", values);
+    } catch (error) {
+      console.error(`bca: rebuild failed: ${error.message}`);
+    } finally {
+      building = false;
+      if (pending) {
+        pending = false;
+        void rebuild();
+      }
+    }
+  };
+
+  const watcher = fsWatch(path.resolve(input), { recursive: true }, (_event, filename) => {
+    if (filename && !filename.toLowerCase().endsWith(".al") &&
+        path.basename(filename) !== "app.json" &&
+        path.basename(filename) !== ".bca.json") return;
+    clearTimeout(timer);
+    timer = setTimeout(rebuild, debounce);
+  });
+  watcher.on("error", (error) => console.error(`bca: watcher error: ${error.message}`));
+  console.log("Watching for AL changes. Press Ctrl+C to stop.");
+}
+
+async function main() {
+  if (process.argv[2] === "docs") return docsMain(process.argv.slice(3));
+  const { values, positionals } = parseArgs({
+    allowPositionals: true,
+    strict: true,
+    options: OPTIONS
+  });
+  if (values.help) return console.log(HELP);
+  if (values.version) {
+    const pkg = JSON.parse(await fs.readFile(new URL("../package.json", import.meta.url)));
+    return console.log(pkg.version);
+  }
+
+  const commands = new Set(["graph", "inspect", "watch"]);
+  const command = commands.has(positionals[0]) ? positionals.shift() : "graph";
+  if (positionals.length !== 1) {
+    console.log(HELP);
+    throw new Error("expected exactly one AL file or project directory");
+  }
+  if (command === "watch") return watch(positionals[0], values);
+  return build(positionals[0], command, values);
+}
+
+main().catch((error) => fail(error.message, 2));

package/src/config.js

@@ -0,0 +1,25 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+
+export async function loadConfig(input, explicitPath) {
+  const inputPath = path.resolve(input);
+  const stat = await fs.stat(inputPath);
+  const base = stat.isDirectory() ? inputPath : path.dirname(inputPath);
+  const configPath = explicitPath
+    ? path.resolve(explicitPath)
+    : path.join(base, ".bca.json");
+  try {
+    const text = await fs.readFile(configPath, "utf8");
+    const config = JSON.parse(text);
+    if (!config || Array.isArray(config) || typeof config !== "object") {
+      throw new Error("configuration root must be an object");
+    }
+    return { path: configPath, values: config };
+  } catch (error) {
+    if (error.code === "ENOENT" && !explicitPath) return { values: {} };
+    if (error instanceof SyntaxError) {
+      throw new Error(`Invalid JSON in ${configPath}: ${error.message}`);
+    }
+    throw error;
+  }
+}

package/src/d2.js

@@ -0,0 +1,264 @@
+import { resolveModel } from "./resolver.js";
+
+const TYPE_STYLES = {
+  table: ["#DCEBFF", "#2362A2"],
+  tableextension: ["#DCEBFF", "#2362A2"],
+  page: ["#E5F6E8", "#31783B"],
+  pageextension: ["#E5F6E8", "#31783B"],
+  pagecustomization: ["#E5F6E8", "#31783B"],
+  codeunit: ["#FFF0D6", "#A96300"],
+  report: ["#F5E5FF", "#77449A"],
+  reportextension: ["#F5E5FF", "#77449A"],
+  query: ["#E1F7F5", "#14766E"],
+  xmlport: ["#FFE2E2", "#A23636"],
+  enum: ["#EEEEEE", "#555555"],
+  enumextension: ["#EEEEEE", "#555555"],
+  interface: ["#FFF8C9", "#8B7400"],
+  module: ["#E8ECF3", "#4E5D78"],
+  procedure: ["#F3F6FA", "#55708F"],
+  trigger: ["#FFF0D6", "#A96300"],
+  event: ["#F5E5FF", "#77449A"],
+  subscriber: ["#FCE8F3", "#A33A78"],
+  action: ["#E5F6E8", "#31783B"]
+};
+
+const RELATION_STYLES = {
+  calls: { color: "#4C78A8" },
+  reads: { color: "#0072B2" },
+  writes: { color: "#D55E00" },
+  relates: { color: "#009E73" },
+  uses: { color: "#6B7280", dash: 3 },
+  extends: { color: "#CC79A7" },
+  implements: { color: "#E69F00" },
+  selects: { color: "#EA580C" },
+  publishes: { color: "#A21CAF" },
+  subscribes: { color: "#A21CAF", dash: 3 },
+  runs: { color: "#15803D" },
+  part: { color: "#0891B2", dash: 3 },
+  contains: { color: "#0891B2", dash: 3 },
+  permits: { color: "#7C3AED" },
+  includes: { color: "#8B5CF6" },
+  starts: { color: "#15803D" },
+  events: { color: "#A21CAF", dash: 3 }
+};
+
+function quote(value) {
+  return `"${String(value).replaceAll("\\", "\\\\").replaceAll('"', '\\"').replaceAll("\n", "\\n")}"`;
+}
+
+function normalized(value) {
+  return String(value).replace(/^"|"$/gu, "").trim().toLowerCase();
+}
+
+function uniqueRelations(relations) {
+  const combined = new Map();
+  for (const relation of relations) {
+    const key =
+      `${relation.from}|${relation.to}|${relation.kind}|${relation.access ?? ""}|` +
+      `${relation.label ?? ""}|${relation.sequence ?? ""}|${relation.isCycle ?? ""}`;
+    const existing = combined.get(key);
+    if (existing) existing.weight = (existing.weight ?? 1) + (relation.weight ?? 1);
+    else combined.set(key, { ...relation });
+  }
+  return [...combined.values()];
+}
+
+function roleFor(type) {
+  if (["table", "tableextension"].includes(type)) return "Data";
+  if (["page", "pageextension", "pagecustomization"].includes(type)) return "UI";
+  if (["codeunit"].includes(type)) return "Services";
+  if (["interface", "enum", "enumextension"].includes(type)) return "Contracts";
+  if (["permissionset", "permissionsetextension", "entitlement"].includes(type)) return "Security";
+  if (["report", "reportextension", "query", "xmlport"].includes(type)) {
+    return "Reporting & Integration";
+  }
+  return "Other";
+}
+
+function groupFor(object, groupBy) {
+  if (object.viewGroup) return object.viewGroup;
+  if (groupBy === "type") return object.type;
+  if (groupBy === "role") return roleFor(object.type);
+  if (groupBy === "folder") {
+    const parts = object.file.replaceAll("\\", "/").split("/");
+    return parts.length > 1 ? parts[0] : "(root)";
+  }
+  return object.namespace;
+}
+
+function memberSummary(items, limit = 8) {
+  const names = items.map(({ name }) => name).filter(Boolean);
+  const shown = names.slice(0, limit);
+  if (names.length > limit) shown.push(`+${names.length - limit} more`);
+  return shown.join(", ");
+}
+
+function relationStyle(kind, sequence, isCycle) {
+  const style = RELATION_STYLES[kind] ?? { color: "#64748B" };
+  const properties = [`style.stroke: ${quote(isCycle ? "#B91C1C" : style.color)}`];
+  if (style.dash || sequence === "inferred") {
+    properties.push(`style.stroke-dash: ${style.dash ?? 4}`);
+  }
+  if (isCycle) properties.push("style.stroke-width: 3");
+  return ` {${properties.join("; ")}}`;
+}
+
+export function renderD2(model, options = {}) {
+  if (!model.edges) model = resolveModel(model);
+  const direction = options.direction ?? "right";
+  const includeExternal = options.includeExternal ?? true;
+  const maxEdges = Number(options.maxEdges ?? 500);
+  const lines = [
+    `direction: ${direction}`,
+    `title: ${quote(options.title ?? "AL architecture")} {`,
+    "  shape: text",
+    "  near: top-center",
+    "  style.font-size: 28",
+    "}",
+    ""
+  ];
+  const nodes = new Map();
+  const keyIndex = new Map();
+
+  model.objects.forEach((object, index) => {
+    const key = `n${index}`;
+    nodes.set(object, key);
+    keyIndex.set(object.key, object);
+  });
+
+  if (!model.objects.length && model.emptyMessage) {
+    lines.push(`empty: ${quote(model.emptyMessage)} {`);
+    lines.push("  shape: text");
+    lines.push('  style.font-color: "#666666"');
+    lines.push("}", "");
+  }
+
+  const namespaces = new Map();
+  for (const object of model.objects) {
+    const group = groupFor(object, options.groupBy ?? "namespace");
+    const list = namespaces.get(group) ?? [];
+    list.push(object);
+    namespaces.set(group, list);
+  }
+
+  let groupIndex = 0;
+  for (const [namespace, objects] of [...namespaces].sort(([a], [b]) => a.localeCompare(b))) {
+    const group = `g${groupIndex++}`;
+    lines.push(`${group}: ${quote(namespace)} {`);
+    lines.push("  style.stroke-dash: 3");
+    for (const object of objects.sort((a, b) => a.name.localeCompare(b.name))) {
+      const key = nodes.get(object);
+      const label = object.id
+        ? `${object.type} ${object.id}\n${object.name}`
+        : `${object.type}\n${object.name}`;
+      const details = options.details
+        ? [
+            object.members?.length ? `${object.members.length} objects` : undefined,
+            object.fields?.length ? `${object.fields.length} fields` : undefined,
+            object.actions?.length ? `${object.actions.length} actions` : undefined,
+            object.procedures?.length ? `${object.procedures.length} procedures` : undefined,
+            options.memberNames && object.isFocus && object.fields?.length
+              ? `Fields: ${memberSummary(object.fields)}`
+              : undefined,
+            options.memberNames && object.isFocus && object.actions?.length
+              ? `Actions: ${memberSummary(object.actions)}`
+              : undefined,
+            options.memberNames && object.isFocus && object.procedures?.length
+              ? `Procedures: ${memberSummary(object.procedures, 10)}`
+              : undefined
+          ].filter(Boolean)
+        : [];
+      const annotations = [
+        object.workflowEntry ? "entry" : undefined,
+        object.cycle ? `cycle ${object.cycle}` : undefined,
+        object.shared ? `shared by ${object.shared} branches` : undefined
+      ].filter(Boolean);
+      const fullDetails = [...details, ...annotations];
+      const fullLabel = fullDetails.length ? `${label}\n${fullDetails.join(" • ")}` : label;
+      const [fill, stroke] = TYPE_STYLES[object.type] ?? ["#F5F5F5", "#666666"];
+      lines.push(`  ${key}: ${quote(fullLabel)} {`);
+      lines.push("    shape: rectangle");
+      const source = object.location?.line
+        ? `${object.file}:${object.location.line}`
+        : object.file;
+      if (source) lines.push(`    tooltip: ${quote(source)}`);
+      if (options.sourceUrlTemplate && object.file) {
+        const link = options.sourceUrlTemplate
+          .replaceAll("{file}", object.file.replaceAll("\\", "/"))
+          .replaceAll("{line}", String(object.location?.line ?? 1));
+        lines.push(`    link: ${quote(link)}`);
+      }
+      lines.push(`    style.fill: ${quote(fill)}`);
+      lines.push(`    style.stroke: ${quote(stroke)}`);
+      if (object.type.endsWith("extension")) lines.push("    style.stroke-dash: 4");
+      lines.push("  }");
+    }
+    lines.push("}", "");
+    for (const object of objects) nodes.set(object, `${group}.${nodes.get(object)}`);
+  }
+
+  const external = new Map();
+  const edges = [];
+  for (const edge of model.edges.slice(0, maxEdges)) {
+    const source = keyIndex.get(edge.from);
+    const target = edge.to ? keyIndex.get(edge.to) : undefined;
+    if (!source) continue;
+    let targetKey = target ? nodes.get(target) : undefined;
+    if (!targetKey && includeExternal && edge.unresolved) {
+      const externalKey = `${edge.unresolved.type}:${normalized(edge.unresolved.name)}`;
+      if (!external.has(externalKey)) external.set(externalKey, `external.e${external.size}`);
+      targetKey = external.get(externalKey);
+    }
+    if (targetKey) {
+      edges.push({
+        from: nodes.get(source),
+        to: targetKey,
+        kind: edge.kind,
+        access: edge.access,
+        label: edge.label,
+        weight: edge.weight,
+        sequence: edge.sequence,
+        isCycle: edge.isCycle
+      });
+    }
+  }
+
+  if (external.size) {
+    lines.push(`external: ${quote("External / unresolved")} {`);
+    lines.push("  style.stroke-dash: 5");
+    for (const [lookup, key] of external) {
+      const [type, ...nameParts] = lookup.split(":");
+      const localKey = key.split(".")[1];
+      lines.push(`  ${localKey}: ${quote(`${type}\n${nameParts.join(":")}`)} {`);
+      lines.push(`    style.fill: ${quote("#FAFAFA")}`);
+      lines.push(`    style.stroke: ${quote("#999999")}`);
+      lines.push("  }");
+    }
+    lines.push("}", "");
+  }
+
+  for (const edge of uniqueRelations(edges)) {
+    const arrow = edge.kind === "extends" || edge.kind === "implements" ? "-->" : "->";
+    const relationLabel = edge.label ?? edge.kind;
+    const certainty = edge.sequence ? ` [${edge.sequence}]` : "";
+    const cycle = edge.isCycle ? " [cycle]" : "";
+    const baseLabel =
+      `${edge.access ? `${relationLabel} [${edge.access}]` : relationLabel}${certainty}${cycle}`;
+    const label = edge.weight && edge.weight > 1
+      ? `${baseLabel} (${edge.weight})`
+      : baseLabel;
+    lines.push(
+      `${edge.from} ${arrow} ${edge.to}: ${quote(label)}${relationStyle(
+        edge.kind,
+        edge.sequence,
+        edge.isCycle
+      )}`
+    );
+  }
+
+  if (model.edges.length > maxEdges) {
+    lines.push("", `# ${model.edges.length - maxEdges} edges omitted by maxEdges=${maxEdges}`);
+  }
+  lines.push("");
+  return lines.join("\n");
+}