@pfdsl/core 0.0.1

package/dist/index.js

@@ -0,0 +1,2386 @@
+// src/audit.ts
+function auditGraph(edges, nodeKinds, artifactMeta) {
+  const produced = /* @__PURE__ */ new Set();
+  const consumed = /* @__PURE__ */ new Set();
+  for (const e of edges) {
+    if (e.kind === "output") {
+      produced.add(e.artifact);
+    } else if (e.kind === "input") {
+      consumed.add(e.artifact);
+    }
+  }
+  const artifacts = [];
+  for (const [id, kind] of nodeKinds) {
+    if (kind === "artifact") artifacts.push(id);
+  }
+  for (const a of [...produced, ...consumed]) {
+    if (!nodeKinds.has(a)) artifacts.push(a);
+  }
+  const terminals = [...new Set(artifacts)].filter(
+    (a) => produced.has(a) && !consumed.has(a) && !artifactMeta?.[a]?.externalStakeholders?.length
+  );
+  const externalInputs = [...new Set(artifacts)].filter(
+    (a) => consumed.has(a) && !produced.has(a)
+  );
+  return { terminals, externalInputs };
+}
+
+// src/formatter.ts
+function splitBodyIntoSegments(body) {
+  if (body === "") return [];
+  const lines = body.split("\n");
+  const hasTrailingNewline = body.endsWith("\n");
+  const realLines = hasTrailingNewline ? lines.slice(0, -1) : lines;
+  const segments = [];
+  let current = null;
+  for (const line of realLines) {
+    const isComment = line === "" || line.startsWith("#");
+    const kind = isComment ? "comment" : "edges";
+    if (current && current.kind === kind) {
+      current.text += `${line}
+`;
+    } else {
+      if (current) segments.push(current);
+      current = { kind, text: `${line}
+` };
+    }
+  }
+  if (current) segments.push(current);
+  return segments;
+}
+function formatEdges(sortedEdges, sortedIsolated = []) {
+  const lines = [];
+  for (const e of sortedEdges) {
+    if (e.kind === "input") lines.push(`${e.artifact} >> ${e.process}`);
+    else if (e.kind === "feedback")
+      lines.push(`${e.artifact} >>? ${e.process}`);
+    else lines.push(`${e.process} -> ${e.artifact}`);
+  }
+  for (const id of sortedIsolated) lines.push(id);
+  if (lines.length === 0) return "";
+  return `${lines.join("\n")}
+`;
+}
+function formatAsFlows(sortedEdges, sortedIsolated = []) {
+  const byProcess = /* @__PURE__ */ new Map();
+  for (const e of sortedEdges) {
+    let entry = byProcess.get(e.process);
+    if (!entry) {
+      entry = { inputs: [], outputs: [], feedbacks: [] };
+      byProcess.set(e.process, entry);
+    }
+    if (e.kind === "input") entry.inputs.push(e.artifact);
+    else if (e.kind === "output") entry.outputs.push(e.artifact);
+    else entry.feedbacks.push(e.artifact);
+  }
+  const rankProxy = /* @__PURE__ */ new Map();
+  const offset = sortedEdges.length;
+  for (let i = 0; i < sortedEdges.length; i++) {
+    const e = sortedEdges[i];
+    if (e.kind !== "input" && !rankProxy.has(e.process)) {
+      rankProxy.set(e.process, i);
+    }
+  }
+  for (let i = 0; i < sortedEdges.length; i++) {
+    const e = sortedEdges[i];
+    if (e.kind === "input" && !rankProxy.has(e.process)) {
+      rankProxy.set(e.process, i + offset);
+    }
+  }
+  const processOrder = [...byProcess.keys()].sort((a, b) => {
+    const diff = (rankProxy.get(a) ?? offset * 2) - (rankProxy.get(b) ?? offset * 2);
+    return diff !== 0 ? diff : a.localeCompare(b);
+  });
+  const lines = [];
+  for (const proc of processOrder) {
+    const { inputs, outputs, feedbacks } = byProcess.get(proc);
+    for (const fb of feedbacks) lines.push(`${fb} >>? ${proc}`);
+    if (inputs.length === 0 && outputs.length === 0) continue;
+    const fmtIds = (ids) => ids.length === 1 ? ids[0] : `[${ids.join(", ")}]`;
+    let stmt = inputs.length > 0 ? `${fmtIds(inputs)} >> ${proc}` : proc;
+    if (outputs.length > 0) stmt += ` -> ${fmtIds(outputs)}`;
+    lines.push(stmt);
+  }
+  for (const id of sortedIsolated) lines.push(id);
+  if (lines.length === 0) return "";
+  return `${lines.join("\n")}
+`;
+}
+
+// src/frontmatter.ts
+import { parse as parseYaml } from "yaml";
+function findFrontmatterNodeRanges(source) {
+  const result = /* @__PURE__ */ new Map();
+  const { bodyStartLine } = loadFrontmatter(source);
+  const fmEndLine = bodyStartLine - 1;
+  const lines = source.split("\n");
+  let inNodeSection = false;
+  for (let i = 0; i < fmEndLine && i < lines.length; i++) {
+    const line = lines[i];
+    if (line === void 0) continue;
+    if (/^\S/.test(line)) {
+      inNodeSection = line.startsWith("artifact:") || line.startsWith("process:");
+      continue;
+    }
+    if (!inNodeSection) continue;
+    const m = /^( {2})(\S[^:]*)\s*:/.exec(line);
+    if (!m) continue;
+    const id = m[2] ?? "";
+    if (!id) continue;
+    const lineNum = i + 1;
+    const col = 3;
+    result.set(id, {
+      start: { line: lineNum, column: col, offset: 0 },
+      end: { line: lineNum, column: col + id.length, offset: 0 }
+    });
+  }
+  return result;
+}
+function loadFrontmatter(source) {
+  if (!source.startsWith("---")) {
+    return {
+      frontmatter: null,
+      body: source,
+      bodyStartLine: 1,
+      diagnostics: []
+    };
+  }
+  const firstNl = source.indexOf("\n");
+  let closingLineStart = -1;
+  let closingLineEnd = -1;
+  let lineNum = 2;
+  if (firstNl !== -1) {
+    let lineStart = firstNl + 1;
+    while (lineStart <= source.length) {
+      const nl = source.indexOf("\n", lineStart);
+      const lineEnd = nl === -1 ? source.length : nl;
+      if (source.slice(lineStart, lineEnd).trimEnd() === "---") {
+        closingLineStart = lineStart;
+        closingLineEnd = lineEnd;
+        break;
+      }
+      if (nl === -1) break;
+      lineStart = nl + 1;
+      lineNum++;
+    }
+  }
+  if (closingLineStart === -1) {
+    const diag = {
+      severity: "error",
+      code: "FM001",
+      message: "Unclosed front matter: missing closing ---",
+      range: {
+        start: { line: 1, column: 1, offset: 0 },
+        end: { line: 1, column: 4, offset: 3 }
+      }
+    };
+    return {
+      frontmatter: null,
+      body: source,
+      bodyStartLine: 1,
+      diagnostics: [diag]
+    };
+  }
+  const yamlText = closingLineStart > firstNl + 1 ? source.slice(firstNl + 1, closingLineStart - 1) : "";
+  const body = closingLineEnd === source.length ? "" : source.slice(closingLineEnd + 1);
+  const bodyStartLine = lineNum + 1;
+  const diagnostics = [];
+  let frontmatter = null;
+  try {
+    const parsed = parseYaml(yamlText);
+    if (parsed != null && typeof parsed === "object") {
+      frontmatter = parsed;
+    }
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    diagnostics.push({
+      severity: "error",
+      code: "FM002",
+      message: `Invalid YAML in front matter: ${msg}`,
+      range: {
+        start: { line: 2, column: 1, offset: 4 },
+        end: { line: 2, column: 1, offset: 4 }
+      }
+    });
+  }
+  return { frontmatter, body, bodyStartLine, diagnostics };
+}
+
+// src/graph.ts
+function buildGraph(edges, nodeKinds) {
+  const nodes = new Map(nodeKinds);
+  const primaryEdges = [];
+  const feedbackEdges = [];
+  for (const edge of edges) {
+    if (edge.kind === "input") {
+      if (!nodes.has(edge.artifact)) nodes.set(edge.artifact, "artifact");
+      if (!nodes.has(edge.process)) nodes.set(edge.process, "process");
+      primaryEdges.push({
+        from: edge.artifact,
+        to: edge.process,
+        kind: "input"
+      });
+    } else if (edge.kind === "output") {
+      if (!nodes.has(edge.process)) nodes.set(edge.process, "process");
+      if (!nodes.has(edge.artifact)) nodes.set(edge.artifact, "artifact");
+      primaryEdges.push({
+        from: edge.process,
+        to: edge.artifact,
+        kind: "output"
+      });
+    } else {
+      if (!nodes.has(edge.artifact)) nodes.set(edge.artifact, "artifact");
+      if (!nodes.has(edge.process)) nodes.set(edge.process, "process");
+      feedbackEdges.push({ artifact: edge.artifact, process: edge.process });
+    }
+  }
+  return { nodes, primaryEdges, feedbackEdges };
+}
+
+// src/lexer.ts
+var ID_PATTERN = /[\p{L}\p{N}_][\p{L}\p{N}_-]*/u;
+var BARE_ID_RE = /[\p{L}\p{N}]/u;
+function lex(source) {
+  const tokens = [];
+  const diagnostics = [];
+  let pos = 0;
+  let line = 1;
+  let column = 1;
+  function currentPos() {
+    return { line, column, offset: pos };
+  }
+  function advance(count = 1) {
+    let result = "";
+    for (let i = 0; i < count; i++) {
+      if (pos >= source.length) break;
+      const cp = source.codePointAt(pos);
+      const charLen = cp > 65535 ? 2 : 1;
+      const ch = source.slice(pos, pos + charLen);
+      result += ch;
+      if (ch === "\n") {
+        line++;
+        column = 1;
+      } else {
+        column++;
+      }
+      pos += charLen;
+    }
+    return result;
+  }
+  function peek(offset = 0) {
+    let p = pos;
+    for (let i = 0; i < offset; i++) {
+      if (p >= source.length) return "";
+      p += source.codePointAt(p) > 65535 ? 2 : 1;
+    }
+    if (p >= source.length) return "";
+    const cp = source.codePointAt(p);
+    return cp > 65535 ? source.slice(p, p + 2) : source[p];
+  }
+  function makeToken(type, value, raw, start, end) {
+    return { type, value, raw, start, end };
+  }
+  while (pos < source.length) {
+    const ch = peek();
+    if (ch === " " || ch === "	" || ch === "\r") {
+      advance();
+      continue;
+    }
+    if (ch === "\n") {
+      const start = currentPos();
+      advance();
+      tokens.push(makeToken("NEWLINE", "\n", "\n", start, currentPos()));
+      continue;
+    }
+    if (ch === "#") {
+      const start = currentPos();
+      let raw = "";
+      while (pos < source.length && peek() !== "\n") raw += advance();
+      tokens.push(makeToken("COMMENT", raw, raw, start, currentPos()));
+      continue;
+    }
+    if (ch === ">" && peek(1) === ">" && peek(2) === "?") {
+      const start = currentPos();
+      advance(3);
+      tokens.push(
+        makeToken("ARROW_FEEDBACK", ">>?", ">>?", start, currentPos())
+      );
+      continue;
+    }
+    if (ch === ">" && peek(1) === ">") {
+      const start = currentPos();
+      advance(2);
+      tokens.push(makeToken("ARROW_INPUT", ">>", ">>", start, currentPos()));
+      continue;
+    }
+    if (ch === "-" && peek(1) === ">") {
+      const start = currentPos();
+      advance(2);
+      tokens.push(makeToken("ARROW_OUTPUT", "->", "->", start, currentPos()));
+      continue;
+    }
+    if (ch === "[") {
+      const s = currentPos();
+      advance();
+      tokens.push(makeToken("LBRACKET", "[", "[", s, currentPos()));
+      continue;
+    }
+    if (ch === "]") {
+      const s = currentPos();
+      advance();
+      tokens.push(makeToken("RBRACKET", "]", "]", s, currentPos()));
+      continue;
+    }
+    if (ch === ",") {
+      const s = currentPos();
+      advance();
+      tokens.push(makeToken("COMMA", ",", ",", s, currentPos()));
+      continue;
+    }
+    if (ch === ";") {
+      const s = currentPos();
+      advance();
+      tokens.push(makeToken("SEMICOLON", ";", ";", s, currentPos()));
+      continue;
+    }
+    if (ch === '"') {
+      const start = currentPos();
+      advance();
+      let value = "";
+      let raw = '"';
+      let closed = false;
+      while (pos < source.length) {
+        const c = peek();
+        if (c === '"') {
+          advance();
+          raw += '"';
+          closed = true;
+          break;
+        }
+        if (c === "\n") break;
+        if (c === "\\") {
+          advance();
+          raw += "\\";
+          const esc = peek();
+          if (esc === '"') {
+            value += '"';
+            raw += '"';
+            advance();
+          } else if (esc === "\\") {
+            value += "\\";
+            raw += "\\";
+            advance();
+          } else if (esc === "n") {
+            value += "\n";
+            raw += "n";
+            advance();
+          } else if (esc === "t") {
+            value += "	";
+            raw += "t";
+            advance();
+          } else {
+            value += `\\${esc}`;
+            raw += esc;
+            advance();
+          }
+        } else {
+          value += c;
+          raw += c;
+          advance();
+        }
+      }
+      if (!closed) {
+        diagnostics.push({
+          severity: "error",
+          code: "L001",
+          message: "Unclosed quoted identifier",
+          range: { start, end: currentPos() }
+        });
+      }
+      tokens.push(makeToken("ID", value, raw, start, currentPos()));
+      continue;
+    }
+    if (isBareIdChar(ch)) {
+      const start = currentPos();
+      let value = "";
+      while (pos < source.length) {
+        const c = peek();
+        if (c === ">" && peek(1) === ">") break;
+        if (c === "-" && peek(1) === ">") break;
+        if (!isBareIdChar(c)) break;
+        value += c;
+        advance();
+      }
+      if (value.length > 0) {
+        tokens.push(makeToken("ID", value, value, start, currentPos()));
+        continue;
+      }
+    }
+    const errStart = currentPos();
+    const unknown = advance();
+    diagnostics.push({
+      severity: "error",
+      code: "L002",
+      message: `Unexpected character: ${JSON.stringify(unknown)}`,
+      range: { start: errStart, end: currentPos() }
+    });
+  }
+  tokens.push(makeToken("EOF", "", "", currentPos(), currentPos()));
+  return { tokens, diagnostics };
+}
+function isBareIdChar(ch) {
+  if (ch === "_" || ch === "-") return true;
+  return BARE_ID_RE.test(ch);
+}
+
+// src/position.ts
+function zeroPos() {
+  return { line: 1, column: 1, offset: 0 };
+}
+function zeroRange() {
+  return { start: zeroPos(), end: zeroPos() };
+}
+
+// src/normalizer.ts
+function edgeKey(edge) {
+  return edge.kind === "output" ? `output\0${edge.process}\0${edge.artifact}` : `${edge.kind}\0${edge.artifact}\0${edge.process}`;
+}
+function normalize(doc, fm) {
+  const diagnostics = [];
+  const rawEdges = [];
+  const seenEdges = /* @__PURE__ */ new Set();
+  const nodeKinds = /* @__PURE__ */ new Map();
+  const declaredNodes = /* @__PURE__ */ new Set();
+  const edgeNodes = /* @__PURE__ */ new Set();
+  for (const id of Object.keys(fm?.artifact ?? {})) {
+    nodeKinds.set(id, "artifact");
+  }
+  for (const id of Object.keys(fm?.group ?? {})) {
+    if (!nodeKinds.has(id)) nodeKinds.set(id, "group");
+  }
+  for (const id of Object.keys(fm?.process ?? {})) {
+    if (nodeKinds.has(id)) {
+      diagnostics.push({
+        severity: "error",
+        code: "N001",
+        message: `'${id}' declared as both artifact and process in front matter`,
+        range: zeroRange()
+      });
+    } else {
+      nodeKinds.set(id, "process");
+    }
+  }
+  function inferKind(id, kind) {
+    const existing = nodeKinds.get(id);
+    if (existing === void 0) {
+      nodeKinds.set(id, kind);
+      return;
+    }
+    if (existing !== kind) {
+      diagnostics.push({
+        severity: "error",
+        code: "N002",
+        message: `'${id}' used as both artifact and process`,
+        range: zeroRange()
+      });
+    }
+  }
+  function addEdge(edge) {
+    const key = edgeKey(edge);
+    if (seenEdges.has(key)) {
+      diagnostics.push({
+        severity: "warning",
+        code: "N003",
+        message: "Duplicate edge",
+        range: zeroRange()
+      });
+      return;
+    }
+    seenEdges.add(key);
+    rawEdges.push(edge);
+    if (edge.kind === "output") {
+      edgeNodes.add(edge.process);
+      edgeNodes.add(edge.artifact);
+    } else {
+      edgeNodes.add(edge.artifact);
+      edgeNodes.add(edge.process);
+    }
+  }
+  function ids(expr) {
+    return expr.ids.map((i) => i.value);
+  }
+  function addEdgesFor(kind, artifactIds, proc) {
+    inferKind(proc, "process");
+    for (const a of artifactIds) {
+      inferKind(a, "artifact");
+      addEdge(
+        kind === "output" ? { kind, process: proc, artifact: a } : { kind, artifact: a, process: proc }
+      );
+    }
+  }
+  function processStmt(stmt) {
+    switch (stmt.type) {
+      case "chain": {
+        let currentArtifacts = ids(stmt.head);
+        for (const seg of stmt.segments) {
+          const proc = seg.process.value;
+          addEdgesFor(
+            seg.op === ">>" ? "input" : "feedback",
+            currentArtifacts,
+            proc
+          );
+          if (seg.output !== null) {
+            const outArtifacts = ids(seg.output);
+            addEdgesFor("output", outArtifacts, proc);
+            currentArtifacts = outArtifacts;
+          }
+        }
+        break;
+      }
+      case "input-edge":
+        addEdgesFor("input", ids(stmt.artifact), stmt.process.value);
+        break;
+      case "feedback-edge":
+        addEdgesFor("feedback", ids(stmt.artifact), stmt.process.value);
+        break;
+      case "output-edge":
+        addEdgesFor("output", ids(stmt.artifact), stmt.process.value);
+        break;
+      case "node-decl": {
+        const id = stmt.id.value;
+        declaredNodes.add(id);
+        if (!nodeKinds.has(id)) nodeKinds.set(id, "artifact");
+        break;
+      }
+    }
+  }
+  for (const stmt of doc.statements) processStmt(stmt);
+  const isolatedNodes = /* @__PURE__ */ new Set();
+  for (const id of declaredNodes) {
+    if (!edgeNodes.has(id)) isolatedNodes.add(id);
+  }
+  for (const [id, kind] of nodeKinds) {
+    if (kind !== "group" && !edgeNodes.has(id) && !isolatedNodes.has(id))
+      isolatedNodes.add(id);
+  }
+  return { edges: rawEdges, nodeKinds, isolatedNodes, diagnostics };
+}
+
+// src/parser.ts
+function parseTokens(tokens) {
+  const diagnostics = [];
+  let pos = 0;
+  function peek(offset = 0) {
+    const idx = pos + offset;
+    return tokens[Math.min(idx, tokens.length - 1)];
+  }
+  function advance() {
+    const t = tokens[pos];
+    if (pos < tokens.length - 1) pos++;
+    return t;
+  }
+  function skipSeparators() {
+    while (peek().type === "NEWLINE" || peek().type === "SEMICOLON" || peek().type === "COMMENT")
+      advance();
+  }
+  function scanContinuation(start) {
+    let i = start;
+    let consecutive = 0;
+    let maxConsecutive = 0;
+    while (i < tokens.length) {
+      const t = tokens[i]?.type;
+      if (t === "NEWLINE") {
+        consecutive++;
+        if (consecutive > maxConsecutive) maxConsecutive = consecutive;
+      } else if (t === "COMMENT") {
+        consecutive = 0;
+      } else {
+        break;
+      }
+      i++;
+    }
+    return { next: i, blankLine: maxConsecutive > 1 };
+  }
+  function tryContinuation(...ops) {
+    const { next, blankLine } = scanContinuation(pos);
+    if (next > pos && next < tokens.length && !blankLine && ops.includes(tokens[next].type)) {
+      pos = next;
+      return true;
+    }
+    return false;
+  }
+  function isOutputEdgeStart() {
+    if (peek().type !== "ID") return false;
+    const { next, blankLine } = scanContinuation(pos + 1);
+    return !blankLine && next < tokens.length && tokens[next]?.type === "ARROW_OUTPUT";
+  }
+  function isNodeDeclStart() {
+    if (peek().type !== "ID") return false;
+    const afterId = pos + 1;
+    if (afterId >= tokens.length) return true;
+    const t = tokens[afterId]?.type;
+    if (t === "ARROW_INPUT" || t === "ARROW_FEEDBACK" || t === "ARROW_OUTPUT")
+      return false;
+    if (t === "NEWLINE" || t === "COMMENT") {
+      const { next, blankLine } = scanContinuation(afterId);
+      if (!blankLine && next < tokens.length) {
+        const nt = tokens[next]?.type;
+        if (nt === "ARROW_INPUT" || nt === "ARROW_FEEDBACK" || nt === "ARROW_OUTPUT")
+          return false;
+      }
+    }
+    return t === "NEWLINE" || t === "SEMICOLON" || t === "EOF" || t === "COMMENT";
+  }
+  function parseId() {
+    const t = peek();
+    if (t.type !== "ID") return null;
+    advance();
+    return {
+      type: "id",
+      value: t.value,
+      raw: t.raw,
+      start: t.start,
+      end: t.end
+    };
+  }
+  function parseArtifactExpr() {
+    const t = peek();
+    if (t.type === "LBRACKET") {
+      const start = t.start;
+      advance();
+      skipSeparators();
+      const ids = [];
+      const first = parseId();
+      if (!first) {
+        diagnostics.push({
+          severity: "error",
+          code: "P002",
+          message: "Expected identifier in artifact set",
+          range: { start: peek().start, end: peek().end }
+        });
+        while (peek().type !== "RBRACKET" && peek().type !== "EOF") advance();
+        const end = peek().end;
+        if (peek().type === "RBRACKET") advance();
+        return { type: "artifact-expr", ids: [], start, end };
+      }
+      ids.push(first);
+      while (peek().type === "COMMA") {
+        advance();
+        skipSeparators();
+        const id2 = parseId();
+        if (!id2) {
+          diagnostics.push({
+            severity: "error",
+            code: "P003",
+            message: "Expected identifier after comma in set",
+            range: { start: peek().start, end: peek().end }
+          });
+          break;
+        }
+        ids.push(id2);
+      }
+      skipSeparators();
+      const rb = peek();
+      if (rb.type === "RBRACKET") {
+        advance();
+        return { type: "artifact-expr", ids, start, end: rb.end };
+      }
+      diagnostics.push({
+        severity: "error",
+        code: "P011",
+        message: "Expected ] to close artifact set",
+        range: { start: rb.start, end: rb.end }
+      });
+      return { type: "artifact-expr", ids, start, end: rb.start };
+    }
+    const id = parseId();
+    if (!id) return null;
+    return { type: "artifact-expr", ids: [id], start: id.start, end: id.end };
+  }
+  function skipToStatementEnd() {
+    while (peek().type !== "NEWLINE" && peek().type !== "SEMICOLON" && peek().type !== "EOF")
+      advance();
+  }
+  function parseStatement() {
+    if (isNodeDeclStart()) {
+      const id = parseId();
+      return {
+        type: "node-decl",
+        id,
+        start: id.start,
+        end: id.end
+      };
+    }
+    if (isOutputEdgeStart()) {
+      const processId2 = parseId();
+      tryContinuation("ARROW_OUTPUT");
+      advance();
+      const artifact = parseArtifactExpr();
+      if (!artifact) {
+        diagnostics.push({
+          severity: "error",
+          code: "P004",
+          message: "Expected artifact expression after ->",
+          range: { start: peek().start, end: peek().end }
+        });
+        return null;
+      }
+      return {
+        type: "output-edge",
+        process: processId2,
+        artifact,
+        start: processId2.start,
+        end: artifact.end
+      };
+    }
+    const head = parseArtifactExpr();
+    if (!head) {
+      diagnostics.push({
+        severity: "error",
+        code: "P001",
+        message: `Unexpected token: ${peek().type} (${peek().raw})`,
+        range: { start: peek().start, end: peek().end }
+      });
+      return null;
+    }
+    tryContinuation("ARROW_INPUT", "ARROW_FEEDBACK");
+    const opToken = peek();
+    if (opToken.type !== "ARROW_INPUT" && opToken.type !== "ARROW_FEEDBACK") {
+      diagnostics.push({
+        severity: "error",
+        code: "P005",
+        message: `Expected >> or >>? after artifact, got ${opToken.type}`,
+        range: { start: opToken.start, end: opToken.end }
+      });
+      return null;
+    }
+    const op = opToken.type === "ARROW_INPUT" ? ">>" : ">>?";
+    advance();
+    const processId = parseId();
+    if (!processId) {
+      diagnostics.push({
+        severity: "error",
+        code: "P006",
+        message: "Expected process identifier",
+        range: { start: peek().start, end: peek().end }
+      });
+      return null;
+    }
+    tryContinuation("ARROW_OUTPUT");
+    if (peek().type !== "ARROW_OUTPUT") {
+      if (op === ">>") {
+        return {
+          type: "input-edge",
+          artifact: head,
+          process: processId,
+          start: head.start,
+          end: processId.end
+        };
+      } else {
+        return {
+          type: "feedback-edge",
+          artifact: head,
+          process: processId,
+          start: head.start,
+          end: processId.end
+        };
+      }
+    }
+    advance();
+    const firstOutput = parseArtifactExpr();
+    if (!firstOutput) {
+      diagnostics.push({
+        severity: "error",
+        code: "P007",
+        message: "Expected artifact expression after -> in chain",
+        range: { start: peek().start, end: peek().end }
+      });
+      return null;
+    }
+    const segments = [
+      { op, process: processId, output: firstOutput }
+    ];
+    while (true) {
+      tryContinuation("ARROW_INPUT", "ARROW_FEEDBACK");
+      if (peek().type !== "ARROW_INPUT" && peek().type !== "ARROW_FEEDBACK")
+        break;
+      const segOp = peek().type === "ARROW_INPUT" ? ">>" : ">>?";
+      advance();
+      const segProcess = parseId();
+      if (!segProcess) {
+        diagnostics.push({
+          severity: "error",
+          code: "P008",
+          message: "Expected process identifier in chain continuation",
+          range: { start: peek().start, end: peek().end }
+        });
+        skipToStatementEnd();
+        break;
+      }
+      tryContinuation("ARROW_OUTPUT");
+      if (peek().type !== "ARROW_OUTPUT") {
+        segments.push({ op: segOp, process: segProcess, output: null });
+        break;
+      }
+      advance();
+      const segOutput = parseArtifactExpr();
+      if (!segOutput) {
+        diagnostics.push({
+          severity: "error",
+          code: "P010",
+          message: "Expected artifact expression in chain continuation",
+          range: { start: peek().start, end: peek().end }
+        });
+        skipToStatementEnd();
+        break;
+      }
+      segments.push({ op: segOp, process: segProcess, output: segOutput });
+    }
+    const last = segments[segments.length - 1];
+    return {
+      type: "chain",
+      head,
+      segments,
+      start: head.start,
+      end: last.output?.end ?? last.process.end
+    };
+  }
+  const statements = [];
+  skipSeparators();
+  while (peek().type !== "EOF") {
+    const stmt = parseStatement();
+    if (stmt) {
+      statements.push(stmt);
+    } else {
+      skipToStatementEnd();
+    }
+    skipSeparators();
+  }
+  return { document: { type: "document", statements }, diagnostics };
+}
+
+// src/sorter.ts
+function sortIsolated(isolatedNodes) {
+  return [...isolatedNodes].sort();
+}
+function sortEdges(edges, graph) {
+  const parent = /* @__PURE__ */ new Map();
+  function find(x) {
+    if (!parent.has(x)) parent.set(x, x);
+    const p = parent.get(x) ?? x;
+    if (p === x) return x;
+    const root = find(p);
+    parent.set(x, root);
+    return root;
+  }
+  function union(x, y) {
+    const rx = find(x), ry = find(y);
+    if (rx !== ry) parent.set(rx, ry);
+  }
+  for (const e of graph.primaryEdges) union(e.from, e.to);
+  const componentMin = /* @__PURE__ */ new Map();
+  for (const nodeId of graph.nodes.keys()) {
+    const root = find(nodeId);
+    const cur = componentMin.get(root);
+    if (cur === void 0 || nodeId < cur) componentMin.set(root, nodeId);
+  }
+  function componentKey(nodeId) {
+    return componentMin.get(find(nodeId)) ?? nodeId;
+  }
+  const inDegree = /* @__PURE__ */ new Map();
+  const adjacency = /* @__PURE__ */ new Map();
+  for (const id of graph.nodes.keys()) {
+    inDegree.set(id, 0);
+    adjacency.set(id, []);
+  }
+  for (const e of graph.primaryEdges) {
+    inDegree.set(e.to, (inDegree.get(e.to) ?? 0) + 1);
+    adjacency.get(e.from)?.push(e.to);
+  }
+  const ranks = /* @__PURE__ */ new Map();
+  const queue = [];
+  for (const [id, deg] of inDegree) {
+    if (deg === 0) {
+      ranks.set(id, 0);
+      queue.push(id);
+    }
+  }
+  for (let head = 0; head < queue.length; head++) {
+    const u = queue[head];
+    const ru = ranks.get(u);
+    for (const v of adjacency.get(u)) {
+      const rv = ranks.get(v) ?? -1;
+      if (ru + 1 > rv) ranks.set(v, ru + 1);
+      const remaining = inDegree.get(v) - 1;
+      inDegree.set(v, remaining);
+      if (remaining === 0) queue.push(v);
+    }
+  }
+  for (const id of graph.nodes.keys()) {
+    if (!ranks.has(id)) ranks.set(id, 0);
+  }
+  function edgeRank(e) {
+    if (e.kind === "input") return ranks.get(e.artifact) ?? 0;
+    if (e.kind === "feedback") return ranks.get(e.process) ?? 0;
+    return ranks.get(e.process) ?? 0;
+  }
+  function edgeKindOrder(e) {
+    if (e.kind === "input") return 0;
+    if (e.kind === "feedback") return 1;
+    return 2;
+  }
+  function edgeLexKey(e) {
+    return e.kind === "output" ? `${e.process}\0${e.artifact}` : `${e.artifact}\0${e.process}`;
+  }
+  const compKeys = /* @__PURE__ */ new Map();
+  for (const e of edges) {
+    const ref = e.kind === "output" ? e.process : e.artifact;
+    compKeys.set(e, componentKey(ref));
+  }
+  return [...edges].sort((a, b) => {
+    const ck = compKeys.get(a).localeCompare(compKeys.get(b));
+    if (ck !== 0) return ck;
+    const rk = edgeRank(a) - edgeRank(b);
+    if (rk !== 0) return rk;
+    const kk = edgeKindOrder(a) - edgeKindOrder(b);
+    if (kk !== 0) return kk;
+    return edgeLexKey(a).localeCompare(edgeLexKey(b));
+  });
+}
+
+// src/types/frontmatter.ts
+var STATUS_VALUES = ["done", "wip", "todo", "blocked"];
+var STYLE_ATTRS = [
+  "fillcolor",
+  "color",
+  "fontcolor",
+  "style",
+  "penwidth"
+];
+
+// src/validator.ts
+var STATUS_SET = new Set(STATUS_VALUES);
+var STYLE_ATTR_SET = new Set(STYLE_ATTRS);
+function validate(edges, nodeKinds, fm, options) {
+  const diagnostics = [];
+  const nodeRanges = options?.source ? findFrontmatterNodeRanges(options.source) : /* @__PURE__ */ new Map();
+  const artifactGenerators = /* @__PURE__ */ new Map();
+  for (const e of edges) {
+    if (e.kind === "output") {
+      const gens = artifactGenerators.get(e.artifact) ?? [];
+      gens.push(e.process);
+      artifactGenerators.set(e.artifact, gens);
+    }
+  }
+  for (const [artifact, processes] of artifactGenerators) {
+    if (processes.length > 1) {
+      diagnostics.push({
+        severity: "error",
+        code: "V001",
+        message: `'${artifact}' generated by multiple processes: ${processes.join(", ")}`,
+        range: zeroRange()
+      });
+    }
+  }
+  const processInputCount = /* @__PURE__ */ new Map();
+  const processOutputCount = /* @__PURE__ */ new Map();
+  for (const e of edges) {
+    if (!processInputCount.has(e.process)) processInputCount.set(e.process, 0);
+    if (!processOutputCount.has(e.process))
+      processOutputCount.set(e.process, 0);
+    if (e.kind === "input" || e.kind === "feedback") {
+      processInputCount.set(
+        e.process,
+        (processInputCount.get(e.process) ?? 0) + 1
+      );
+    } else {
+      processOutputCount.set(
+        e.process,
+        (processOutputCount.get(e.process) ?? 0) + 1
+      );
+    }
+  }
+  for (const [id, count] of processInputCount) {
+    if (count === 0)
+      diagnostics.push({
+        severity: "error",
+        code: "V002",
+        message: `Process '${id}' has no inputs`,
+        range: zeroRange()
+      });
+  }
+  for (const [id, count] of processOutputCount) {
+    if (count === 0)
+      diagnostics.push({
+        severity: "error",
+        code: "V003",
+        message: `Process '${id}' has no outputs`,
+        range: zeroRange()
+      });
+  }
+  for (const pid of Object.keys(fm?.process ?? {})) {
+    if (!processInputCount.has(pid)) {
+      diagnostics.push({
+        severity: "error",
+        code: "V020",
+        message: `Process '${pid}' is declared but has no edges (orphaned process)`,
+        range: zeroRange()
+      });
+    }
+  }
+  const artifactMeta = fm?.artifact ?? {};
+  const nodesWithEdges = /* @__PURE__ */ new Set();
+  for (const e of edges) {
+    if (e.kind === "input" || e.kind === "feedback") {
+      nodesWithEdges.add(e.artifact);
+      nodesWithEdges.add(e.process);
+    } else {
+      nodesWithEdges.add(e.process);
+      nodesWithEdges.add(e.artifact);
+    }
+  }
+  for (const [artifactId, meta] of Object.entries(artifactMeta)) {
+    for (const partId of meta.parts ?? []) {
+      if (nodeKinds.get(partId) === "process") {
+        diagnostics.push({
+          severity: "error",
+          code: "V004",
+          message: `Parts member '${partId}' of '${artifactId}' is a process`,
+          range: zeroRange()
+        });
+      }
+      if (partId === artifactId) {
+        diagnostics.push({
+          severity: "error",
+          code: "V005",
+          message: `'${artifactId}' cannot include itself in parts`,
+          range: zeroRange()
+        });
+      }
+      if (!nodesWithEdges.has(partId) && nodeKinds.get(partId) !== "process") {
+        diagnostics.push({
+          severity: "warning",
+          code: "W001",
+          message: `Parts member '${partId}' of '${artifactId}' has no edges`,
+          range: zeroRange()
+        });
+      }
+    }
+    if (meta.status !== void 0 && !STATUS_SET.has(meta.status)) {
+      diagnostics.push({
+        severity: "error",
+        code: "V007",
+        message: `Invalid status '${meta.status}' on artifact '${artifactId}'. Allowed: ${STATUS_VALUES.join(", ")}`,
+        range: zeroRange()
+      });
+    }
+  }
+  const checkIndices = (entries, kind) => {
+    const seen = /* @__PURE__ */ new Map();
+    for (const [id, meta] of Object.entries(entries)) {
+      const idx = meta.index;
+      if (idx === void 0) continue;
+      if (typeof idx !== "number" || !Number.isInteger(idx) || idx < 1) {
+        diagnostics.push({
+          severity: "error",
+          code: "V029",
+          message: `Invalid index '${String(idx)}' on ${kind} '${id}'. Must be a positive integer`,
+          range: nodeRanges.get(id) ?? zeroRange()
+        });
+        continue;
+      }
+      const prev = seen.get(idx);
+      if (prev !== void 0) {
+        diagnostics.push({
+          severity: "warning",
+          code: "W004",
+          message: `Duplicate index ${idx} on ${kind} '${id}' (also on '${prev}')`,
+          range: nodeRanges.get(id) ?? zeroRange()
+        });
+      } else {
+        seen.set(idx, id);
+      }
+    }
+  };
+  checkIndices(fm?.artifact ?? {}, "artifact");
+  checkIndices(fm?.process ?? {}, "process");
+  for (const [key, style] of Object.entries(fm?.statusStyles ?? {})) {
+    if (!STATUS_SET.has(key)) {
+      diagnostics.push({
+        severity: "error",
+        code: "V008",
+        message: `Invalid statusStyles key '${key}'. Allowed: ${STATUS_VALUES.join(", ")}`,
+        range: zeroRange()
+      });
+    }
+    for (const attr of Object.keys(style ?? {})) {
+      if (!STYLE_ATTR_SET.has(attr)) {
+        diagnostics.push({
+          severity: "error",
+          code: "V009",
+          message: `Invalid style attribute '${attr}' in statusStyles.${key}. Allowed: ${STYLE_ATTRS.join(", ")}`,
+          range: zeroRange()
+        });
+      }
+    }
+  }
+  for (const [key, meta] of Object.entries(fm?.tag ?? {})) {
+    for (const attr of Object.keys(meta?.style ?? {})) {
+      if (!STYLE_ATTR_SET.has(attr)) {
+        diagnostics.push({
+          severity: "error",
+          code: "V009",
+          message: `Invalid style attribute '${attr}' in tag.${key}.style. Allowed: ${STYLE_ATTRS.join(", ")}`,
+          range: zeroRange()
+        });
+      }
+    }
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const inStack = /* @__PURE__ */ new Set();
+  const path = [];
+  function detectCycle(id) {
+    if (inStack.has(id)) {
+      diagnostics.push({
+        severity: "error",
+        code: "V006",
+        message: `Cycle in parts: ${[...path, id].join(" \u2192 ")}`,
+        range: zeroRange()
+      });
+      return;
+    }
+    if (visited.has(id)) return;
+    visited.add(id);
+    inStack.add(id);
+    path.push(id);
+    for (const part of artifactMeta[id]?.parts ?? []) detectCycle(part);
+    path.pop();
+    inStack.delete(id);
+  }
+  for (const id of Object.keys(artifactMeta)) detectCycle(id);
+  const primaryAdj = /* @__PURE__ */ new Map();
+  for (const e of edges) {
+    if (e.kind === "input") {
+      const adj = primaryAdj.get(e.artifact) ?? [];
+      adj.push(e.process);
+      primaryAdj.set(e.artifact, adj);
+    } else if (e.kind === "output") {
+      const adj = primaryAdj.get(e.process) ?? [];
+      adj.push(e.artifact);
+      primaryAdj.set(e.process, adj);
+    }
+  }
+  {
+    let dfsV0102 = function(id) {
+      if (color.get(id) === "gray") return true;
+      if (color.get(id) === "black") return false;
+      color.set(id, "gray");
+      for (const neighbor of primaryAdj.get(id) ?? []) {
+        if (dfsV0102(neighbor)) {
+          if (!cycleReported) {
+            cycleReported = true;
+            diagnostics.push({
+              severity: "error",
+              code: "V010",
+              message: `Primary graph contains a cycle involving '${id}' \u2192 '${neighbor}'`,
+              range: zeroRange()
+            });
+          }
+          color.set(id, "black");
+          return false;
+        }
+      }
+      color.set(id, "black");
+      return false;
+    };
+    var dfsV010 = dfsV0102;
+    const color = /* @__PURE__ */ new Map();
+    const allNodes = /* @__PURE__ */ new Set();
+    for (const e of edges) {
+      if (e.kind !== "feedback") {
+        allNodes.add(e.kind === "output" ? e.process : e.artifact);
+        allNodes.add(e.kind === "output" ? e.artifact : e.process);
+      }
+    }
+    for (const n of allNodes) color.set(n, "white");
+    let cycleReported = false;
+    for (const n of allNodes) {
+      if (color.get(n) === "white") dfsV0102(n);
+    }
+  }
+  if (options?.strict) {
+    let primaryReachable2 = function(startProcess) {
+      const reachable = /* @__PURE__ */ new Set();
+      const queue = [startProcess];
+      while (queue.length > 0) {
+        const node = queue.shift();
+        for (const neighbor of primaryAdj.get(node) ?? []) {
+          if (!reachable.has(neighbor)) {
+            reachable.add(neighbor);
+            queue.push(neighbor);
+          }
+        }
+      }
+      return reachable;
+    };
+    var primaryReachable = primaryReachable2;
+    for (const e of edges) {
+      if (e.kind === "feedback") {
+        const reachable = primaryReachable2(e.process);
+        if (!reachable.has(e.artifact)) {
+          diagnostics.push({
+            severity: "error",
+            code: "V011",
+            message: `Feedback artifact '${e.artifact}' is not reachable from process '${e.process}' in the primary graph`,
+            range: zeroRange()
+          });
+        }
+      }
+    }
+  }
+  const processMeta = fm?.process ?? {};
+  for (const [pid, meta] of Object.entries(processMeta)) {
+    const m = meta;
+    if (m.criteria !== void 0) {
+      diagnostics.push({
+        severity: "error",
+        code: "V012",
+        message: `'criteria' is not allowed on process '${pid}'`,
+        range: zeroRange()
+      });
+    }
+    if (m.location !== void 0) {
+      diagnostics.push({
+        severity: "error",
+        code: "V013",
+        message: `'location' is not allowed on process '${pid}'`,
+        range: zeroRange()
+      });
+    }
+    if (m.revises !== void 0) {
+      diagnostics.push({
+        severity: "error",
+        code: "V015",
+        message: `'revises' is not allowed on process '${pid}'`,
+        range: zeroRange()
+      });
+    }
+  }
+  for (const [aid, meta] of Object.entries(artifactMeta)) {
+    if (meta.criteria === void 0) {
+      diagnostics.push({
+        severity: options?.strict ? "error" : "warning",
+        code: "W002",
+        message: `Artifact '${aid}' has no 'criteria' field`,
+        range: nodeRanges.get(aid) ?? zeroRange()
+      });
+    }
+    if (meta.command !== void 0) {
+      diagnostics.push({
+        severity: "error",
+        code: "V014",
+        message: `'command' is not allowed on artifact '${aid}'`,
+        range: zeroRange()
+      });
+    }
+  }
+  const revisesTargets = /* @__PURE__ */ new Map();
+  for (const [aid, meta] of Object.entries(artifactMeta)) {
+    const target = meta.revises;
+    if (target === void 0 || target === null) continue;
+    if (typeof target !== "string") {
+      diagnostics.push({
+        severity: "error",
+        code: "V016",
+        message: `'revises' on artifact '${aid}' must be a string, got ${typeof target}`,
+        range: zeroRange()
+      });
+      continue;
+    }
+    if (target === aid) {
+      diagnostics.push({
+        severity: "error",
+        code: "V017",
+        message: `Artifact '${aid}' revises itself`,
+        range: zeroRange()
+      });
+      continue;
+    }
+    if (artifactMeta[target] === void 0) {
+      diagnostics.push({
+        severity: "error",
+        code: "V016",
+        message: `'revises' target '${target}' of artifact '${aid}' not found in this file`,
+        range: zeroRange()
+      });
+      continue;
+    }
+    revisesTargets.set(aid, target);
+  }
+  const revisedBy = /* @__PURE__ */ new Map();
+  for (const [aid, target] of revisesTargets) {
+    const arr = revisedBy.get(target) ?? [];
+    arr.push(aid);
+    revisedBy.set(target, arr);
+  }
+  for (const [target, revisors] of revisedBy) {
+    if (revisors.length > 1) {
+      diagnostics.push({
+        severity: "error",
+        code: "V018",
+        message: `Artifact '${target}' is revised by multiple artifacts: ${revisors.join(", ")}`,
+        range: zeroRange()
+      });
+    }
+  }
+  {
+    let dfsRevises2 = function(id) {
+      if (color.get(id) === "gray") return true;
+      if (color.get(id) === "black") return false;
+      color.set(id, "gray");
+      const target = revisesTargets.get(id);
+      if (target !== void 0 && dfsRevises2(target)) {
+        diagnostics.push({
+          severity: "error",
+          code: "V019",
+          message: `Cycle detected in 'revises' chain involving '${id}'`,
+          range: zeroRange()
+        });
+        color.set(id, "black");
+        return false;
+      }
+      color.set(id, "black");
+      return false;
+    };
+    var dfsRevises = dfsRevises2;
+    const color = /* @__PURE__ */ new Map();
+    for (const id of Object.keys(artifactMeta)) color.set(id, "white");
+    for (const id of Object.keys(artifactMeta)) {
+      if (color.get(id) === "white") dfsRevises2(id);
+    }
+  }
+  {
+    const processInputs = /* @__PURE__ */ new Map();
+    const processOutputs = /* @__PURE__ */ new Map();
+    for (const e of edges) {
+      if (e.kind === "input") {
+        const arr = processInputs.get(e.process) ?? [];
+        arr.push(e.artifact);
+        processInputs.set(e.process, arr);
+      } else if (e.kind === "output") {
+        const arr = processOutputs.get(e.process) ?? [];
+        arr.push(e.artifact);
+        processOutputs.set(e.process, arr);
+      }
+    }
+    for (const [pid, outputs] of processOutputs) {
+      const hasDoneOutput = outputs.some(
+        (aid) => artifactMeta[aid]?.status === "done"
+      );
+      if (!hasDoneOutput) continue;
+      for (const aid of processInputs.get(pid) ?? []) {
+        const status = artifactMeta[aid]?.status;
+        if (status !== void 0 && status !== "done") {
+          diagnostics.push({
+            severity: "warning",
+            code: "W003",
+            message: `Process '${pid}' outputs a 'done' artifact but input '${aid}' has status '${status}'`,
+            range: zeroRange()
+          });
+        }
+      }
+    }
+  }
+  for (const [id, meta] of Object.entries(fm?.artifact ?? {})) {
+    if (meta.subflow !== void 0) {
+      diagnostics.push({
+        severity: "error",
+        code: "V023",
+        message: `'subflow' is not allowed on artifact '${id}'`,
+        range: zeroRange()
+      });
+    }
+  }
+  for (const [pid, meta] of Object.entries(fm?.process ?? {})) {
+    if (meta.boundary !== void 0 && meta.subflow === void 0) {
+      diagnostics.push({
+        severity: "error",
+        code: "V024",
+        message: `'boundary' on process '${pid}' requires 'subflow'`,
+        range: zeroRange()
+      });
+    }
+  }
+  {
+    let dfsGroup2 = function(id) {
+      color.set(id, "gray");
+      const parent = groupMeta[id]?.parent;
+      if (parent !== void 0) {
+        if (color.get(parent) === "gray") {
+          diagnostics.push({
+            severity: "error",
+            code: "V025",
+            message: `Cycle detected in 'parent' chain involving group '${id}' \u2192 '${parent}'`,
+            range: zeroRange()
+          });
+          color.set(id, "black");
+          return true;
+        }
+        if (color.get(parent) === "white") {
+          if (dfsGroup2(parent)) {
+            color.set(id, "black");
+            return true;
+          }
+        }
+      }
+      color.set(id, "black");
+      return false;
+    };
+    var dfsGroup = dfsGroup2;
+    const groupMeta = fm?.group ?? {};
+    const color = /* @__PURE__ */ new Map();
+    for (const id of Object.keys(groupMeta)) color.set(id, "white");
+    for (const id of Object.keys(groupMeta)) {
+      if (color.get(id) === "white") dfsGroup2(id);
+    }
+  }
+  return diagnostics;
+}
+
+// src/meta.ts
+function resolveMeta(fm, kind, id) {
+  if (!fm) return void 0;
+  if (kind === "artifact") return fm.artifact?.[id];
+  if (kind === "group") return fm.group?.[id];
+  return fm.process?.[id];
+}
+
+// src/diff.ts
+function edgeKey2(from, to) {
+  return `${from} -> ${to}`;
+}
+function setDiff(lhs, rhs) {
+  return [...rhs].filter((x) => !lhs.has(x)).sort();
+}
+function stableStringify(value) {
+  if (value === void 0) return "undefined";
+  if (value === null) return "null";
+  if (typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) {
+    return `[${value.map(stableStringify).join(",")}]`;
+  }
+  const keys = Object.keys(value).sort();
+  const pairs = keys.map((k) => {
+    const v = value[k];
+    if (v === void 0) return null;
+    return `${JSON.stringify(k)}:${stableStringify(v)}`;
+  }).filter((p) => p !== null);
+  return `{${pairs.join(",")}}`;
+}
+function diffGraphs(a, b, fmA, fmB) {
+  const aNodes = new Set(a.nodes.keys());
+  const bNodes = new Set(b.nodes.keys());
+  const aEdges = new Set(a.primaryEdges.map((e) => edgeKey2(e.from, e.to)));
+  const bEdges = new Set(b.primaryEdges.map((e) => edgeKey2(e.from, e.to)));
+  const aFb = new Set(
+    a.feedbackEdges.map((e) => edgeKey2(e.artifact, e.process))
+  );
+  const bFb = new Set(
+    b.feedbackEdges.map((e) => edgeKey2(e.artifact, e.process))
+  );
+  const commonIds = [...aNodes].filter((id) => bNodes.has(id));
+  const changedNodes = [];
+  for (const id of commonIds) {
+    const kindA = a.nodes.get(id);
+    const kindB = b.nodes.get(id);
+    if (kindA !== kindB) {
+      changedNodes.push(id);
+      continue;
+    }
+    if (fmA != null && fmB != null && kindB != null) {
+      const metaA = resolveMeta(fmA, kindB, id);
+      const metaB = resolveMeta(fmB, kindB, id);
+      if (stableStringify(metaA) !== stableStringify(metaB)) {
+        changedNodes.push(id);
+      }
+    }
+  }
+  changedNodes.sort();
+  return {
+    addedNodes: setDiff(aNodes, bNodes),
+    removedNodes: setDiff(bNodes, aNodes),
+    changedNodes,
+    addedEdges: setDiff(aEdges, bEdges),
+    removedEdges: setDiff(bEdges, aEdges),
+    addedFeedback: setDiff(aFb, bFb),
+    removedFeedback: setDiff(bFb, aFb)
+  };
+}
+
+// src/reindex.ts
+function reindex(source, opts = {}) {
+  const { edges, graph, nodeKinds, frontmatter, diagnostics } = analyze(source);
+  if (diagnostics.some((d) => d.severity === "error")) {
+    return { output: source, changes: [], diagnostics };
+  }
+  const kindOf = (id) => nodeKinds.get(id) ?? "artifact";
+  const existingIndex = (id) => {
+    const meta = kindOf(id) === "process" ? frontmatter?.process?.[id] : frontmatter?.artifact?.[id];
+    return typeof meta?.index === "number" ? meta.index : void 0;
+  };
+  const order = [];
+  const seen = /* @__PURE__ */ new Set();
+  const push = (id) => {
+    if (!seen.has(id)) {
+      seen.add(id);
+      order.push(id);
+    }
+  };
+  for (const e of sortEdges(edges, graph)) {
+    if (e.kind === "input") {
+      push(e.artifact);
+      push(e.process);
+    } else if (e.kind === "output") {
+      push(e.process);
+      push(e.artifact);
+    }
+  }
+  const remaining = /* @__PURE__ */ new Set([
+    ...graph.nodes.keys(),
+    ...Object.keys(frontmatter?.artifact ?? {}),
+    ...Object.keys(frontmatter?.process ?? {})
+  ]);
+  for (const id of [...remaining].sort()) push(id);
+  const assigned = /* @__PURE__ */ new Map();
+  if (opts.renumber) {
+    const counter = {
+      artifact: 0,
+      process: 0,
+      group: 0
+    };
+    for (const id of order) {
+      const kind = kindOf(id);
+      counter[kind] += 1;
+      assigned.set(id, counter[kind]);
+    }
+  } else {
+    const next = {
+      artifact: 0,
+      process: 0,
+      group: 0
+    };
+    for (const id of order) {
+      const cur = existingIndex(id);
+      if (cur !== void 0) next[kindOf(id)] = Math.max(next[kindOf(id)], cur);
+    }
+    for (const id of order) {
+      const cur = existingIndex(id);
+      if (cur !== void 0) {
+        assigned.set(id, cur);
+        continue;
+      }
+      const kind = kindOf(id);
+      next[kind] += 1;
+      assigned.set(id, next[kind]);
+    }
+  }
+  const changes = [];
+  const writes = [];
+  for (const id of order) {
+    const to = assigned.get(id);
+    const from = existingIndex(id) ?? null;
+    if (from === to) continue;
+    const kind = kindOf(id);
+    changes.push({ kind, id, from, to });
+    writes.push({ kind, id, value: to });
+  }
+  const output = writes.length ? applyWrites(source, writes) : source;
+  return { output, changes, diagnostics };
+}
+function applyWrites(source, writes) {
+  const lines = source.split("\n");
+  const trailingNewline = source.endsWith("\n");
+  let open = -1;
+  let close = -1;
+  if (lines[0]?.trim() === "---") {
+    open = 0;
+    for (let i = 1; i < lines.length; i++) {
+      if (lines[i]?.trim() === "---") {
+        close = i;
+        break;
+      }
+    }
+  }
+  if (open === -1 || close === -1) {
+    const fm = buildFrontmatter(writes);
+    return `${fm}${source}`;
+  }
+  const yaml = lines.slice(open + 1, close);
+  for (const w of writes) setIndex(yaml, w);
+  const rebuilt = [...lines.slice(0, open + 1), ...yaml, ...lines.slice(close)];
+  let result = rebuilt.join("\n");
+  if (trailingNewline && !result.endsWith("\n")) result += "\n";
+  return result;
+}
+function buildFrontmatter(writes) {
+  const lines = ["---"];
+  for (const section of ["artifact", "process"]) {
+    const ws = writes.filter((w) => w.kind === section);
+    if (ws.length === 0) continue;
+    lines.push(`${section}:`);
+    for (const w of ws) {
+      lines.push(`  ${w.id}:`);
+      lines.push(`    index: ${w.value}`);
+    }
+  }
+  lines.push("---", "");
+  return lines.join("\n");
+}
+var indentOf = (line) => line.length - line.trimStart().length;
+function setIndex(yaml, w) {
+  const section = w.kind;
+  let sectionStart = -1;
+  for (let i = 0; i < yaml.length; i++) {
+    const line = yaml[i];
+    if (/^[^\s#]/.test(line) && line.replace(/:\s*$/, "") === section) {
+      sectionStart = i;
+      break;
+    }
+  }
+  if (sectionStart === -1) {
+    yaml.push(`${section}:`, `  ${w.id}:`, `    index: ${w.value}`);
+    return;
+  }
+  let sectionEnd = yaml.length;
+  for (let i = sectionStart + 1; i < yaml.length; i++) {
+    const line = yaml[i];
+    if (line.trim() !== "" && /^[^\s#]/.test(line)) {
+      sectionEnd = i;
+      break;
+    }
+  }
+  let sectionIndent = 2;
+  for (let i = sectionStart + 1; i < sectionEnd; i++) {
+    const line = yaml[i];
+    if (line.trim() !== "" && !line.trimStart().startsWith("#")) {
+      sectionIndent = indentOf(line);
+      break;
+    }
+  }
+  const keyRe = new RegExp(`^(\\s+)${escapeRe(w.id)}:(.*)$`);
+  let nodeLine = -1;
+  let nodeIndent = sectionIndent;
+  let nodeRest = "";
+  for (let i = sectionStart + 1; i < sectionEnd; i++) {
+    const m = keyRe.exec(yaml[i]);
+    if (m && m[1].length === sectionIndent) {
+      nodeLine = i;
+      nodeIndent = m[1].length;
+      nodeRest = m[2];
+      break;
+    }
+  }
+  const pad = (n) => " ".repeat(n);
+  if (nodeLine === -1) {
+    const block = [
+      `${pad(sectionIndent)}${w.id}:`,
+      `${pad(sectionIndent * 2)}index: ${w.value}`
+    ];
+    yaml.splice(sectionEnd, 0, ...block);
+    return;
+  }
+  if (nodeRest.trimStart().startsWith("{")) {
+    const span = innerBraceSpan(nodeRest);
+    if (span) {
+      const prefix = yaml[nodeLine].slice(
+        0,
+        yaml[nodeLine].length - nodeRest.length
+      );
+      const before = nodeRest.slice(0, span.open);
+      const after = nodeRest.slice(span.close + 1);
+      const inner = nodeRest.slice(span.open + 1, span.close).trim();
+      let merged;
+      if (/\bindex:\s*\d/.test(inner)) {
+        merged = inner.replace(/(\bindex:\s*)\d+/, `$1${w.value}`);
+      } else {
+        merged = inner === "" ? `index: ${w.value}` : `index: ${w.value}, ${inner}`;
+      }
+      yaml[nodeLine] = `${prefix}${before}{ ${merged} }${after}`;
+      return;
+    }
+  }
+  const childIndent = nodeIndent + sectionIndent;
+  for (let i = nodeLine + 1; i < sectionEnd; i++) {
+    const line = yaml[i];
+    if (line.trim() === "") continue;
+    if (indentOf(line) <= nodeIndent) break;
+    if (/^\s*index:\s*/.test(line)) {
+      yaml[i] = line.replace(/^(\s*index:\s*)\d+/, `$1${w.value}`);
+      return;
+    }
+  }
+  yaml.splice(nodeLine + 1, 0, `${pad(childIndent)}index: ${w.value}`);
+}
+function escapeRe(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function innerBraceSpan(s) {
+  const open = s.indexOf("{");
+  if (open === -1) return null;
+  let depth = 0;
+  for (let i = open; i < s.length; i++) {
+    if (s[i] === "{") depth++;
+    else if (s[i] === "}" && --depth === 0) return { open, close: i };
+  }
+  return null;
+}
+
+// src/sort.ts
+var indentOf2 = (line) => line.length - line.trimStart().length;
+function extractNodeId(line) {
+  const m = /^\s+(\S[^:]*?)\s*:/.exec(line);
+  return m?.[1] ?? "";
+}
+function extractBlocksAndGaps(sectionLines, childIndent) {
+  const blocks = [];
+  const gaps = [];
+  let currentGap = [];
+  let pendingComments = [];
+  let i = 0;
+  while (i < sectionLines.length) {
+    const line = sectionLines[i];
+    const trimmed = line.trim();
+    if (trimmed === "") {
+      if (pendingComments.length > 0) {
+        currentGap.push(...pendingComments);
+        pendingComments = [];
+      }
+      currentGap.push(line);
+      i++;
+      continue;
+    }
+    if (trimmed.startsWith("#")) {
+      pendingComments.push(line);
+      i++;
+      continue;
+    }
+    if (indentOf2(line) === childIndent) {
+      gaps.push([...currentGap]);
+      currentGap = [];
+      const blockLines = [...pendingComments, line];
+      pendingComments = [];
+      i++;
+      while (i < sectionLines.length) {
+        const childLine = sectionLines[i];
+        if (childLine.trim() === "") break;
+        if (indentOf2(childLine) <= childIndent) break;
+        blockLines.push(childLine);
+        i++;
+      }
+      blocks.push({ id: extractNodeId(line), lines: blockLines });
+      continue;
+    }
+    if (pendingComments.length > 0) {
+      currentGap.push(...pendingComments);
+      pendingComments = [];
+    }
+    currentGap.push(line);
+    i++;
+  }
+  const trailingGap = [...currentGap, ...pendingComments];
+  gaps.push(trailingGap);
+  return { blocks, gaps };
+}
+function sort(source, opts) {
+  const { edges, graph, nodeKinds, frontmatter, diagnostics } = analyze(source);
+  if (diagnostics.some((d) => d.severity === "error")) {
+    return { output: source, changed: false, diagnostics };
+  }
+  const topoOrder = /* @__PURE__ */ new Map();
+  if (opts.by.includes("topological")) {
+    const order = [];
+    const seen = /* @__PURE__ */ new Set();
+    const push = (id) => {
+      if (!seen.has(id)) {
+        seen.add(id);
+        order.push(id);
+      }
+    };
+    for (const e of sortEdges(edges, graph)) {
+      if (e.kind === "input") {
+        push(e.artifact);
+        push(e.process);
+      } else if (e.kind === "output") {
+        push(e.process);
+        push(e.artifact);
+      }
+    }
+    const remaining = /* @__PURE__ */ new Set([
+      ...graph.nodes.keys(),
+      ...Object.keys(frontmatter?.artifact ?? {}),
+      ...Object.keys(frontmatter?.process ?? {})
+    ]);
+    for (const id of [...remaining].sort()) push(id);
+    for (const [rank, id] of order.entries()) topoOrder.set(id, rank);
+  }
+  const kindOf = (id) => nodeKinds.get(id) ?? "artifact";
+  const getGroup = (id) => {
+    const kind = kindOf(id);
+    const meta = kind === "artifact" ? frontmatter?.artifact?.[id] : frontmatter?.process?.[id];
+    return typeof meta?.group === "string" ? meta.group : null;
+  };
+  const getSortValue = (id, key) => {
+    const kind = kindOf(id);
+    const meta = kind === "artifact" ? frontmatter?.artifact?.[id] : frontmatter?.process?.[id];
+    switch (key) {
+      case "index":
+        return typeof meta?.index === "number" ? meta.index : Number.MAX_SAFE_INTEGER;
+      case "topological":
+        return topoOrder.get(id) ?? Number.MAX_SAFE_INTEGER;
+      case "id":
+        return id;
+    }
+  };
+  const lines = source.split("\n");
+  const trailingNewline = source.endsWith("\n");
+  let fmOpen = -1;
+  let fmClose = -1;
+  if (lines[0]?.trim() === "---") {
+    fmOpen = 0;
+    for (let i = 1; i < lines.length; i++) {
+      if (lines[i]?.trim() === "---") {
+        fmClose = i;
+        break;
+      }
+    }
+  }
+  if (fmOpen === -1 || fmClose === -1) {
+    return { output: source, changed: false, diagnostics };
+  }
+  const yaml = lines.slice(fmOpen + 1, fmClose);
+  const sectionMods = [];
+  for (const section of ["artifact", "process"]) {
+    let sectionStart = -1;
+    for (let i = 0; i < yaml.length; i++) {
+      const line = yaml[i];
+      if (/^[^\s#]/.test(line) && line.replace(/\s*:.*$/, "") === section) {
+        sectionStart = i;
+        break;
+      }
+    }
+    if (sectionStart === -1) continue;
+    let sectionEnd = yaml.length;
+    for (let i = sectionStart + 1; i < yaml.length; i++) {
+      const line = yaml[i];
+      if (line.trim() !== "" && /^[^\s#]/.test(line)) {
+        sectionEnd = i;
+        break;
+      }
+    }
+    const sectionContent = yaml.slice(sectionStart + 1, sectionEnd);
+    let childIndent = 2;
+    for (const line of sectionContent) {
+      if (line.trim() !== "" && !line.trimStart().startsWith("#")) {
+        childIndent = indentOf2(line);
+        break;
+      }
+    }
+    const { blocks, gaps } = extractBlocksAndGaps(sectionContent, childIndent);
+    if (blocks.length === 0) continue;
+    const indexed = blocks.map((block, idx) => ({ block, idx }));
+    indexed.sort((a, b) => {
+      for (const key of opts.by) {
+        let cmp;
+        if (key === "group") {
+          const ga = getGroup(a.block.id);
+          const gb = getGroup(b.block.id);
+          if (ga === null && gb === null) cmp = 0;
+          else if (ga === null) cmp = 1;
+          else if (gb === null) cmp = -1;
+          else cmp = ga.localeCompare(gb);
+        } else {
+          const va = getSortValue(a.block.id, key);
+          const vb = getSortValue(b.block.id, key);
+          if (typeof va === "number" && typeof vb === "number") {
+            cmp = va - vb;
+          } else {
+            cmp = String(va).localeCompare(String(vb));
+          }
+        }
+        if (cmp !== 0) return cmp;
+      }
+      return a.idx - b.idx;
+    });
+    const orderChanged = indexed.some((x, i) => x.idx !== i);
+    if (!orderChanged) continue;
+    const sortedBlocks = indexed.map((x) => x.block);
+    const newLines = [];
+    for (let j = 0; j < sortedBlocks.length; j++) {
+      newLines.push(...gaps[j]);
+      newLines.push(...sortedBlocks[j].lines);
+    }
+    newLines.push(...gaps[sortedBlocks.length]);
+    sectionMods.push({
+      yamlStart: sectionStart + 1,
+      yamlEnd: sectionEnd,
+      newLines
+    });
+  }
+  if (sectionMods.length === 0) {
+    return { output: source, changed: false, diagnostics };
+  }
+  const mutableYaml = [...yaml];
+  for (const mod of [...sectionMods].reverse()) {
+    mutableYaml.splice(
+      mod.yamlStart,
+      mod.yamlEnd - mod.yamlStart,
+      ...mod.newLines
+    );
+  }
+  const rebuilt = [
+    ...lines.slice(0, fmOpen + 1),
+    ...mutableYaml,
+    ...lines.slice(fmClose)
+  ];
+  let result = rebuilt.join("\n");
+  if (trailingNewline && !result.endsWith("\n")) result += "\n";
+  return { output: result, changed: true, diagnostics };
+}
+
+// src/multifile.ts
+import { dirname, resolve } from "path";
+function resolveRefPath(fromFile, ref) {
+  if (ref.includes("://")) return { ok: false, reason: "url" };
+  if (ref.startsWith("/")) return { ok: false, reason: "absolute" };
+  return { ok: true, path: resolve(dirname(fromFile), ref) };
+}
+function collectExtendsRefs(fm) {
+  const ext = fm.extends;
+  if (ext === void 0) return [];
+  return Array.isArray(ext) ? [...ext] : [ext];
+}
+function collectSubflowRefs(fm) {
+  const refs = [];
+  for (const [process, meta] of Object.entries(fm.process ?? {})) {
+    if (typeof meta.subflow === "string") {
+      refs.push({ process, ref: meta.subflow });
+    }
+  }
+  return refs;
+}
+function loadSubflowGraph(entryPath, load) {
+  const docs = /* @__PURE__ */ new Map();
+  const diagnostics = [];
+  const stack = /* @__PURE__ */ new Set();
+  function visit(path) {
+    if (stack.has(path)) {
+      diagnostics.push({
+        severity: "error",
+        code: "V022",
+        message: `circular subflow reference: ${path}`,
+        range: zeroRange()
+      });
+      return;
+    }
+    if (docs.has(path)) return;
+    const doc = load(path);
+    if (doc === null) {
+      diagnostics.push({
+        severity: "error",
+        code: "V021",
+        message: `subflow file not found: ${path}`,
+        range: zeroRange()
+      });
+      return;
+    }
+    docs.set(path, doc);
+    stack.add(path);
+    for (const { ref } of collectSubflowRefs(doc.frontmatter ?? {})) {
+      const resolved = resolveRefPath(path, ref);
+      if (!resolved.ok) {
+        diagnostics.push({
+          severity: "error",
+          code: "V021",
+          message: `invalid subflow path (${resolved.reason}): ${ref}`,
+          range: zeroRange()
+        });
+        continue;
+      }
+      visit(resolved.path);
+    }
+    stack.delete(path);
+  }
+  visit(entryPath);
+  return { docs, diagnostics };
+}
+function computeOpenInputs(edges) {
+  const all = /* @__PURE__ */ new Set();
+  const produced = /* @__PURE__ */ new Set();
+  for (const e of edges) {
+    all.add(e.artifact);
+    if (e.kind === "output") produced.add(e.artifact);
+  }
+  return new Set([...all].filter((a) => !produced.has(a)));
+}
+function computeTerminals(edges) {
+  const all = /* @__PURE__ */ new Set();
+  const consumed = /* @__PURE__ */ new Set();
+  for (const e of edges) {
+    all.add(e.artifact);
+    if (e.kind === "input" || e.kind === "feedback") consumed.add(e.artifact);
+  }
+  return new Set([...all].filter((a) => !consumed.has(a)));
+}
+function validateSubflowBoundary(ctx) {
+  const {
+    processId,
+    parentNormalInputs,
+    parentOutputs,
+    boundaryMap,
+    childOpenInputs,
+    childTerminals
+  } = ctx;
+  const diagnostics = [];
+  const parentBoundary = /* @__PURE__ */ new Set([...parentNormalInputs, ...parentOutputs]);
+  const childBoundary = /* @__PURE__ */ new Set([...childOpenInputs, ...childTerminals]);
+  let hasC1orC2Error = false;
+  for (const key of Object.keys(boundaryMap)) {
+    if (!parentBoundary.has(key)) {
+      hasC1orC2Error = true;
+      diagnostics.push({
+        severity: "error",
+        code: "V025",
+        message: `boundary key '${key}' on process '${processId}' is not a parent boundary artifact`,
+        range: zeroRange()
+      });
+    }
+  }
+  for (const val of Object.values(boundaryMap)) {
+    if (!childBoundary.has(val)) {
+      hasC1orC2Error = true;
+      diagnostics.push({
+        severity: "error",
+        code: "V025",
+        message: `boundary value '${val}' on process '${processId}' is not a child boundary artifact`,
+        range: zeroRange()
+      });
+    }
+  }
+  if (hasC1orC2Error) return diagnostics;
+  const effective = /* @__PURE__ */ new Map();
+  for (const p of parentBoundary) {
+    effective.set(p, boundaryMap[p] ?? p);
+  }
+  const childToParent = /* @__PURE__ */ new Map();
+  for (const [p, c] of effective) {
+    if (childToParent.has(c)) {
+      diagnostics.push({
+        severity: "error",
+        code: "V025",
+        message: `boundary map for process '${processId}' is not injective: multiple parent IDs map to child '${c}'`,
+        range: zeroRange()
+      });
+    } else {
+      childToParent.set(c, p);
+    }
+  }
+  for (const p of parentNormalInputs) {
+    const c = effective.get(p);
+    if (childTerminals.has(c) && !childOpenInputs.has(c)) {
+      diagnostics.push({
+        severity: "error",
+        code: "V025",
+        message: `boundary maps input '${p}' to terminal '${c}' (side mismatch) on process '${processId}'`,
+        range: zeroRange()
+      });
+    }
+  }
+  for (const p of parentOutputs) {
+    const c = effective.get(p);
+    if (childOpenInputs.has(c) && !childTerminals.has(c)) {
+      diagnostics.push({
+        severity: "error",
+        code: "V025",
+        message: `boundary maps output '${p}' to open input '${c}' (side mismatch) on process '${processId}'`,
+        range: zeroRange()
+      });
+    }
+  }
+  if (diagnostics.length > 0) return diagnostics;
+  const mappedInputs = new Set(
+    [...parentNormalInputs].map((p) => effective.get(p))
+  );
+  if (!setsEqual(mappedInputs, childOpenInputs)) {
+    diagnostics.push({
+      severity: "error",
+      code: "V025",
+      message: `subflow boundary mismatch on process '${processId}': parent inputs ${JSON.stringify([...mappedInputs].sort())} \u2260 child open inputs ${JSON.stringify([...childOpenInputs].sort())}`,
+      range: zeroRange()
+    });
+  }
+  const mappedOutputs = new Set(
+    [...parentOutputs].map((p) => effective.get(p))
+  );
+  if (!setsEqual(mappedOutputs, childTerminals)) {
+    diagnostics.push({
+      severity: "error",
+      code: "V025",
+      message: `subflow boundary mismatch on process '${processId}': parent outputs ${JSON.stringify([...mappedOutputs].sort())} \u2260 child terminals ${JSON.stringify([...childTerminals].sort())}`,
+      range: zeroRange()
+    });
+  }
+  return diagnostics;
+}
+function setsEqual(a, b) {
+  if (a.size !== b.size) return false;
+  for (const x of a) if (!b.has(x)) return false;
+  return true;
+}
+function loadExtendsChain(entryPath, load) {
+  const docs = /* @__PURE__ */ new Map();
+  const diagnostics = [];
+  const stack = /* @__PURE__ */ new Set();
+  function visit(path) {
+    if (stack.has(path)) {
+      diagnostics.push({
+        severity: "error",
+        code: "V027",
+        message: `circular extends reference: ${path}`,
+        range: zeroRange()
+      });
+      return;
+    }
+    if (docs.has(path)) return;
+    const doc = load(path);
+    if (doc === null) {
+      diagnostics.push({
+        severity: "error",
+        code: "V026",
+        message: `extends file not found: ${path}`,
+        range: zeroRange()
+      });
+      return;
+    }
+    docs.set(path, doc);
+    stack.add(path);
+    for (const ref of collectExtendsRefs(doc.frontmatter ?? {})) {
+      const resolved = resolveRefPath(path, ref);
+      if (!resolved.ok) {
+        diagnostics.push({
+          severity: "error",
+          code: "V026",
+          message: `invalid extends path (${resolved.reason}): ${ref}`,
+          range: zeroRange()
+        });
+        continue;
+      }
+      visit(resolved.path);
+    }
+    stack.delete(path);
+  }
+  visit(entryPath);
+  return { docs, diagnostics };
+}
+var PRESET_ALLOWED_KEYS = /* @__PURE__ */ new Set([
+  "extends",
+  "statusStyles",
+  "tag",
+  "group"
+]);
+function validatePresetKeys(path, fm) {
+  if (fm === null) return [];
+  const diagnostics = [];
+  for (const key of Object.keys(fm)) {
+    if (!PRESET_ALLOWED_KEYS.has(key)) {
+      diagnostics.push({
+        severity: "error",
+        code: "V028",
+        message: `preset '${path}' contains non-presentation key '${key}'`,
+        range: zeroRange()
+      });
+    }
+  }
+  return diagnostics;
+}
+function resolvePresentation(chain) {
+  let statusStyles;
+  let tag;
+  let group;
+  for (const { fm } of chain) {
+    if (fm === null) continue;
+    if (fm.statusStyles !== void 0) {
+      if (statusStyles === void 0) {
+        statusStyles = {};
+      }
+      for (const [status, nodeStyle] of Object.entries(fm.statusStyles)) {
+        if (nodeStyle === void 0) continue;
+        const existing = statusStyles[status] ?? {};
+        statusStyles[status] = {
+          ...existing,
+          ...nodeStyle
+        };
+      }
+    }
+    if (fm.tag !== void 0) {
+      if (tag === void 0) {
+        tag = {};
+      }
+      for (const [id, tagMeta] of Object.entries(fm.tag)) {
+        if (tagMeta === void 0) continue;
+        const existing = tag[id] ?? {};
+        const { style: newStyle, ...otherFields } = tagMeta;
+        const { style: existingStyle, ...existingOther } = existing;
+        const mergedStyle = newStyle !== void 0 || existingStyle !== void 0 ? { ...existingStyle, ...newStyle } : void 0;
+        tag[id] = {
+          ...existingOther,
+          ...otherFields,
+          ...mergedStyle !== void 0 ? { style: mergedStyle } : {}
+        };
+      }
+    }
+    if (fm.group !== void 0) {
+      if (group === void 0) {
+        group = {};
+      }
+      for (const [id, groupMeta] of Object.entries(fm.group)) {
+        if (groupMeta === void 0) continue;
+        group[id] = { ...group[id] ?? {}, ...groupMeta };
+      }
+    }
+  }
+  return { statusStyles, tag, group };
+}
+
+// src/index.ts
+function parse(source) {
+  const {
+    frontmatter,
+    body,
+    diagnostics: fmDiags,
+    bodyStartLine
+  } = loadFrontmatter(source);
+  const { tokens: rawTokens, diagnostics: lexDiags } = lex(body);
+  const lineOffset = bodyStartLine - 1;
+  const tokens = lineOffset > 0 ? rawTokens.map((t) => ({
+    ...t,
+    start: { ...t.start, line: t.start.line + lineOffset },
+    end: { ...t.end, line: t.end.line + lineOffset }
+  })) : rawTokens;
+  const { document, diagnostics: parseDiags } = parseTokens(tokens);
+  return {
+    document,
+    frontmatter,
+    bodyStartLine,
+    diagnostics: [...fmDiags, ...lexDiags, ...parseDiags]
+  };
+}
+function hasErrors(diags) {
+  return diags.some((d) => d.severity === "error");
+}
+function analyze(source, opts = {}) {
+  const {
+    document,
+    frontmatter,
+    bodyStartLine,
+    diagnostics: parseDiags
+  } = parse(source);
+  const {
+    edges,
+    nodeKinds,
+    isolatedNodes,
+    diagnostics: normDiags
+  } = normalize(document, frontmatter);
+  const valOpts = { source };
+  if (opts.strict) valOpts.strict = true;
+  const valDiags = validate(edges, nodeKinds, frontmatter, valOpts);
+  const graph = buildGraph(edges, nodeKinds);
+  return {
+    document,
+    frontmatter,
+    bodyStartLine,
+    edges,
+    nodeKinds,
+    isolatedNodes,
+    graph,
+    diagnostics: [...parseDiags, ...normDiags, ...valDiags]
+  };
+}
+function format(source, opts = {}) {
+  const {
+    frontmatter,
+    body,
+    diagnostics: fmDiags,
+    bodyStartLine
+  } = loadFrontmatter(source);
+  const { tokens: rawTokens2, diagnostics: lexDiags } = lex(body);
+  const lineOffset = bodyStartLine - 1;
+  const tokens = lineOffset > 0 ? rawTokens2.map((t) => ({
+    ...t,
+    start: { ...t.start, line: t.start.line + lineOffset },
+    end: { ...t.end, line: t.end.line + lineOffset }
+  })) : rawTokens2;
+  const { document, diagnostics: parseDiags } = parseTokens(tokens);
+  const {
+    edges,
+    nodeKinds,
+    diagnostics: normDiags
+  } = normalize(document, frontmatter);
+  const valDiags = opts.skipValidation ? [] : validate(edges, nodeKinds, frontmatter, { source });
+  const frontmatterSection = source.slice(0, source.length - body.length);
+  const segments = splitBodyIntoSegments(body);
+  const formattedBody = segments.map((seg) => {
+    if (seg.kind === "comment") return seg.text;
+    const { tokens: segToks } = lex(seg.text);
+    const { document: segDoc } = parseTokens(segToks);
+    const { edges: segEdges, isolatedNodes: segIsolated } = normalize(
+      segDoc,
+      frontmatter
+    );
+    const segGraph = buildGraph(segEdges, nodeKinds);
+    const segSorted = sortEdges(segEdges, segGraph);
+    const segIso = sortIsolated(segIsolated);
+    return opts.style === "flows" ? formatAsFlows(segSorted, segIso) : formatEdges(segSorted, segIso);
+  }).join("");
+  return {
+    output: frontmatterSection + formattedBody,
+    diagnostics: [
+      ...fmDiags,
+      ...lexDiags,
+      ...parseDiags,
+      ...normDiags,
+      ...valDiags
+    ]
+  };
+}
+export {
+  ID_PATTERN,
+  STATUS_VALUES,
+  STYLE_ATTRS,
+  analyze,
+  auditGraph,
+  buildGraph,
+  collectExtendsRefs,
+  collectSubflowRefs,
+  computeOpenInputs,
+  computeTerminals,
+  diffGraphs,
+  format,
+  formatAsFlows,
+  formatEdges,
+  hasErrors,
+  loadExtendsChain,
+  loadFrontmatter,
+  loadSubflowGraph,
+  normalize as normalizeDocument,
+  parse,
+  reindex,
+  resolveMeta,
+  resolvePresentation,
+  resolveRefPath,
+  sort,
+  sortEdges,
+  sortIsolated,
+  validate as validateGraph,
+  validatePresetKeys,
+  validateSubflowBoundary
+};