@zenuml/core 4.1.0 → 4.2.1

package/dist/cli/zenuml.mjs

@@ -1,8 +1,8 @@
 #!/usr/bin/env bun
 import antlr4 from 'antlr4';
 import { marked } from 'marked';
-import { mkdirSync, writeFileSync, readFileSync, statSync, watch } from 'node:fs';
-import { resolve, dirname, extname, basename, join } from 'node:path';
+import { readFileSync, statSync, mkdirSync, writeFileSync, watch } from 'node:fs';
+import { resolve, join, dirname, basename, extname } from 'node:path';
 
 // Generated from java-escape by ANTLR 4.11.1
 // jshint ignore: start
@@ -2738,7 +2738,7 @@ class sequenceParser extends antlr4.Parser {
 
 
 	returnAsyncMessage() {
-	    let localctx = new ReturnAsyncMessageContext$2(this, this._ctx, this.state);
+	    let localctx = new ReturnAsyncMessageContext$3(this, this._ctx, this.state);
 	    this.enterRule(localctx, 30, sequenceParser.RULE_returnAsyncMessage);
 	    var _la = 0; // Token type
 	    try {
@@ -5800,7 +5800,7 @@ let RetContext$3 = class RetContext extends antlr4.ParserRuleContext {
 	};
 
 	returnAsyncMessage() {
-	    return this.getTypedRuleContext(ReturnAsyncMessageContext$2,0);
+	    return this.getTypedRuleContext(ReturnAsyncMessageContext$3,0);
 	};
 
 	enterRule(listener) {
@@ -5820,7 +5820,7 @@ let RetContext$3 = class RetContext extends antlr4.ParserRuleContext {
 
 
 
-let ReturnAsyncMessageContext$2 = class ReturnAsyncMessageContext extends antlr4.ParserRuleContext {
+let ReturnAsyncMessageContext$3 = class ReturnAsyncMessageContext extends antlr4.ParserRuleContext {
 
     constructor(parser, parent, invokingState) {
         if(parent===undefined) {
@@ -8714,7 +8714,7 @@ sequenceParser.WidthContext = WidthContext;
 sequenceParser.EmojiContext = EmojiContext; 
 sequenceParser.BlockContext = BlockContext; 
 sequenceParser.RetContext = RetContext$3; 
-sequenceParser.ReturnAsyncMessageContext = ReturnAsyncMessageContext$2; 
+sequenceParser.ReturnAsyncMessageContext = ReturnAsyncMessageContext$3; 
 sequenceParser.DividerContext = DividerContext$1; 
 sequenceParser.DividerNoteContext = DividerNoteContext; 
 sequenceParser.StatContext = StatContext$3; 
@@ -8779,6 +8779,10 @@ const blankParticipant = {
 };
 let Participant$1 = class Participant {
   name;
+  // Fields the renderer-facing ParticipantView (ir/contract.ts) exposes are
+  // public; they were already fully exposed via ToValue(), so the previous
+  // `private` was inconsistent encapsulation. `width` stays private — it is not
+  // part of ParticipantView.
   stereotype;
   width;
   groupId;
@@ -9204,7 +9208,7 @@ const seqParser$7 = sequenceParser;
 const CreationContext$6 = seqParser$7.CreationContext;
 const MessageContext$6 = seqParser$7.MessageContext;
 const AsyncMessageContext$2 = seqParser$7.AsyncMessageContext;
-const ReturnAsyncMessageContext$1 = seqParser$7.ReturnAsyncMessageContext;
+const ReturnAsyncMessageContext$2 = seqParser$7.ReturnAsyncMessageContext;
 const RetMessageContext = seqParser$7.RetContext;
 
 CreationContext$6.prototype.Assignee = function () {
@@ -9264,12 +9268,12 @@ AsyncMessageContext$2.prototype.Owner = function () {
   return this.To() || getOwnerFromAncestor(this.parentCtx);
 };
 
-ReturnAsyncMessageContext$1.prototype.To = function () {
+ReturnAsyncMessageContext$2.prototype.To = function () {
   const toCtx = this.to();
   return toCtx?.name?.()?.getFormattedText() || toCtx?.getFormattedText();
 };
 
-ReturnAsyncMessageContext$1.prototype.Owner = function () {
+ReturnAsyncMessageContext$2.prototype.Owner = function () {
   return this.To() || getOwnerFromAncestor(this.parentCtx);
 };
 
@@ -9386,13 +9390,13 @@ RefContext.prototype.Participants = function() {
   return this.name().slice(1) ?? [];
 };
 
-const ParserRuleContext = antlr4.ParserRuleContext;
+const ParserRuleContext$1 = antlr4.ParserRuleContext;
 const StatContext$2 = sequenceParser.StatContext;
 const ProgContext = sequenceParser.ProgContext;
 const MessageContext$4 = sequenceParser.MessageContext;
 const CreationContext$4 = sequenceParser.CreationContext;
 
-ParserRuleContext.prototype.Origin = function () {
+ParserRuleContext$1.prototype.Origin = function () {
   let ctx = this.parentCtx;
   while (ctx && !(ctx instanceof StatContext$2 || ctx instanceof ProgContext)) {
     ctx = this.parentCtx;
@@ -9438,8 +9442,8 @@ function formatParameter(param) {
   if (param.namedParameter?.()) {
     const namedParam = param.namedParameter();
     if (namedParam) {
-      const expr = namedParam.expr();
-      const value = expr ? expr.getFormattedText() : "";
+      const expr2 = namedParam.expr();
+      const value = expr2 ? expr2.getFormattedText() : "";
       return `${namedParam.ID().getText()}=${value}`;
     }
   }
@@ -9449,8 +9453,9 @@ function formatParameter(param) {
       return `${decl.type().getText()} ${decl.ID().getText()}`;
     }
   }
-  if (param.expr?.()) {
-    return param.expr().getFormattedText();
+  const expr = param.expr?.();
+  if (expr) {
+    return expr.getFormattedText();
   }
   return param.getFormattedText();
 }
@@ -9462,6 +9467,7 @@ const ParametersContext = sequenceParser.ParametersContext;
 const AsyncMessageContext$1 = sequenceParser.AsyncMessageContext;
 const CreationContext$3 = sequenceParser.CreationContext;
 const RetContext$1 = sequenceParser.RetContext;
+const ReturnAsyncMessageContext$1 = sequenceParser.ReturnAsyncMessageContext;
 MessageContext$3.prototype.SignatureText = function() {
   return this.messageBody()?.func()?.signature()?.map((s) => s?.getFormattedText()).join(".") ?? "";
 };
@@ -9482,7 +9488,7 @@ CreationContext$3.prototype.isParamValid = function() {
 RetContext$1.prototype.SignatureText = function() {
   return this.asyncMessage()?.content()?.getFormattedText() ?? this.returnAsyncMessage()?.content()?.getFormattedText() ?? this.expr()?.getFormattedText() ?? "";
 };
-sequenceParser.ReturnAsyncMessageContext.prototype.SignatureText = function() {
+ReturnAsyncMessageContext$1.prototype.SignatureText = function() {
   return this.content()?.getFormattedText() ?? "";
 };
 ParametersContext.prototype.getFormattedText = function() {
@@ -9557,46 +9563,47 @@ LoopContext.prototype.Statements = function() {
 };
 
 const seqParser$1 = sequenceParser;
-const CreationContext = seqParser$1.CreationContext;
 const StatContext$1 = seqParser$1.StatContext;
+const CreationContext = seqParser$1.CreationContext;
 const MessageContext = seqParser$1.MessageContext;
 const AsyncMessageContext = seqParser$1.AsyncMessageContext;
 const ReturnAsyncMessageContext = seqParser$1.ReturnAsyncMessageContext;
 const RetContext = seqParser$1.RetContext;
 CreationContext.prototype.From = function() {
   if (this.parentCtx instanceof StatContext$1) {
-    return this.ClosestAncestorStat().Origin();
+    return this.ClosestAncestorStat()?.Origin();
   }
   return void 0;
 };
 MessageContext.prototype.ProvidedFrom = function() {
-  const fromCtx = this.messageBody()?.fromTo()?.from();
-  return fromCtx?.name?.()?.getFormattedText() || fromCtx?.getFormattedText();
+  const fromCtx = this.messageBody()?.fromTo?.()?.from?.();
+  return fromCtx?.name?.()?.getFormattedText?.() || fromCtx?.getFormattedText?.();
 };
 MessageContext.prototype.From = function() {
-  return this.ProvidedFrom() || this.ClosestAncestorStat().Origin();
+  return this.ProvidedFrom() || this.ClosestAncestorStat()?.Origin();
 };
 AsyncMessageContext.prototype.ProvidedFrom = function() {
   const fromCtx = this.from();
-  return fromCtx?.name?.()?.getFormattedText() || fromCtx?.getFormattedText();
+  return fromCtx?.name?.()?.getFormattedText?.() || fromCtx?.getFormattedText?.();
 };
 AsyncMessageContext.prototype.From = function() {
-  return this.ProvidedFrom() || this.ClosestAncestorStat().Origin();
+  return this.ProvidedFrom() || this.ClosestAncestorStat()?.Origin();
 };
 ReturnAsyncMessageContext.prototype.ProvidedFrom = function() {
   const fromCtx = this.from();
-  return fromCtx?.name?.()?.getFormattedText() || fromCtx?.getFormattedText();
+  return fromCtx?.name?.()?.getFormattedText?.() || fromCtx?.getFormattedText?.();
 };
 ReturnAsyncMessageContext.prototype.From = function() {
-  return this.ProvidedFrom() || this.ClosestAncestorStat().Origin();
+  return this.ProvidedFrom() || this.ClosestAncestorStat()?.Origin();
 };
 RetContext.prototype.From = function() {
-  return this.asyncMessage()?.From() || this.returnAsyncMessage()?.From() || this.ClosestAncestorStat().Origin();
+  return this.asyncMessage()?.From?.() || this.returnAsyncMessage()?.From?.() || this.ClosestAncestorStat()?.Origin();
 };
 
 const seqParser = sequenceParser;
 const StatContext = seqParser.StatContext;
-antlr4.ParserRuleContext.prototype.ClosestAncestorStat = function() {
+const ParserRuleContext = antlr4.ParserRuleContext;
+ParserRuleContext.prototype.ClosestAncestorStat = function() {
   if (this instanceof StatContext) {
     return this;
   }
@@ -9609,7 +9616,7 @@ antlr4.ParserRuleContext.prototype.ClosestAncestorStat = function() {
   }
   return void 0;
 };
-antlr4.ParserRuleContext.prototype.ClosestAncestorBlock = function() {
+ParserRuleContext.prototype.ClosestAncestorBlock = function() {
   const parentCtx = this.ClosestAncestorStat()?.parentCtx;
   if (parentCtx instanceof seqParser.BlockContext) {
     return parentCtx;
@@ -9920,33 +9927,31 @@ function OrderedParticipants(rootContext) {
   const cached = orderedParticipantsCache.get(rootContext);
   if (cached) return cached;
   const participants = ToCollector.getParticipants(rootContext);
-  const participantEntries = Array.from(participants.participants.entries());
+  const participantEntries = participants.Array().map((p) => p.ToValue());
   const allMessages = AllMessages(rootContext);
   const emptyContext = allMessages.length === 0 && participantEntries.length === 0;
   const someMessagesMissFrom = allMessages.some((m) => !m.from);
   const needDefaultStarter = emptyContext || someMessagesMissFrom;
   if (needDefaultStarter) {
-    participantEntries.unshift([
-      _STARTER_,
-      { ...blankParticipant, name: _STARTER_, isStarter: true }
-    ]);
-  }
-  const result = participantEntries.map(
-    (entry, index, entries) => {
-      const participant = entry[1];
-      const previousName = index > 0 ? entries[index - 1][1].name : "";
-      return new Participant(
-        participant.name,
-        previousName,
-        participant.label,
-        participant.type,
-        participant.stereotype,
-        participant.color,
-        participant.groupId,
-        participant.emoji
-      );
-    }
-  );
+    participantEntries.unshift({
+      ...blankParticipant,
+      name: _STARTER_,
+      isStarter: true
+    });
+  }
+  const result = participantEntries.map((participant, index, entries) => {
+    const previousName = index > 0 ? entries[index - 1].name : "";
+    return new Participant(
+      participant.name,
+      previousName,
+      participant.label,
+      participant.type,
+      participant.stereotype,
+      participant.color,
+      participant.groupId,
+      participant.emoji
+    );
+  });
   orderedParticipantsCache.set(rootContext, result);
   return result;
 }
@@ -10045,7 +10050,7 @@ function longestPathTable(graph, gaps) {
   }
   return [tracker.delta, table];
 }
-function freezeCriticalGaps(table, graph, gaps) {
+function freezeCriticalGaps(table, gaps) {
   let j = table.length - 1;
   while (j > 0) {
     const argument = table[j].argument;
@@ -10082,7 +10087,7 @@ function find_optimal(matrix) {
       return positionsFromTable(table);
     }
     if (table[n - 1].maximum.velocity > 0) {
-      freezeCriticalGaps(table, graph, gaps);
+      freezeCriticalGaps(table, gaps);
     } else {
       advanceGaps(gaps, delta);
     }
@@ -10872,10 +10877,22 @@ class FragmentAltVM extends FragmentVM {
   }
 }
 
+class FragmentRefVM extends FragmentVM {
+  kind = "ref";
+  measure(top) {
+    const context = this.context?.ref?.() || this.context;
+    const commentHeight = this.measureComment(context);
+    const headerHeight = this.metrics.fragmentHeaderHeight;
+    const height = commentHeight + headerHeight + this.metrics.fragmentPaddingBottom;
+    return { top, height, kind: this.kind };
+  }
+}
+
 class FragmentSingleBlockVM extends FragmentVM {
-  constructor(statement, fragment, runtime) {
+  constructor(statement, fragment, runtime, kind) {
     super(statement, runtime);
     this.fragment = fragment;
+    this.kind = kind;
   }
   measure(top, origin) {
     const commentHeight = this.measureComment(this.fragment);
@@ -10896,37 +10913,6 @@ class FragmentSingleBlockVM extends FragmentVM {
   }
 }
 
-class FragmentCriticalVM extends FragmentSingleBlockVM {
-  kind = "critical";
-}
-
-class FragmentLoopVM extends FragmentSingleBlockVM {
-  kind = "loop";
-}
-
-class FragmentOptVM extends FragmentSingleBlockVM {
-  kind = "opt";
-}
-
-class FragmentParVM extends FragmentSingleBlockVM {
-  kind = "par";
-}
-
-class FragmentRefVM extends FragmentVM {
-  kind = "ref";
-  measure(top) {
-    const context = this.context?.ref?.() || this.context;
-    const commentHeight = this.measureComment(context);
-    const headerHeight = this.metrics.fragmentHeaderHeight;
-    const height = commentHeight + headerHeight + this.metrics.fragmentPaddingBottom;
-    return { top, height, kind: this.kind };
-  }
-}
-
-class FragmentSectionVM extends FragmentSingleBlockVM {
-  kind = "section";
-}
-
 class FragmentTryCatchVM extends FragmentVM {
   constructor(statement, tcf, runtime) {
     super(statement, runtime);
@@ -11056,25 +11042,11 @@ const createStatementVM = (statement, runtime) => {
   if (statement.divider?.()) {
     return new DividerStatementVM(statement, runtime);
   }
-  const loop = statement.loop?.();
-  if (loop) {
-    return new FragmentLoopVM(statement, loop, runtime);
-  }
-  const opt = statement.opt?.();
-  if (opt) {
-    return new FragmentOptVM(statement, opt, runtime);
-  }
-  const par = statement.par?.();
-  if (par) {
-    return new FragmentParVM(statement, par, runtime);
-  }
-  const section = statement.section?.();
-  if (section) {
-    return new FragmentSectionVM(statement, section, runtime);
-  }
-  const critical = statement.critical?.();
-  if (critical) {
-    return new FragmentCriticalVM(statement, critical, runtime);
+  for (const kind of ["loop", "opt", "par", "section", "critical"]) {
+    const fragment = statement[kind]?.();
+    if (fragment) {
+      return new FragmentSingleBlockVM(statement, fragment, runtime, kind);
+    }
   }
   const tcf = statement.tcf?.();
   if (tcf) {
@@ -11520,7 +11492,7 @@ function snapX(x) {
   return x;
 }
 const COMMENT_FONT_ASCENT = 15;
-function buildFragmentGeometry(info, coord, coordinates, verticalCoordinates, allParticipants, measureText, commentHeight = 0, commentText, commentStyle, commentYBase) {
+function buildFragmentGeometry(info, coord, coordinates, verticalCoordinates, allParticipants, _measureText, commentHeight = 0, commentText, commentStyle, commentYBase) {
   const statNode = info.statNode;
   if (!statNode) return null;
   const fragmentCtx = findFragmentContext(statNode);
@@ -13652,6 +13624,69 @@ async function checkOne(input) {
     errors
   };
 }
+async function renderMarkdownFile(inputArg, args, config) {
+  const mdContent = await readCode(inputArg);
+  const effectiveFormat = args.outputFormat ?? config.configOutputFormat ?? "svg";
+  if (effectiveFormat !== "svg" && effectiveFormat !== "png") {
+    throw new Error(
+      `Unsupported output format: "${effectiveFormat}". Use "svg" or "png".`
+    );
+  }
+  const inputPath = inputArg === "-" ? void 0 : resolve(inputArg);
+  const outputPath = args.output === "-" ? "-" : args.output ? resolve(args.output) : inputPath ? join(
+    dirname(inputPath),
+    `${basename(inputArg, extname(inputArg))}-rendered.md`
+  ) : "-";
+  const imageDir = outputPath !== "-" ? dirname(outputPath) : inputPath ? dirname(inputPath) : process.cwd();
+  const imageStem = inputPath ? basename(inputArg, extname(inputArg)) : outputPath !== "-" ? basename(outputPath, extname(outputPath)) : "diagram";
+  const renderOptions = {};
+  const effectiveTheme = args.theme ?? config.configTheme;
+  if (effectiveTheme) {
+    renderOptions.theme = effectiveTheme;
+  }
+  const blocks = extractZenumlBlocks(mdContent);
+  const imageFiles = /* @__PURE__ */ new Map();
+  for (const block of blocks) {
+    if (block.empty) continue;
+    const imageFilename = `${imageStem}-zenuml-${block.index}.${effectiveFormat}`;
+    const imageFilePath = join(imageDir, imageFilename);
+    let result;
+    try {
+      result = renderToSvg(block.code, renderOptions);
+    } catch (err) {
+      throw new Error(
+        `Failed to render zenuml block ${block.index}: ${err.message}`
+      );
+    }
+    mkdirSync(imageDir, { recursive: true });
+    const image = effectiveFormat === "png" ? await rasterizeToPng(
+      result.svg,
+      result.width,
+      result.height,
+      args.scale ?? config.configScale ?? 2
+    ) : result.svg;
+    writeFileSync(imageFilePath, image);
+    imageFiles.set(block.index, imageFilename);
+    if (!args.quiet && !args.watch) {
+      process.stderr.write(`Wrote ${imageFilePath}
+`);
+    }
+  }
+  const outputMd = [...blocks].reverse().reduce((markdown, block) => {
+    const replacement = block.empty ? "" : `![${block.title || `diagram ${block.index + 1}`}](${imageFiles.get(block.index)})`;
+    return markdown.replace(block.raw, replacement);
+  }, mdContent);
+  if (outputPath === "-") {
+    process.stdout.write(outputMd);
+    return;
+  }
+  mkdirSync(dirname(outputPath), { recursive: true });
+  writeFileSync(outputPath, outputMd, "utf-8");
+  if (!args.quiet && !args.watch) {
+    process.stderr.write(`Wrote ${outputPath}
+`);
+  }
+}
 async function main() {
   if (!globalThis.OffscreenCanvas && typeof document === "undefined") {
     try {
@@ -13755,146 +13790,6 @@ async function main() {
     process.stdout.write(JSON.stringify(ast, null, 2) + "\n");
     process.exit(0);
   }
-  const isMdMode = args.md || expandedInputs.some((f) => f !== "-" && /\.(?:md|markdown)$/i.test(f));
-  if (isMdMode) {
-    if (expandedInputs.length > 1) {
-      process.stderr.write(
-        "Error: --md mode supports only a single input file.\n"
-      );
-      process.exit(1);
-    }
-    const inputArg = expandedInputs[0];
-    if (args.md && inputArg !== "-") {
-      const ext = extname(inputArg).toLowerCase();
-      if (ext !== ".md" && ext !== ".markdown") {
-        process.stderr.write(
-          `Error: --md flag requires a .md or .markdown input file, got: ${inputArg}
-`
-        );
-        process.exit(1);
-      }
-    }
-    let mdContent;
-    try {
-      mdContent = await readCode(inputArg);
-    } catch (err) {
-      process.stderr.write(`Error: ${err.message}
-`);
-      process.exit(1);
-    }
-    const effectiveFormat = args.outputFormat ?? "svg";
-    if (effectiveFormat !== "svg" && effectiveFormat !== "png") {
-      process.stderr.write(
-        `Error: Unsupported output format: "${effectiveFormat}". Use "svg" or "png".
-`
-      );
-      process.exit(1);
-    }
-    let imageDir;
-    let mdOutputPath;
-    if (args.output && args.output !== "-") {
-      const resolvedOutput = resolve(args.output);
-      imageDir = dirname(resolvedOutput);
-      mdOutputPath = resolvedOutput;
-    } else if (args.output === "-") {
-      if (inputArg !== "-") {
-        imageDir = dirname(resolve(inputArg));
-      } else {
-        imageDir = process.cwd();
-      }
-      mdOutputPath = "-";
-    } else {
-      if (inputArg !== "-") {
-        const resolvedInput = resolve(inputArg);
-        const inputDir = dirname(resolvedInput);
-        const ext = extname(inputArg);
-        const stem = basename(inputArg, ext);
-        imageDir = inputDir;
-        mdOutputPath = join(inputDir, `${stem}-rendered.md`);
-      } else {
-        imageDir = process.cwd();
-        mdOutputPath = "-";
-      }
-    }
-    let imageStem;
-    if (inputArg !== "-") {
-      const ext = extname(inputArg);
-      imageStem = basename(inputArg, ext);
-    } else if (mdOutputPath !== "-") {
-      const ext = extname(mdOutputPath);
-      imageStem = basename(mdOutputPath, ext);
-    } else {
-      imageStem = "diagram";
-    }
-    const blocks = extractZenumlBlocks(mdContent);
-    const effectiveScale = args.scale ?? 2;
-    const effectiveTheme = args.theme;
-    const renderOptions = {};
-    if (effectiveTheme) {
-      renderOptions.theme = effectiveTheme;
-    }
-    const imageFiles = /* @__PURE__ */ new Map();
-    for (const block of blocks) {
-      if (block.empty) continue;
-      const imageFilename = `${imageStem}-zenuml-${block.index}.${effectiveFormat}`;
-      const imageFilePath = join(imageDir, imageFilename);
-      let svg;
-      let svgWidth;
-      let svgHeight;
-      try {
-        const result = renderToSvg(block.code, renderOptions);
-        svg = result.svg;
-        svgWidth = result.width;
-        svgHeight = result.height;
-      } catch (err) {
-        process.stderr.write(
-          `Error: Failed to render zenuml block ${block.index}: ${err.message}
-`
-        );
-        process.exit(1);
-      }
-      mkdirSync(imageDir, { recursive: true });
-      if (effectiveFormat === "png") {
-        const pngBuffer = await rasterizeToPng(
-          svg,
-          svgWidth,
-          svgHeight,
-          effectiveScale
-        );
-        writeFileSync(imageFilePath, pngBuffer);
-      } else {
-        writeFileSync(imageFilePath, svg, "utf-8");
-      }
-      if (!args.quiet) {
-        process.stderr.write(`Wrote ${imageFilePath}
-`);
-      }
-      imageFiles.set(block.index, imageFilename);
-    }
-    let outputMd = mdContent;
-    const sortedBlocks = [...blocks].reverse();
-    for (const block of sortedBlocks) {
-      const altText = block.title || `diagram ${block.index + 1}`;
-      if (block.empty) {
-        outputMd = outputMd.replace(block.raw, "");
-      } else {
-        const imageFilename = imageFiles.get(block.index);
-        const replacement = `![${altText}](${imageFilename})`;
-        outputMd = outputMd.replace(block.raw, replacement);
-      }
-    }
-    if (mdOutputPath === "-") {
-      process.stdout.write(outputMd);
-    } else {
-      mkdirSync(dirname(mdOutputPath), { recursive: true });
-      writeFileSync(mdOutputPath, outputMd, "utf-8");
-      if (!args.quiet) {
-        process.stderr.write(`Wrote ${mdOutputPath}
-`);
-      }
-    }
-    process.exit(0);
-  }
   let configScale;
   let configTheme;
   let configOutputFormat;
@@ -13912,99 +13807,30 @@ async function main() {
     );
     process.exit(1);
   }
-  if (args.watch) {
-    const renderForWatch = async (inputArg) => {
-      await renderOneFile(inputArg, args, {
-        configScale,
-        configTheme,
-        configOutputFormat});
-    };
-    const renderMdForWatch = async (inputArg) => {
-      let mdContent;
-      try {
-        mdContent = readFileSync(resolve(inputArg), "utf-8");
-      } catch {
-        throw new Error(`Cannot read input file: ${resolve(inputArg)}`);
-      }
-      const effectiveFormat = args.outputFormat ?? "svg";
-      if (effectiveFormat !== "svg" && effectiveFormat !== "png") {
-        throw new Error(
-          `Unsupported output format: "${effectiveFormat}". Use "svg" or "png".`
-        );
-      }
-      let mdOutputPath;
-      let imageDir;
-      if (args.output && args.output !== "-") {
-        const resolvedOutput = resolve(args.output);
-        imageDir = dirname(resolvedOutput);
-        mdOutputPath = resolvedOutput;
-      } else if (args.output === "-") {
-        imageDir = dirname(resolve(inputArg));
-        mdOutputPath = "-";
-      } else {
-        const resolvedInput = resolve(inputArg);
-        const inputDir = dirname(resolvedInput);
-        const ext2 = extname(inputArg);
-        const stem = basename(inputArg, ext2);
-        imageDir = inputDir;
-        mdOutputPath = join(inputDir, `${stem}-rendered.md`);
-      }
-      const ext = extname(inputArg);
-      const imageStem = basename(inputArg, ext);
-      const blocks = extractZenumlBlocks(mdContent);
-      const effectiveScale = args.scale ?? configScale ?? 2;
-      const imageFiles = /* @__PURE__ */ new Map();
-      for (const block of blocks) {
-        if (block.empty) continue;
-        const imageFilename = `${imageStem}-zenuml-${block.index}.${effectiveFormat}`;
-        const imageFilePath = join(imageDir, imageFilename);
-        const result = renderToSvg(block.code);
-        const { svg, width: svgWidth, height: svgHeight } = result;
-        mkdirSync(imageDir, { recursive: true });
-        if (effectiveFormat === "png") {
-          const pngBuffer = await rasterizeToPng(
-            svg,
-            svgWidth,
-            svgHeight,
-            effectiveScale
-          );
-          writeFileSync(imageFilePath, pngBuffer);
-        } else {
-          writeFileSync(imageFilePath, svg, "utf-8");
-        }
-        imageFiles.set(block.index, imageFilename);
-      }
-      let outputMd = mdContent;
-      const sortedBlocks = [...blocks].reverse();
-      for (const block of sortedBlocks) {
-        const altText = block.title || `diagram ${block.index + 1}`;
-        if (block.empty) {
-          outputMd = outputMd.replace(block.raw, "");
-        } else {
-          const imageFilename = imageFiles.get(block.index);
-          const replacement = `![${altText}](${imageFilename})`;
-          outputMd = outputMd.replace(block.raw, replacement);
-        }
-      }
-      if (mdOutputPath === "-") {
-        process.stdout.write(outputMd);
-      } else {
-        mkdirSync(dirname(mdOutputPath), { recursive: true });
-        writeFileSync(mdOutputPath, outputMd, "utf-8");
-      }
-    };
-    const hasMdInputs = expandedInputs.some(
-      (f) => /\.(?:md|markdown)$/i.test(f)
+  const config = {
+    configScale,
+    configTheme,
+    configOutputFormat,
+    multipleInputs
+  };
+  const isMdMode = args.md || expandedInputs.some((f) => f !== "-" && /\.(?:md|markdown)$/i.test(f));
+  if (isMdMode && multipleInputs) {
+    process.stderr.write(
+      "Error: --md mode supports only a single input file.\n"
     );
-    const renderMdFnForWatch = hasMdInputs ? renderMdForWatch : void 0;
-    const watchHandle = await startWatchMode(
-      expandedInputs,
-      renderForWatch,
-      void 0,
-      void 0,
-      void 0,
-      renderMdFnForWatch
+    process.exit(1);
+  }
+  const inputArg = expandedInputs[0];
+  if (args.md && inputArg !== "-" && !/\.(?:md|markdown)$/i.test(inputArg)) {
+    process.stderr.write(
+      `Error: --md flag requires a .md or .markdown input file, got: ${inputArg}
+`
     );
+    process.exit(1);
+  }
+  if (args.watch) {
+    const renderForWatch = (input) => isMdMode ? renderMarkdownFile(input, args, config) : renderOneFile(input, args, config);
+    const watchHandle = await startWatchMode(expandedInputs, renderForWatch);
     process.on("SIGINT", () => {
       watchHandle.shutdown();
       process.exit(0);
@@ -14013,16 +13839,26 @@ async function main() {
     });
     return;
   }
+  if (isMdMode) {
+    try {
+      await renderMarkdownFile(inputArg, args, config);
+      process.exit(0);
+    } catch (err) {
+      process.stderr.write(`Error: ${err.message}
+`);
+      process.exit(1);
+    }
+  }
   let rendered = 0;
   let errors = 0;
-  for (const inputArg of expandedInputs) {
+  for (const inputArg2 of expandedInputs) {
     if (!args.quiet) {
-      const displayName = inputArg === "-" ? "<stdin>" : inputArg;
+      const displayName = inputArg2 === "-" ? "<stdin>" : inputArg2;
       process.stderr.write(`Rendering ${displayName}...
 `);
     }
     try {
-      await renderOneFile(inputArg, args, {
+      await renderOneFile(inputArg2, args, {
         configScale,
         configTheme,
         configOutputFormat,
@@ -14031,7 +13867,7 @@ async function main() {
       rendered++;
     } catch (err) {
       errors++;
-      process.stderr.write(`Error: ${inputArg}: ${err.message}
+      process.stderr.write(`Error: ${inputArg2}: ${err.message}
 `);
     }
   }