@diagrammo/dgmo 0.46.0 → 0.47.0

package/dist/chunk-RYEGFMUO.js

@@ -0,0 +1,955 @@
+import {
+  displayName,
+  normalizeName
+} from "./chunk-NOTA6TEI.js";
+import {
+  OPTION_NOCOLON_RE,
+  RACI_REGISTRY,
+  measureIndent,
+  parseFirstLine,
+  splitNameAndMeta,
+  tryParseSharedOption,
+  warnUnknownMetaKeys
+} from "./chunk-Y3J7VR52.js";
+import {
+  resolveColorWithDiagnostic
+} from "./chunk-TLVIHFRO.js";
+import {
+  NAME_DIAGNOSTIC_CODES,
+  emit,
+  makeDgmoError,
+  makeFail,
+  nameMergedMessage,
+  suggest
+} from "./chunk-CXK4DZH3.js";
+
+// src/raci/diagnostics.ts
+var RACI_DX = {
+  // ── Errors ──────────────────────────────────────────────────
+  MULTI_ACCOUNTABLE: {
+    code: "E_RACI_MULTI_ACCOUNTABLE",
+    severity: "error",
+    chartType: "raci",
+    title: "Multiple Accountable",
+    // variants.ts › multiAccountableRule
+    message: (p) => `Task '${p.task ?? "Task"}' has more than one Accountable \u2014 RACI requires exactly one.`,
+    hint: "Assign the A marker to exactly one role per task; make the others Responsible or Consulted.",
+    example: `raci
+
+Task
+  Cap: A
+  QM: A`
+  },
+  DACI_MULTI_DRIVER: {
+    code: "E_DACI_MULTI_DRIVER",
+    severity: "error",
+    chartType: "raci",
+    title: "Multiple Driver (DACI)",
+    // variants.ts › daciMultiDriverRule
+    message: (p) => `Task '${p.task ?? "Task"}' has more than one Driver \u2014 DACI requires exactly one.`,
+    hint: "A DACI decision has a single Driver; give the extra D roles another marker.",
+    example: `raci
+
+Decision
+  PM: D
+  Cap: D`
+  },
+  DACI_MULTI_ACCOUNTABLE: {
+    code: "E_DACI_MULTI_ACCOUNTABLE",
+    severity: "error",
+    chartType: "raci",
+    title: "Multiple Approver (DACI)",
+    // variants.ts › daciMultiAccountableRule
+    message: (p) => `Task '${p.task ?? "Task"}' has more than one Approver \u2014 DACI requires exactly one.`,
+    hint: "A DACI decision has a single Approver (A); reduce to one.",
+    example: `raci
+
+Decision
+  Lead: D
+  PM: A
+  Cap: A`
+  },
+  INVALID_MARKER: {
+    code: "E_RACI_INVALID_MARKER",
+    severity: "error",
+    chartType: "raci",
+    // Two emit sites share this code: parser.ts first-pass (default form,
+    // rejects letters outside the union alphabet) and parser.ts post-pass
+    // (variant-aware form, passed `variant`+`alphabet`, rejects union
+    // letters outside the resolved variant). The `{}` default renders the
+    // first-pass wording.
+    title: "Invalid marker",
+    // parser.ts first-pass tokenizer
+    message: (p) => p.variant !== void 0 && p.variant !== null ? `Marker '${p.marker ?? "X"}' is not in the ${p.variant} alphabet (${p.alphabet}).` : `Marker '${p.marker ?? "X"}' is not a recognized RACI marker (R A S C I D).`,
+    hint: "Use only R, A, S, C, I (or D for DACI). Wrong-variant letters (e.g. S in a DACI chart) trigger the variant-alphabet form of this diagnostic.",
+    example: `raci
+
+Task
+  Cap: X`
+  },
+  UNEXPECTED_LINE: {
+    code: "E_RACI_UNEXPECTED_LINE",
+    severity: "error",
+    chartType: "raci",
+    title: "Unexpected line under task",
+    // parser.ts — free-text after first role assignment
+    message: (p) => `Unexpected line after role assignments under task '${p.task ?? "Task"}'. Lines under a task must be either a description (before the first 'Role: markers' line) or another role assignment.`,
+    hint: "Put all description text before the first role assignment; nothing but assignments may follow.",
+    example: `raci
+
+Task
+  Cap: A
+  This is an unexpected description.`
+  },
+  MIXED_VARIANTS: {
+    code: "E_RACI_MIXED_VARIANTS",
+    severity: "error",
+    chartType: "raci",
+    title: "Mixed RASCI/DACI markers",
+    // parser.ts — variant resolution, inferVariant() returned null
+    message: "Chart uses both 'D' and 'S' markers but neither RASCI nor DACI covers both. Use only RACI/RASCI markers (R, A, S, C, I) or only DACI markers (D, A, C, I).",
+    hint: "Pick one convention: R/A/S/C/I (RACI/RASCI) or D/A/C/I (DACI). Do not mix D and S in one chart.",
+    example: `raci
+
+Task
+  Cap: D
+  Crew: S`
+  },
+  // ── Warnings ────────────────────────────────────────────────
+  MISSING_ACCOUNTABLE: {
+    code: "W_RACI_MISSING_ACCOUNTABLE",
+    severity: "warning",
+    chartType: "raci",
+    title: "Missing Accountable",
+    // variants.ts › missingAccountableRule
+    message: (p) => `Task '${p.task ?? "Task"}' has no Accountable assigned.`,
+    hint: "Every RACI task should have exactly one Accountable (A).",
+    example: `raci
+
+Task
+  Cap: R`
+  },
+  MISSING_RESPONSIBLE: {
+    code: "W_RACI_MISSING_RESPONSIBLE",
+    severity: "warning",
+    chartType: "raci",
+    title: "Missing Responsible",
+    // variants.ts › missingResponsibleRule
+    message: (p) => `Task '${p.task ?? "Task"}' has no Responsible assigned.`,
+    hint: "Assign at least one Responsible (R) \u2014 someone has to do the work.",
+    example: `raci
+
+Task
+  Cap: A`
+  },
+  DACI_MISSING_DRIVER: {
+    code: "W_DACI_MISSING_DRIVER",
+    severity: "warning",
+    chartType: "raci",
+    title: "Missing Driver (DACI)",
+    // variants.ts › daciMissingDriverRule
+    message: (p) => `Task '${p.task ?? "Task"}' has no Driver assigned.`,
+    hint: "A DACI decision needs a Driver (D) to move it forward.",
+    example: `raci
+
+Pick Vendor
+  Lead: D
+  PM: A
+Sign Off
+  Cap: C`
+  },
+  DACI_MISSING_ACCOUNTABLE: {
+    code: "W_DACI_MISSING_ACCOUNTABLE",
+    severity: "warning",
+    chartType: "raci",
+    title: "Missing Approver (DACI)",
+    // variants.ts › daciMissingAccountableRule
+    message: (p) => `Task '${p.task ?? "Task"}' has no Approver assigned.`,
+    hint: "A DACI decision needs an Approver (A) to sign off.",
+    example: `raci
+
+Pick Vendor
+  Lead: D
+  PM: A
+Sign Off
+  Cap: C`
+  },
+  UNKNOWN_ROLE: {
+    code: "W_RACI_UNKNOWN_ROLE",
+    severity: "warning",
+    chartType: "raci",
+    title: "Undeclared role",
+    // parser.ts — only when `roles:` is declared. Live message appends a
+    // ` Did you mean 'X'?` suggestion when a near match exists.
+    message: (p) => {
+      const role = p.role ?? "Role";
+      const hint = p.hint ?? "";
+      return `Role '${role}' is not declared in the 'roles:' directive.${hint ? " " + hint : ""}`;
+    },
+    hint: "Add the role to the `roles` directive, or fix the typo to match a declared role.",
+    example: `raci
+roles Cap, QM
+
+Task
+  Cap: A
+  Stranger: R`
+  },
+  EMPTY_TASK: {
+    code: "W_RACI_EMPTY_TASK",
+    severity: "warning",
+    chartType: "raci",
+    title: "Empty task",
+    // variants.ts › emptyTaskRule
+    message: (p) => `Task '${p.task ?? "Task"}' has no role assignments.`,
+    hint: "Add at least one `Role: markers` line, or remove the empty task.",
+    example: `raci
+
+Task
+  Just a description with no assignments`
+  },
+  CONFLICTING_MARKERS: {
+    code: "W_RACI_CONFLICTING_MARKERS",
+    severity: "warning",
+    chartType: "raci",
+    title: "Conflicting markers",
+    // variants.ts › conflictingMarkersRule
+    message: (p) => {
+      const role = p.role ?? "Role";
+      const task = p.task ?? "Task";
+      const markers = p.markers ?? "A C";
+      return `Role '${role}' on task '${task}' has conflicting markers (${markers}). A role can be either active (R/A/D) or passive (C/I), not both.`;
+    },
+    hint: "Give the role either an active marker (R/A/D) or a passive one (C/I), not both.",
+    example: `raci
+
+Task
+  Cap: A C`
+  },
+  TOO_MANY_RESPONSIBLE: {
+    code: "W_RACI_TOO_MANY_RESPONSIBLE",
+    severity: "warning",
+    chartType: "raci",
+    title: "Too many Responsible",
+    // variants.ts › tooManyResponsibleRule (threshold = 3)
+    message: (p) => {
+      const task = p.task ?? "Task";
+      const count = p.count ?? 4;
+      const threshold = p.threshold ?? 3;
+      return `Task '${task}' has ${count} Responsibles \u2014 more than ${threshold} dilutes ownership. Consider splitting the task or marking some as Consulted.`;
+    },
+    hint: "Keep Responsibles at or below 3 \u2014 split the task or downgrade some roles to Consulted.",
+    example: `raci
+
+Task
+  W: R
+  X: R
+  Y: R
+  Z: R
+  Lead: A`
+  },
+  ORPHAN_ROLE: {
+    code: "W_RACI_ORPHAN_ROLE",
+    severity: "warning",
+    chartType: "raci",
+    title: "Orphan role",
+    // parser.ts — role declared/seen but never assigned any marker
+    message: (p) => `Role '${p.role ?? "Role"}' is declared but never assigned to any task.`,
+    hint: "Assign the role a marker somewhere, or remove it from the `roles` directive.",
+    example: `raci
+roles Cap, Ghost
+
+Task
+  Cap: A R`
+  }
+};
+var RACI_DIAGNOSTICS = Object.values(RACI_DX);
+
+// src/raci/variants.ts
+var RACI_ERROR_CODES = {
+  MULTI_ACCOUNTABLE: "E_RACI_MULTI_ACCOUNTABLE",
+  DACI_MULTI_DRIVER: "E_DACI_MULTI_DRIVER",
+  DACI_MULTI_ACCOUNTABLE: "E_DACI_MULTI_ACCOUNTABLE",
+  INVALID_MARKER: "E_RACI_INVALID_MARKER",
+  UNEXPECTED_LINE: "E_RACI_UNEXPECTED_LINE",
+  MIXED_VARIANTS: "E_RACI_MIXED_VARIANTS"
+};
+var ALL_MARKERS = /* @__PURE__ */ new Set([
+  "R",
+  "A",
+  "S",
+  "C",
+  "I",
+  "D"
+]);
+function inferVariant(markers) {
+  let hasD = false;
+  let hasS = false;
+  for (const m of markers) {
+    if (m === "D") hasD = true;
+    else if (m === "S") hasS = true;
+  }
+  if (hasD && hasS) return null;
+  if (hasD) return "daci";
+  if (hasS) return "rasci";
+  return "raci";
+}
+var RACI_WARNING_CODES = {
+  MISSING_ACCOUNTABLE: "W_RACI_MISSING_ACCOUNTABLE",
+  MISSING_RESPONSIBLE: "W_RACI_MISSING_RESPONSIBLE",
+  DACI_MISSING_DRIVER: "W_DACI_MISSING_DRIVER",
+  DACI_MISSING_ACCOUNTABLE: "W_DACI_MISSING_ACCOUNTABLE",
+  UNKNOWN_ROLE: "W_RACI_UNKNOWN_ROLE",
+  EMPTY_TASK: "W_RACI_EMPTY_TASK",
+  CONFLICTING_MARKERS: "W_RACI_CONFLICTING_MARKERS",
+  TOO_MANY_RESPONSIBLE: "W_RACI_TOO_MANY_RESPONSIBLE",
+  ORPHAN_ROLE: "W_RACI_ORPHAN_ROLE"
+};
+var TOO_MANY_RESPONSIBLE_THRESHOLD = 3;
+function countMarker(task, marker) {
+  let count = 0;
+  for (const assignment of task.roleAssignments) {
+    for (const m of assignment.markers) if (m === marker) count++;
+  }
+  return count;
+}
+function totalMarkerCount(task) {
+  let n = 0;
+  for (const a of task.roleAssignments) n += a.markers.length;
+  return n;
+}
+function findFirstAssignmentLineWithMarker(task, marker, skipFirst) {
+  let seen = 0;
+  for (const assignment of task.roleAssignments) {
+    if (assignment.markers.includes(marker)) {
+      seen++;
+      if (skipFirst && seen === 1) continue;
+      return assignment.lineNumber;
+    }
+  }
+  return task.lineNumber;
+}
+var multiAccountableRule = (task) => {
+  if (countMarker(task, "A") > 1) {
+    return [
+      emit(
+        RACI_DX.MULTI_ACCOUNTABLE,
+        findFirstAssignmentLineWithMarker(task, "A", true),
+        {
+          task: task.displayName
+        }
+      )
+    ];
+  }
+  return [];
+};
+var daciMultiDriverRule = (task) => {
+  if (countMarker(task, "D") > 1) {
+    return [
+      emit(
+        RACI_DX.DACI_MULTI_DRIVER,
+        findFirstAssignmentLineWithMarker(task, "D", true),
+        {
+          task: task.displayName
+        }
+      )
+    ];
+  }
+  return [];
+};
+var daciMultiAccountableRule = (task) => {
+  if (countMarker(task, "A") > 1) {
+    return [
+      emit(
+        RACI_DX.DACI_MULTI_ACCOUNTABLE,
+        findFirstAssignmentLineWithMarker(task, "A", true),
+        {
+          task: task.displayName
+        }
+      )
+    ];
+  }
+  return [];
+};
+var emptyTaskRule = (task) => {
+  if (totalMarkerCount(task) === 0) {
+    return [
+      emit(RACI_DX.EMPTY_TASK, task.lineNumber, { task: task.displayName })
+    ];
+  }
+  return [];
+};
+var missingAccountableRule = (task) => {
+  if (totalMarkerCount(task) === 0) return [];
+  if (countMarker(task, "A") === 0) {
+    return [
+      emit(RACI_DX.MISSING_ACCOUNTABLE, task.lineNumber, {
+        task: task.displayName
+      })
+    ];
+  }
+  return [];
+};
+var missingResponsibleRule = (task) => {
+  if (totalMarkerCount(task) === 0) return [];
+  if (countMarker(task, "R") === 0) {
+    return [
+      emit(RACI_DX.MISSING_RESPONSIBLE, task.lineNumber, {
+        task: task.displayName
+      })
+    ];
+  }
+  return [];
+};
+var daciMissingDriverRule = (task) => {
+  if (totalMarkerCount(task) === 0) return [];
+  if (countMarker(task, "D") === 0) {
+    return [
+      emit(RACI_DX.DACI_MISSING_DRIVER, task.lineNumber, {
+        task: task.displayName
+      })
+    ];
+  }
+  return [];
+};
+var daciMissingAccountableRule = (task) => {
+  if (totalMarkerCount(task) === 0) return [];
+  if (countMarker(task, "A") === 0) {
+    return [
+      emit(RACI_DX.DACI_MISSING_ACCOUNTABLE, task.lineNumber, {
+        task: task.displayName
+      })
+    ];
+  }
+  return [];
+};
+var ACTIVE_MARKERS = /* @__PURE__ */ new Set(["R", "A", "D"]);
+var PASSIVE_MARKERS = /* @__PURE__ */ new Set(["C", "I"]);
+var conflictingMarkersRule = (task) => {
+  const out = [];
+  for (const a of task.roleAssignments) {
+    let hasActive = false;
+    let hasPassive = false;
+    for (const m of a.markers) {
+      if (ACTIVE_MARKERS.has(m)) hasActive = true;
+      if (PASSIVE_MARKERS.has(m)) hasPassive = true;
+    }
+    if (hasActive && hasPassive) {
+      out.push(
+        emit(RACI_DX.CONFLICTING_MARKERS, a.lineNumber, {
+          role: a.displayName,
+          task: task.displayName,
+          markers: a.markers.join(" ")
+        })
+      );
+    }
+  }
+  return out;
+};
+var tooManyResponsibleRule = (task) => {
+  const n = countMarker(task, "R");
+  if (n > TOO_MANY_RESPONSIBLE_THRESHOLD) {
+    return [
+      emit(RACI_DX.TOO_MANY_RESPONSIBLE, task.lineNumber, {
+        task: task.displayName,
+        count: n,
+        threshold: TOO_MANY_RESPONSIBLE_THRESHOLD
+      })
+    ];
+  }
+  return [];
+};
+var VARIANTS = {
+  raci: {
+    alphabet: ["R", "A", "C", "I"],
+    errorRules: [multiAccountableRule],
+    warningRules: [
+      emptyTaskRule,
+      missingAccountableRule,
+      missingResponsibleRule,
+      conflictingMarkersRule,
+      tooManyResponsibleRule
+    ]
+  },
+  rasci: {
+    alphabet: ["R", "A", "S", "C", "I"],
+    errorRules: [multiAccountableRule],
+    warningRules: [
+      emptyTaskRule,
+      missingAccountableRule,
+      missingResponsibleRule,
+      conflictingMarkersRule,
+      tooManyResponsibleRule
+    ]
+  },
+  daci: {
+    alphabet: ["D", "A", "C", "I"],
+    errorRules: [daciMultiDriverRule, daciMultiAccountableRule],
+    warningRules: [
+      emptyTaskRule,
+      daciMissingDriverRule,
+      daciMissingAccountableRule,
+      conflictingMarkersRule
+    ]
+  }
+};
+
+// src/raci/parser.ts
+var KNOWN_OPTIONS = /* @__PURE__ */ new Set(["roles", "palette", "theme", "active-tag"]);
+var KNOWN_BOOLEANS = /* @__PURE__ */ new Set(["no-title"]);
+var REMOVED_BOOLEANS = {
+  "no-rule-enforcement": '"no-rule-enforcement" has been removed \u2014 RACI validation is always active.'
+};
+var PHASE_RE = /^\[(.+?)\]\s*(.*)$/;
+var PHASE_PALETTE_COLOR_RE = /^(red|orange|yellow|green|blue|purple|teal|cyan|gray|black|white)\b/;
+var ROLE_ASSIGNMENT_RE = /^([^:]+):\s*(.*)$/;
+function parseRoleAssignmentLine(trimmed) {
+  const colonMatch = trimmed.match(ROLE_ASSIGNMENT_RE);
+  if (colonMatch) {
+    return {
+      // Capture groups [1] and [2] guaranteed by ROLE_ASSIGNMENT_RE shape.
+      rawRole: colonMatch[1].trim(),
+      markersBlob: colonMatch[2].trim()
+    };
+  }
+  const tokens = trimmed.split(/\s+/).filter((t) => t.length > 0);
+  if (tokens.length < 2) return null;
+  const isAllMarkers = (tok) => {
+    if (tok.length === 0) return false;
+    for (const ch of tok) {
+      if (!ALL_MARKERS.has(ch)) return false;
+    }
+    return true;
+  };
+  let firstMarkerIdx = -1;
+  for (let j = 0; j < tokens.length; j++) {
+    if (isAllMarkers(tokens[j])) {
+      firstMarkerIdx = j;
+      break;
+    }
+  }
+  if (firstMarkerIdx <= 0) return null;
+  return {
+    rawRole: tokens.slice(0, firstMarkerIdx).join(" "),
+    markersBlob: tokens.slice(firstMarkerIdx).join(" ")
+  };
+}
+function parseRaci(content, palette) {
+  const options = {};
+  const result = {
+    type: "raci",
+    variant: "raci",
+    roles: [],
+    roleDisplayNames: [],
+    roleColors: [],
+    phases: [],
+    tasksWithoutPhase: [],
+    options,
+    diagnostics: [],
+    error: null
+  };
+  const fail = makeFail(result);
+  const warn = (line, message, code) => {
+    result.diagnostics.push(makeDgmoError(line, message, "warning", code));
+  };
+  const errorAt = (line, message, code) => {
+    result.diagnostics.push(makeDgmoError(line, message, "error", code));
+  };
+  if (!content?.trim()) {
+    return fail(0, "No content provided");
+  }
+  const lines = content.split("\n");
+  let i = 0;
+  for (; i < lines.length; i++) {
+    const trimmed = lines[i].trim();
+    if (!trimmed || trimmed.startsWith("//")) continue;
+    const firstLine = parseFirstLine(trimmed);
+    if (firstLine?.chartType !== "raci") {
+      return fail(i + 1, 'Expected chart type "raci" on the first line.');
+    }
+    if (firstLine.title) {
+      result.title = firstLine.title;
+      result.titleLineNumber = i + 1;
+    }
+    i++;
+    break;
+  }
+  let bodyStarted = false;
+  const roleStore = /* @__PURE__ */ new Map();
+  const taskStore = /* @__PURE__ */ new Map();
+  let rolesExplicit = false;
+  let currentPhase = null;
+  let currentTask = null;
+  let taskIndent = 0;
+  let taskHasRoleAssignment = false;
+  const getOrAddRole = (label, line, color) => {
+    const display = displayName(label);
+    if (!display) {
+      errorAt(line, "Role name is empty.");
+      return null;
+    }
+    const key = normalizeName(display);
+    const existing = roleStore.get(key);
+    if (existing) {
+      if (existing.displayName !== display) {
+        warn(
+          line,
+          nameMergedMessage({
+            incomingDisplay: display,
+            incomingLine: line,
+            existingDisplay: existing.displayName,
+            existingLine: existing.declaredLine
+          }),
+          NAME_DIAGNOSTIC_CODES.NAME_MERGED
+        );
+      }
+      if (color !== void 0) {
+        const idx = result.roles.indexOf(key);
+        if (idx >= 0) result.roleColors[idx] = color;
+      }
+      return key;
+    }
+    roleStore.set(key, { displayName: display, declaredLine: line });
+    result.roles.push(key);
+    result.roleDisplayNames.push(display);
+    result.roleColors.push(color);
+    return key;
+  };
+  const registerTask = (display, line) => {
+    const key = normalizeName(display);
+    const existing = taskStore.get(key);
+    if (existing) {
+      if (existing.displayName !== display) {
+        warn(
+          line,
+          nameMergedMessage({
+            incomingDisplay: display,
+            incomingLine: line,
+            existingDisplay: existing.displayName,
+            existingLine: existing.declaredLine
+          }),
+          NAME_DIAGNOSTIC_CODES.NAME_MERGED
+        );
+      }
+    } else {
+      taskStore.set(key, { displayName: display, declaredLine: line });
+    }
+    return key;
+  };
+  const finalizeTask = (uptoLineExclusive) => {
+    if (!currentTask) return;
+    let end = uptoLineExclusive - 1;
+    while (end > currentTask.lineNumber && !lines[end - 1].trim()) end--;
+    currentTask.endLineNumber = end;
+    if (currentPhase) currentPhase.endLineNumber = end;
+    currentTask = null;
+    taskHasRoleAssignment = false;
+  };
+  const finalizePhase = (uptoLineExclusive) => {
+    if (currentTask) finalizeTask(uptoLineExclusive);
+    if (currentPhase) {
+      let end = uptoLineExclusive - 1;
+      while (end > currentPhase.lineNumber && !lines[end - 1].trim()) end--;
+      currentPhase.endLineNumber = Math.max(currentPhase.endLineNumber, end);
+      currentPhase = null;
+    }
+  };
+  for (; i < lines.length; i++) {
+    const raw = lines[i];
+    const lineNumber = i + 1;
+    const trimmed = raw.trim();
+    const indent = measureIndent(raw);
+    if (!trimmed) continue;
+    if (trimmed.startsWith("//")) continue;
+    if (!bodyStarted && indent === 0 && !PHASE_RE.test(trimmed)) {
+      if (trimmed.toLowerCase() === "roles") {
+        rolesExplicit = true;
+        let j = i + 1;
+        for (; j < lines.length; j++) {
+          const next = lines[j];
+          const nextTrim = next.trim();
+          if (!nextTrim) continue;
+          if (nextTrim.startsWith("//")) continue;
+          if (next.length > 0 && next[0] !== " " && next[0] !== "	") break;
+          const stripped = nextTrim.replace(/,\s*$/, "");
+          const split = splitNameAndMeta(
+            stripped,
+            RACI_REGISTRY,
+            /* @__PURE__ */ new Map(),
+            void 0,
+            result.diagnostics,
+            j + 1
+          );
+          warnUnknownMetaKeys(
+            split.meta,
+            RACI_REGISTRY,
+            (msg) => warn(j + 1, msg),
+            split.name
+          );
+          const roleLabel = split.name;
+          let roleColor;
+          const colorRaw = split.color ?? split.meta["color"];
+          if (colorRaw) {
+            roleColor = resolveColorWithDiagnostic(
+              colorRaw,
+              j + 1,
+              result.diagnostics,
+              palette
+            );
+          }
+          if (roleLabel) getOrAddRole(roleLabel, j + 1, roleColor);
+        }
+        i = j - 1;
+        continue;
+      }
+      const lower = trimmed.toLowerCase();
+      const removedMsg = REMOVED_BOOLEANS[lower];
+      if (removedMsg) {
+        warn(lineNumber, removedMsg);
+        continue;
+      }
+      if (KNOWN_BOOLEANS.has(lower)) {
+        options[lower] = "on";
+        continue;
+      }
+      if (tryParseSharedOption(trimmed, options)) continue;
+      const optMatch = trimmed.match(OPTION_NOCOLON_RE);
+      if (optMatch) {
+        const key = optMatch[1].trim().toLowerCase();
+        if (KNOWN_OPTIONS.has(key)) {
+          const value = optMatch[2].trim();
+          if (key === "roles") {
+            rolesExplicit = true;
+            const declared = value.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+            for (const rawRole of declared) {
+              getOrAddRole(rawRole, lineNumber);
+            }
+          } else {
+            options[key] = value;
+          }
+          continue;
+        }
+      }
+    }
+    if (indent === 0) {
+      const phaseMatch = trimmed.match(PHASE_RE);
+      if (phaseMatch) {
+        bodyStarted = true;
+        finalizePhase(lineNumber);
+        const label = phaseMatch[1].trim();
+        const display = displayName(label);
+        if (!display) {
+          errorAt(lineNumber, "Phase label is empty.");
+          continue;
+        }
+        let phaseColor;
+        const tail = (phaseMatch[2] ?? "").trim();
+        const colorMatch = tail.match(PHASE_PALETTE_COLOR_RE);
+        if (colorMatch) {
+          phaseColor = resolveColorWithDiagnostic(
+            colorMatch[1],
+            lineNumber,
+            result.diagnostics,
+            palette
+          );
+        }
+        currentPhase = {
+          id: normalizeName(display),
+          displayName: display,
+          ...phaseColor !== void 0 && { color: phaseColor },
+          tasks: [],
+          lineNumber,
+          endLineNumber: lineNumber
+        };
+        result.phases.push(currentPhase);
+        continue;
+      }
+    }
+    const startTask = () => {
+      const display = displayName(trimmed);
+      if (!display) {
+        errorAt(lineNumber, "Task name is empty.");
+        return;
+      }
+      const taskId = registerTask(display, lineNumber);
+      const task = {
+        id: taskId,
+        displayName: display,
+        description: "",
+        roleAssignments: [],
+        lineNumber,
+        endLineNumber: lineNumber
+      };
+      if (currentPhase) {
+        currentPhase.tasks.push(task);
+      } else {
+        result.tasksWithoutPhase.push(task);
+      }
+      currentTask = task;
+      taskIndent = indent;
+      taskHasRoleAssignment = false;
+    };
+    if (indent === 0 && !currentPhase) {
+      bodyStarted = true;
+      finalizeTask(lineNumber);
+      startTask();
+      continue;
+    }
+    if (indent === 0 && currentPhase) {
+      bodyStarted = true;
+      finalizePhase(lineNumber);
+      startTask();
+      continue;
+    }
+    if (currentPhase && indent > 0 && (!currentTask || indent <= taskIndent)) {
+      bodyStarted = true;
+      finalizeTask(lineNumber);
+      startTask();
+      continue;
+    }
+    if (currentTask && indent > taskIndent) {
+      const task = currentTask;
+      const parsedAssign = parseRoleAssignmentLine(trimmed);
+      if (parsedAssign) {
+        const { rawRole, markersBlob } = parsedAssign;
+        const markers = [];
+        const tokens = [];
+        for (const tok of markersBlob.split(/\s+/)) {
+          if (!tok) continue;
+          for (const ch of tok) tokens.push(ch);
+        }
+        for (const tok of tokens) {
+          if (ALL_MARKERS.has(tok)) {
+            markers.push(tok);
+          } else {
+            result.diagnostics.push(
+              emit(RACI_DX.INVALID_MARKER, lineNumber, { marker: tok })
+            );
+          }
+        }
+        const roleId = getOrAddRole(rawRole, lineNumber);
+        if (roleId === null) continue;
+        if (rolesExplicit) {
+          const entry = roleStore.get(roleId);
+          if (entry?.declaredLine === lineNumber) {
+            const candidates = result.roleDisplayNames.filter(
+              (n) => n !== entry.displayName
+            );
+            const hint = suggest(rawRole, candidates);
+            result.diagnostics.push(
+              emit(RACI_DX.UNKNOWN_ROLE, lineNumber, {
+                role: rawRole,
+                hint: hint ?? ""
+              })
+            );
+          }
+        }
+        const assignment = {
+          id: roleId,
+          displayName: roleStore.get(roleId).displayName,
+          markers,
+          lineNumber,
+          endLineNumber: lineNumber
+        };
+        task.roleAssignments.push(assignment);
+        task.endLineNumber = lineNumber;
+        taskHasRoleAssignment = true;
+        continue;
+      }
+      if (!taskHasRoleAssignment) {
+        task.description = task.description ? task.description + "\n" + trimmed : trimmed;
+        task.endLineNumber = lineNumber;
+        continue;
+      }
+      result.diagnostics.push(
+        emit(RACI_DX.UNEXPECTED_LINE, lineNumber, { task: task.displayName })
+      );
+      continue;
+    }
+    if (bodyStarted) {
+      errorAt(
+        lineNumber,
+        `Unexpected line: '${trimmed}'. In the body expect a '[Phase]' header, an indented task name, or an assignment 'Role: A R C I' under a task. (\xA724A)`
+      );
+    } else {
+      warn(lineNumber, `Unrecognized directive: '${trimmed}'.`);
+    }
+  }
+  finalizePhase(lines.length + 1);
+  const usedMarkers = [];
+  for (const task of allTasks(result)) {
+    for (const a of task.roleAssignments) {
+      for (const m of a.markers) usedMarkers.push(m);
+    }
+  }
+  const inferred = inferVariant(usedMarkers);
+  if (inferred === null) {
+    const titleLine = result.titleLineNumber ?? 1;
+    result.diagnostics.push(emit(RACI_DX.MIXED_VARIANTS, titleLine));
+    result.variant = "rasci";
+  } else {
+    result.variant = inferred;
+  }
+  const resolvedAlphabet = VARIANTS[result.variant].alphabet;
+  for (const task of allTasks(result)) {
+    for (const a of task.roleAssignments) {
+      const kept = [];
+      for (const m of a.markers) {
+        if (resolvedAlphabet.includes(m)) {
+          kept.push(m);
+        } else {
+          result.diagnostics.push(
+            emit(RACI_DX.INVALID_MARKER, a.lineNumber, {
+              marker: m,
+              variant: result.variant.toUpperCase(),
+              alphabet: resolvedAlphabet.join(" ")
+            })
+          );
+        }
+      }
+      a.markers = kept;
+    }
+  }
+  const variantRules = VARIANTS[result.variant];
+  for (const task of allTasks(result)) {
+    for (const rule of variantRules.errorRules) {
+      result.diagnostics.push(...rule(task));
+    }
+    for (const rule of variantRules.warningRules) {
+      result.diagnostics.push(...rule(task));
+    }
+  }
+  const usedRoleIds = /* @__PURE__ */ new Set();
+  for (const task of allTasks(result)) {
+    for (const a of task.roleAssignments) {
+      if (a.markers.length > 0) usedRoleIds.add(a.id);
+    }
+  }
+  for (let i2 = 0; i2 < result.roles.length; i2++) {
+    const roleId = result.roles[i2];
+    if (usedRoleIds.has(roleId)) continue;
+    const declared = roleStore.get(roleId);
+    const displayName2 = result.roleDisplayNames[i2] ?? roleId;
+    result.diagnostics.push(
+      emit(RACI_DX.ORPHAN_ROLE, declared?.declaredLine ?? 1, {
+        role: displayName2
+      })
+    );
+  }
+  return result;
+}
+function* allTasks(parsed) {
+  for (const t of parsed.tasksWithoutPhase) yield t;
+  for (const phase of parsed.phases) {
+    for (const t of phase.tasks) yield t;
+  }
+}
+
+export {
+  RACI_DIAGNOSTICS,
+  RACI_ERROR_CODES,
+  RACI_WARNING_CODES,
+  VARIANTS,
+  parseRaci,
+  allTasks
+};
+//# sourceMappingURL=chunk-RYEGFMUO.js.map