@jpeakai/mermaidjs-lint 0.4.2 → 0.6.0

package/dist/testing.js

@@ -47,6 +47,14 @@ class RuleOptionError extends UsageError {
     this.option = option;
   }
 }
+
+class CanvasProfileError extends UsageError {
+  file;
+  constructor(file) {
+    super(`${file}: a canvas applies under the github profile only, and this file is scored under mkdocs-material, whose page is Material's own; drop the canvas for it, or pass --profile github`, "canvas-profile");
+    this.file = file;
+  }
+}
 class FixNotConvergingError extends MermaidLintError {
   file;
   rules;
@@ -215,6 +223,7 @@ var getMermaid = async () => {
   mermaidCore = (await import("mermaid")).default;
   return mermaidCore;
 };
+var getMermaidCore = async () => await getMermaid();
 var LANGIUM_TYPES = {
   "architecture-beta": "architecture",
   architecture: "architecture",
@@ -860,15 +869,27 @@ var MKDOCS_MATERIAL = {
   light: { bg: "#ffffff", text: "#36464e" },
   dark: { bg: "#1e2129", text: "hsl(225 18% 86% / 0.82)" }
 };
-var GITHUB = { light: { bg: "#ffffff" }, dark: { bg: "#0d1117" } };
+var GITHUB_CANVAS = { light: "#ffffff", dark: "#0d1117" };
 var THEMES = ["light", "dark"];
+var canvasColourProblem = (value) => {
+  if (typeof value !== "string")
+    return "is not a colour string";
+  let alpha;
+  try {
+    alpha = alphaOf(value);
+  } catch {
+    return "is not a CSS colour";
+  }
+  return alpha < 1 ? "is translucent, and a page canvas must be opaque" : null;
+};
+var resolveCanvas = (setting) => ({ ...GITHUB_CANVAS, ...setting });
 var MERMAID_EDGE_LABEL = {
   light: { box: "rgba(232,232,232,0.8)", backing: "rgba(232,232,232,0.5)" },
   dark: { box: "#585858", backing: "rgba(88,88,88,0.5)" }
 };
-var edgeLabelBackground = (theme) => {
+var edgeLabelBackground = (theme, canvas = GITHUB_CANVAS) => {
   const { box, backing } = MERMAID_EDGE_LABEL[theme];
-  return compositeOver(box, compositeOver(box, compositeOver(backing, GITHUB[theme].bg)));
+  return compositeOver(box, compositeOver(box, compositeOver(backing, canvas[theme])));
 };
 var MERMAID_ER = {
   light: { odd: "#ffffff", even: "#f1f1ff", label: "#333333" },
@@ -890,12 +911,12 @@ var scorePair = (kind, d, fg, bg) => {
   };
 };
 var message = (err) => err instanceof Error ? err.message : String(err);
-var scoreEdgeLabel = (d, pairs, skipped) => {
+var scoreEdgeLabel = (d, canvas, pairs, skipped) => {
   const { color } = d.properties;
   if (!color)
     return;
   try {
-    pairs.push(...THEMES.map((t) => scoreHostPair("text", d, t, color, edgeLabelBackground(t))));
+    pairs.push(...THEMES.map((t) => scoreHostPair("text", d, t, color, edgeLabelBackground(t, canvas))));
   } catch (err) {
     skipped.push({
       selector: d.selector,
@@ -905,12 +926,12 @@ var scoreEdgeLabel = (d, pairs, skipped) => {
     });
   }
 };
-var scoreGithub = (directives) => {
+var scoreGithub = (directives, canvas = GITHUB_CANVAS) => {
   const pairs = [];
   const skipped = [];
   for (const d of directives) {
     if (d.kind === "linkStyle")
-      scoreEdgeLabel(d, pairs, skipped);
+      scoreEdgeLabel(d, canvas, pairs, skipped);
     if (d.kind !== "classDef" && d.kind !== "style")
       continue;
     const { fill, color, stroke } = d.properties;
@@ -932,7 +953,7 @@ var scoreGithub = (directives) => {
       note("fill is fully transparent, so there is no box to anchor contrast");
       continue;
     }
-    const boxes = alpha < 1 ? THEMES.map((t) => [compositeOver(fill, GITHUB[t].bg), t]) : [[fill, undefined]];
+    const boxes = alpha < 1 ? THEMES.map((t) => [compositeOver(fill, canvas[t]), t]) : [[fill, undefined]];
     if (!color) {
       note("no color: declared beside fill:, and the github profile requires one " + "(if the host forces label text, use the mkdocs-material profile)", true);
     }
@@ -1065,11 +1086,144 @@ var scoreEr = (directives) => {
   }
   return { pairs, skipped };
 };
-var scoreForProfile = (directives, profile, keyword) => {
+var scoreForProfile = (directives, profile, keyword, canvas = GITHUB_CANVAS) => {
   if (profile === "mkdocs-material")
     return scoreMkdocs(directives);
-  return keyword === "erDiagram" ? scoreEr(directives) : scoreGithub(directives);
+  return keyword === "erDiagram" ? scoreEr(directives) : scoreGithub(directives, canvas);
+};
+var SEQUENCE_THEMES = ["base", "default", "dark", "forest", "neutral"];
+var LINE = { NOTE: 2, ACTIVE_START: 17, RECT_START: 22, AUTONUMBER: 26 };
+var FRAME_STARTS = new Set([10, 12, 15, 19, 27, 30, 32]);
+var sequenceFeatures = (db) => {
+  const messages = db.getMessages();
+  const has = (type) => messages.some((m) => m.type === type);
+  return {
+    humanActor: [...db.getActors().values()].some((a) => a.type === "actor"),
+    note: has(LINE.NOTE),
+    frame: messages.some((m) => FRAME_STARTS.has(m.type)),
+    activation: has(LINE.ACTIVE_START),
+    numbered: messages.some((m) => m.type === LINE.AUTONUMBER && m.message?.visible !== false),
+    rects: messages.filter((m) => m.type === LINE.RECT_START).map((m) => String(m.message))
+  };
+};
+var resolveVariables = (mermaid, config, themes) => {
+  const prior = mermaid.mermaidAPI.getSiteConfig();
+  try {
+    const out = {};
+    for (const t of THEMES) {
+      mermaid.initialize({ ...structuredClone(config), theme: themes[t] });
+      out[t] = { ...mermaid.mermaidAPI.getSiteConfig().themeVariables };
+    }
+    return out;
+  } finally {
+    mermaid.initialize(prior);
+  }
 };
+var themeVariable = (selector, line) => ({
+  kind: "themeVariables",
+  selector,
+  properties: {},
+  spans: {},
+  line
+});
+var scoreSequence = async (source, profile, canvas = GITHUB_CANVAS) => {
+  const pairs = [];
+  const skipped = [];
+  const lines = source.split(`
+`);
+  const keywordLine = lines.findIndex((l) => /^\s*sequenceDiagram\b/.test(l)) + 1;
+  const lineOf = (key) => {
+    const found = lines.findLastIndex((l) => new RegExp(`\\b${key}["']?\\s*:`).test(l));
+    return found < 0 ? keywordLine : found + 1;
+  };
+  const rectLines = lines.flatMap((l, i) => /^\s*rect\s/.test(l) ? [i + 1] : []);
+  const mermaid = await getMermaidCore();
+  let config;
+  let db;
+  try {
+    config = (await mermaid.parse(source)).config;
+    db = (await mermaid.mermaidAPI.getDiagramFromText(source)).db;
+  } catch {
+    return { pairs, skipped };
+  }
+  const block = (selector, reason) => {
+    skipped.push({ selector, line: lineOf(selector), reason, blocking: true });
+    return { pairs, skipped };
+  };
+  if (config.themeCSS !== undefined)
+    return block("themeCSS", "themeCSS restyles the diagram with CSS the audit cannot model");
+  const pinned = config.theme;
+  if (pinned !== undefined && !SEQUENCE_THEMES.includes(String(pinned))) {
+    return block("theme", `the ${String(pinned)} theme is not modelled, only ${SEQUENCE_THEMES.join(", ")}`);
+  }
+  const features = sequenceFeatures(db);
+  const host = profile === "mkdocs-material";
+  const theme = (fallback) => pinned === undefined ? fallback : String(pinned);
+  let variables;
+  try {
+    variables = resolveVariables(mermaid, config, { light: theme("default"), dark: theme(host ? "default" : "dark") });
+  } catch (err) {
+    return block("themeVariables", `Mermaid could not resolve the theme: ${message(err)}`);
+  }
+  for (const t of THEMES) {
+    const page = host ? MKDOCS_MATERIAL[t].bg : canvas[t];
+    const vars = variables[t];
+    const color = (key) => {
+      const value = vars[key];
+      if (typeof value !== "string")
+        throw new Error(`${key} is not a resolved colour`);
+      return value;
+    };
+    const pair = (kind, fgKey, bg, suffix = "", at) => {
+      const selector = fgKey + suffix;
+      const line = at ?? lineOf(fgKey);
+      try {
+        const box = compositeOver("key" in bg ? color(bg.key) : bg.colour, page);
+        pairs.push({ ...scoreHostPair(kind, themeVariable(selector, line), t, color(fgKey), box), advisory: host });
+      } catch (err) {
+        skipped.push({ selector, line, reason: `${t} sequence pair unparseable: ${message(err)}`, blocking: true });
+      }
+    };
+    const onPage = { colour: page };
+    if (host) {
+      pair("border", "actorLineColor", onPage);
+      pair("border", "signalColor", onPage, " (arrowhead)");
+      if (features.activation)
+        pair("border", "activationBorderColor", { key: "activationBkgColor" });
+      continue;
+    }
+    pair("text", "actorTextColor", { key: "actorBkg" });
+    pair("border", "actorBorder", { key: "actorBkg" });
+    if (features.humanActor) {
+      pair("text", "actorTextColor", onPage, " (human actor label)");
+      pair("border", "actorBorder", onPage, " (human actor glyph)");
+    }
+    pair("border", "actorLineColor", onPage);
+    pair("text", "signalTextColor", onPage);
+    pair("border", "signalColor", onPage);
+    if (features.note)
+      pair("text", "noteTextColor", { key: "noteBkgColor" });
+    if (features.frame) {
+      pair("text", "labelTextColor", { key: "labelBoxBkgColor" });
+      pair("text", "loopTextColor", onPage);
+      pair("border", "labelBoxBorderColor", onPage, " (loop frame)");
+    }
+    if (features.activation)
+      pair("border", "activationBorderColor", { key: "activationBkgColor" });
+    if (features.numbered)
+      pair("text", "sequenceNumberColor", { key: "signalColor" });
+    for (const [i, rect] of features.rects.entries()) {
+      const fill = { colour: rect };
+      const at = rectLines[i];
+      pair("text", "signalTextColor", fill, " (rect)", at);
+      pair("border", "signalColor", fill, " (rect)", at);
+      if (features.frame)
+        pair("text", "loopTextColor", fill, " (rect)", at);
+    }
+  }
+  return { pairs, skipped };
+};
+var scoreDiagram = (source, directives, profile, keyword, canvas = GITHUB_CANVAS) => keyword === "sequenceDiagram" ? scoreSequence(source, profile, canvas) : Promise.resolve(scoreForProfile(directives, profile, keyword, canvas));
 var detectProfile = (filePath) => {
   let dir = dirname(resolve(filePath));
   for (let i = 0;i < 20; i++) {
@@ -1233,7 +1387,7 @@ var COMPLEXITY_OPTIONS = {
   subgraphWeight: "number",
   depthWeight: "number"
 };
-var CONTRAST_OPTIONS = { profile: "string" };
+var CONTRAST_OPTIONS = { profile: "string", canvas: "canvas" };
 var measure = async (diagram, config) => {
   const stats = await diagram.stats();
   if (parseFailed(diagram.source, stats))
@@ -1263,17 +1417,35 @@ var profileOf = (ctx) => {
   }
   return wanted === "auto" ? detectProfile(ctx.file) : wanted;
 };
+var settingsOf = (ctx) => {
+  const profile = profileOf(ctx);
+  const setting = ctx.options.canvas;
+  if (setting === undefined)
+    return { profile, canvas: GITHUB_CANVAS };
+  for (const side of THEMES) {
+    if (!(side in setting))
+      continue;
+    const problem = canvasColourProblem(setting[side]);
+    if (problem)
+      throw new Error(`canvas.${side} ${problem}: ${JSON.stringify(setting[side])}`);
+  }
+  if (profile === "mkdocs-material")
+    throw new CanvasProfileError(ctx.file);
+  return { profile, canvas: resolveCanvas(setting) };
+};
 var scored = new WeakMap;
-var contrastOf = (diagram, profile) => {
-  let byProfile = scored.get(diagram);
-  if (!byProfile) {
-    byProfile = new Map;
-    scored.set(diagram, byProfile);
+var contrastOf = (diagram, settings) => {
+  const { profile, canvas } = settings;
+  const key = `${profile}\x00${canvas.light}\x00${canvas.dark}`;
+  let bySettings = scored.get(diagram);
+  if (!bySettings) {
+    bySettings = new Map;
+    scored.set(diagram, bySettings);
   }
-  let result = byProfile.get(profile);
+  let result = bySettings.get(key);
   if (!result) {
-    result = scoreForProfile(diagram.directives, profile, diagram.keyword);
-    byProfile.set(profile, result);
+    result = scoreDiagram(diagram.source, diagram.directives, profile, diagram.keyword, canvas);
+    bySettings.set(key, result);
   }
   return result;
 };
@@ -1384,11 +1556,11 @@ var contrastBorderBelowUiMinimum = {
   category: "contrast",
   summary: "a border below 3:1 against its fill",
   options: CONTRAST_OPTIONS,
-  check: (ctx) => {
-    const profile = profileOf(ctx);
+  check: async (ctx) => {
+    const settings = settingsOf(ctx);
     const found = [];
     for (const diagram of ctx.doc.diagrams) {
-      for (const p of contrastOf(diagram, profile).pairs) {
+      for (const p of (await contrastOf(diagram, settings)).pairs) {
         if (p.kind !== "border" || p.passes || p.advisory)
           continue;
         const line = fileLine(diagram, p.line);
@@ -1398,7 +1570,7 @@ var contrastBorderBelowUiMinimum = {
           endLine: line,
           rule: RULE.BORDER,
           message: `${p.directive.kind} ${p.selector}: border ${p.assessment.ratio.toFixed(2)}:1 < ${AA_NON_TEXT2} ` + `(${p.foreground} on ${p.background}${p.theme ? `, ${p.theme}` : ""})`,
-          remediation: "Darken the stroke or lighten the fill until the ratio reaches 3:1."
+          remediation: p.directive.kind === "themeVariables" ? "Set the theme variable to a colour that reaches 3:1 on its background in both themes, or remove it and let the theme set it." : "Darken the stroke or lighten the fill until the ratio reaches 3:1."
         });
       }
     }
@@ -1412,11 +1584,11 @@ var contrastDirectiveUnauditable = {
   category: "contrast",
   summary: "a style directive whose contrast cannot be audited",
   options: CONTRAST_OPTIONS,
-  check: (ctx) => {
-    const profile = profileOf(ctx);
+  check: async (ctx) => {
+    const settings = settingsOf(ctx);
     const found = [];
     for (const diagram of ctx.doc.diagrams) {
-      for (const s of contrastOf(diagram, profile).skipped) {
+      for (const s of (await contrastOf(diagram, settings)).skipped) {
         if (!s.blocking)
           continue;
         const line = fileLine(diagram, s.line);
@@ -1426,7 +1598,7 @@ var contrastDirectiveUnauditable = {
           endLine: line,
           rule: RULE.UNAUDITABLE,
           message: `${s.selector}: unaudited, ${s.reason}`,
-          remediation: "Declare the missing property or fix the colour so the pair can be scored."
+          remediation: "Declare the missing property, fix the colour, or remove the config the audit cannot model, so the pair can be scored."
         });
       }
     }
@@ -1443,11 +1615,11 @@ var contrastTextBelowAa = {
   category: "contrast",
   summary: "label text below 4.5:1 against its fill",
   options: CONTRAST_OPTIONS,
-  check: (ctx) => {
-    const profile = profileOf(ctx);
+  check: async (ctx) => {
+    const settings = settingsOf(ctx);
     const found = [];
     for (const diagram of ctx.doc.diagrams) {
-      for (const p of contrastOf(diagram, profile).pairs) {
+      for (const p of (await contrastOf(diagram, settings)).pairs) {
         if (p.kind !== "text" || p.passes)
           continue;
         const where = [p.theme, p.row].filter(Boolean).join("/");
@@ -1458,19 +1630,19 @@ var contrastTextBelowAa = {
           endLine: line,
           rule: RULE.TEXT,
           message: `${p.directive.kind} ${p.selector}: text ${p.assessment.ratio.toFixed(2)}:1 < ${AA_NORMAL2} ` + `(${p.foreground} on ${p.background}${where ? `, ${where}` : ""})`,
-          remediation: profile === "mkdocs-material" ? "The host theme forces the label text, so change the fill until the host text reads on it in both themes." : p.directive.kind === "linkStyle" ? "An edge label sits on Mermaid's own label box, light in one theme and grey in the other, and no one colour reads on both, so drop color: from the linkStyle and let the theme set the label text." : "Darken or lighten the fill, or change color:, until the ratio reaches 4.5:1 in every theme."
+          remediation: settings.profile === "mkdocs-material" ? "The host theme forces the label text, so change the fill until the host text reads on it in both themes." : p.directive.kind === "themeVariables" ? "A sequence diagram colour is a theme variable, and text with no box of its own sits on the page, so set the variable to a colour that reads on its background in both themes, or remove it and let the theme set it." : p.directive.kind === "linkStyle" ? "An edge label sits on Mermaid's own label box, light in one theme and grey in the other, and no one colour reads on both, so drop color: from the linkStyle and let the theme set the label text." : "Darken or lighten the fill, or change color:, until the ratio reaches 4.5:1 in every theme."
         });
       }
     }
     return found;
   },
-  fix: (ctx) => {
-    const profile = profileOf(ctx);
-    if (profile === "mkdocs-material")
+  fix: async (ctx) => {
+    const settings = settingsOf(ctx);
+    if (settings.profile === "mkdocs-material")
       return [];
     const edits = [];
     for (const diagram of ctx.doc.diagrams) {
-      const { pairs } = contrastOf(diagram, profile);
+      const { pairs } = await contrastOf(diagram, settings);
       const failing = new Set(pairs.filter((p) => p.kind === "text" && !p.passes).map((p) => p.directive));
       for (const directive of failing) {
         const span = directive.spans.color;
@@ -1590,8 +1762,27 @@ var typeOf = (value) => {
     return "boolean";
   if (Array.isArray(value) && value.every((v) => typeof v === "string"))
     return "string[]";
+  if (isCanvasShape(value))
+    return "canvas";
   return null;
 };
+var isCanvasShape = (value) => {
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    return false;
+  const keys = Object.keys(value);
+  return keys.length > 0 && keys.every((k) => THEMES.includes(k));
+};
+var describeType = (want) => want === "canvas" ? 'an object such as { "light": "#ffffff", "dark": "#0d1117" }' : `a ${want}`;
+var checkCanvas = (where, rule, name, value) => {
+  for (const side of THEMES) {
+    if (!(side in value))
+      continue;
+    const problem = canvasColourProblem(value[side]);
+    if (problem) {
+      throw new RuleOptionError(where, rule.id, name, `option "${name}.${side}" of "${rule.id}" ${problem}: ${JSON.stringify(value[side])}`);
+    }
+  }
+};
 var checkOptions = (where, rule, options) => {
   const accepted = Object.keys(rule.options ?? {});
   for (const [name, value] of Object.entries(options)) {
@@ -1601,8 +1792,13 @@ var checkOptions = (where, rule, options) => {
       throw new RuleOptionError(where, rule.id, name, `rule "${rule.id}" has no option "${name}"; ${list}`);
     }
     if (typeOf(value) !== want) {
-      throw new RuleOptionError(where, rule.id, name, `option "${name}" of "${rule.id}" must be a ${want}`);
+      throw new RuleOptionError(where, rule.id, name, `option "${name}" of "${rule.id}" must be ${describeType(want)}`);
     }
+    if (want === "canvas")
+      checkCanvas(where, rule, name, value);
+  }
+  if (options.profile === "mkdocs-material" && options.canvas !== undefined && rule.options?.canvas === "canvas") {
+    throw new RuleOptionError(where, rule.id, "canvas", `option "canvas" of "${rule.id}" applies under the github profile only, and this rule sets profile mkdocs-material, whose page is Material's own`);
   }
   if (typeof options.preset === "string" && canonicalPreset(options.preset) === null) {
     throw new RuleOptionError(where, rule.id, "preset", `option "preset" of "${rule.id}" is not a known preset`);
@@ -1646,8 +1842,24 @@ var buildRegistry = (input) => {
 var BUILTIN = buildRegistry({ rules: RULES, fixOrder: FIX_ORDER, categories: BUILTIN_CATEGORIES });
 
 // src/check.ts
+var canvasName = (side, prefix) => prefix ? `${prefix}canvas-${side}` : `canvas.${side}`;
 var checkRunFlags = (flags, prefix = "") => {
-  const { preset, profile } = flags;
+  const { preset, profile, canvas } = flags;
+  for (const side of THEMES) {
+    if (canvas?.[side] === undefined)
+      continue;
+    const problem = canvasColourProblem(canvas[side]);
+    if (problem) {
+      const name = canvasName(side, prefix);
+      throw new FlagError(name, `${name} ${problem}: "${canvas[side]}"; give an opaque CSS colour, such as #ffffff`);
+    }
+  }
+  const sides = THEMES.filter((side) => canvas?.[side] !== undefined);
+  const first = sides[0];
+  if (profile === "mkdocs-material" && first !== undefined) {
+    const name = canvasName(first, prefix);
+    throw new FlagError(name, `${name} applies under the github profile only; mkdocs-material scores Material's own page colours`);
+  }
   if (preset !== undefined && canonicalPreset(preset) === null) {
     throw new FlagError(`${prefix}preset`, `${prefix}preset must be one of ${PRESET_NAMES.join(", ")}, not "${preset}"`);
   }
@@ -1664,6 +1876,17 @@ var optionsFor = (rule, configured, flags) => {
   }
   if (typeof options.preset === "string")
     options.preset = canonicalPreset(options.preset) ?? options.preset;
+  const canvas = flags.canvas;
+  if (canvas && THEMES.some((side) => canvas[side] !== undefined) && rule.options?.canvas === "canvas") {
+    const configured2 = typeof options.canvas === "object" && options.canvas !== null ? options.canvas : {};
+    const merged = { ...configured2 };
+    for (const side of THEMES) {
+      const value = canvas[side];
+      if (value !== undefined)
+        merged[side] = value;
+    }
+    options.canvas = merged;
+  }
   return options;
 };
 var checkModel = async (doc, file, flags = {}, registry = BUILTIN) => {
@@ -1829,7 +2052,7 @@ var RULE_KEY = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
 // src/plugins/load.ts
 var isRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
 var message2 = (err) => err instanceof Error ? err.message : String(err);
-var OPTION_TYPES = new Set(["number", "string", "boolean", "string[]"]);
+var OPTION_TYPES = new Set(["number", "string", "boolean", "string[]", "canvas"]);
 var RESERVED_OPTIONS = ["preset", "profile"];
 var checkRule = (spec, key, raw, own) => {
   const where = `rule "${key}"`;
@@ -1858,7 +2081,7 @@ var checkRule = (spec, key, raw, own) => {
   if (options !== undefined) {
     const valid = isRecord(options) && Object.values(options).every((t) => OPTION_TYPES.has(t));
     if (!valid) {
-      throw new PluginContractError(spec, `${where} options must map names to number, string, boolean or string[]`);
+      throw new PluginContractError(spec, `${where} options must map names to number, string, boolean, string[] or canvas`);
     }
     for (const name of RESERVED_OPTIONS) {
       if (name in options && options[name] !== "string") {

package/dist/types/check.d.ts

@@ -1,9 +1,11 @@
 import { type DocModel } from "./model.ts";
+import { type CanvasSetting } from "./parse/contrast.ts";
 import { type Registry } from "./rules/registry.ts";
 import type { Finding, Rule, RuleOptions } from "./rules/types.ts";
 export interface RunFlags {
     preset?: string;
     profile?: string;
+    canvas?: CanvasSetting;
 }
 export declare const checkRunFlags: (flags: RunFlags, prefix?: string) => void;
 export declare const optionsFor: (rule: Rule, configured: RuleOptions | undefined, flags: RunFlags) => RuleOptions;

package/dist/types/errors.d.ts

@@ -47,6 +47,10 @@ export declare class RuleOptionError extends UsageError {
     readonly option: string;
     constructor(file: string, rule: string, option: string, message: string);
 }
+export declare class CanvasProfileError extends UsageError {
+    readonly file: string;
+    constructor(file: string);
+}
 export declare class FixOutsideRootError extends UsageError {
     readonly file: string;
     readonly target: string;

package/dist/types/index.d.ts

@@ -6,6 +6,7 @@ export { type Collected, collectFiles } from "./files.ts";
 export { type FixReport, fixSource, fixSourceReport } from "./fix/engine.ts";
 export { buildDocModel, DIAGRAM_EXTS, type Diagram, type DocModel, documentKind } from "./model.ts";
 export type { ContrastAssessment, StyleDirective, ValueSpan } from "./parse/color.ts";
+export { type Canvas, type CanvasSetting, GITHUB_CANVAS } from "./parse/contrast.ts";
 export { PRESETS, type Preset, type ThresholdConfig, thresholdsFrom } from "./parse/metrics.ts";
 export { type DiagramStats, detectKeyword, extractStats } from "./parse/stats.ts";
 export type { Plugin, PluginEdit, PluginFinding, PluginMeta, PluginRule } from "./plugins/contract.ts";

package/dist/types/parse/contrast.d.ts

@@ -4,11 +4,20 @@ export type Theme = "light" | "dark";
 export type PairKind = "text" | "border";
 export type ErRow = "odd" | "even";
 export declare const PROFILES: readonly ["auto", "github", "mkdocs-material"];
-export declare const edgeLabelBackground: (theme: Theme) => string;
+export type Canvas = Readonly<Record<Theme, string>>;
+export type CanvasSetting = Readonly<Partial<Record<Theme, string>>>;
+export declare const GITHUB_CANVAS: Canvas;
+export declare const THEMES: readonly Theme[];
+export declare const canvasColourProblem: (value: unknown) => string | null;
+export declare const resolveCanvas: (setting: CanvasSetting | undefined) => Canvas;
+export declare const edgeLabelBackground: (theme: Theme, canvas?: Canvas) => string;
+export type ContrastSource = StyleDirective | (Omit<StyleDirective, "kind"> & {
+    kind: "themeVariables";
+});
 export interface ContrastPair {
     kind: PairKind;
     selector: string;
-    directive: StyleDirective;
+    directive: ContrastSource;
     foreground: string;
     background: string;
     line: number;
@@ -28,8 +37,29 @@ export interface ContrastResult {
     pairs: ContrastPair[];
     skipped: SkippedDirective[];
 }
-export declare const scoreGithub: (directives: StyleDirective[]) => ContrastResult;
+export declare const scoreGithub: (directives: StyleDirective[], canvas?: Canvas) => ContrastResult;
 export declare const scoreMkdocs: (directives: StyleDirective[]) => ContrastResult;
 export declare const scoreEr: (directives: StyleDirective[]) => ContrastResult;
-export declare const scoreForProfile: (directives: StyleDirective[], profile: Profile, keyword: string | null) => ContrastResult;
+export declare const scoreForProfile: (directives: StyleDirective[], profile: Profile, keyword: string | null, canvas?: Canvas) => ContrastResult;
+interface SequenceDb {
+    getActors: () => Map<string, {
+        type: string;
+    }>;
+    getMessages: () => Array<{
+        type: number;
+        message: unknown;
+    }>;
+}
+export interface SequenceFeatures {
+    humanActor: boolean;
+    note: boolean;
+    frame: boolean;
+    activation: boolean;
+    numbered: boolean;
+    rects: string[];
+}
+export declare const sequenceFeatures: (db: SequenceDb) => SequenceFeatures;
+export declare const scoreSequence: (source: string, profile: Profile, canvas?: Canvas) => Promise<ContrastResult>;
+export declare const scoreDiagram: (source: string, directives: StyleDirective[], profile: Profile, keyword: string | null, canvas?: Canvas) => Promise<ContrastResult>;
 export declare const detectProfile: (filePath: string) => Profile;
+export {};

package/dist/types/parse/stats.d.ts

@@ -1,3 +1,16 @@
+export interface MermaidCore {
+    parse: (text: string) => Promise<{
+        config: Record<string, unknown>;
+    }>;
+    initialize: (config: Record<string, unknown>) => void;
+    mermaidAPI: {
+        getSiteConfig: () => Record<string, unknown>;
+        getDiagramFromText: (text: string) => Promise<{
+            db: unknown;
+        }>;
+    };
+}
+export declare const getMermaidCore: () => Promise<MermaidCore>;
 export interface DiagramStats {
     nodes: number;
     edges: number;

package/dist/types/plugins/runtime.d.ts

@@ -3,4 +3,4 @@ export interface RuntimeInfo {
     features: Record<string, unknown>;
 }
 export declare const canImportTypeScript: (runtime?: RuntimeInfo) => boolean;
-export declare const TYPESCRIPT_HELP = "TypeScript cannot be imported by this runtime. Run with Bun (bunx --bun @jpeakai/mermaidjs-lint), use Node 22.18 or newer, or write a .js or .mjs file";
+export declare const TYPESCRIPT_HELP = "TypeScript cannot be imported by this runtime. Run with Bun (bunx --bun @jpeakai/mermaidjs-lint), use Node 22.18 or newer (23.6 or newer on Node 23), or write a .js or .mjs file";

package/dist/types/rules/shared.d.ts

@@ -1,5 +1,5 @@
 import type { Diagram } from "../model.ts";
-import { type ContrastResult, type Profile } from "../parse/contrast.ts";
+import { type Canvas, type ContrastResult, type Profile } from "../parse/contrast.ts";
 import { type ComplexityMetrics, type ThresholdConfig } from "../parse/metrics.ts";
 import type { DiagramStats } from "../parse/stats.ts";
 import type { Finding, OptionSpec, RuleContext, RuleId } from "./types.ts";
@@ -14,5 +14,10 @@ export declare const finding: (ctx: RuleContext, diagram: Diagram, rule: RuleId,
 export declare const boundaryHint: (boundaries: string[]) => string;
 export declare const splitTarget: (c: ThresholdConfig) => string;
 export declare const profileOf: (ctx: RuleContext) => Profile;
-export declare const contrastOf: (diagram: Diagram, profile: Profile) => ContrastResult;
+export interface ContrastSettings {
+    profile: Profile;
+    canvas: Canvas;
+}
+export declare const settingsOf: (ctx: RuleContext) => ContrastSettings;
+export declare const contrastOf: (diagram: Diagram, settings: ContrastSettings) => Promise<ContrastResult>;
 export declare const fileLine: (diagram: Diagram, line: number) => number;

package/dist/types/rules/types.d.ts

@@ -27,7 +27,7 @@ export interface Finding {
     message: string;
     remediation?: string;
 }
-export type OptionType = "number" | "string" | "boolean" | "string[]";
+export type OptionType = "number" | "string" | "boolean" | "string[]" | "canvas";
 export type OptionSpec = Readonly<Record<string, OptionType>>;
 export type RuleOptions = Readonly<Record<string, unknown>>;
 export interface Helpers {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jpeakai/mermaidjs-lint",
-  "version": "0.4.2",
+  "version": "0.6.0",
   "type": "module",
   "description": "Deterministic lint gates and verified fixers for Mermaid diagrams in markdown",
   "license": "MIT",
@@ -58,7 +58,7 @@
     "mdast-util-from-markdown": "^2.0.3",
     "mdast-util-frontmatter": "^2.0.1",
     "mdast-util-gfm": "^3.1.0",
-    "mermaid": "^11.14.0",
+    "mermaid": "11.17.2",
     "micromark-extension-frontmatter": "^2.0.0",
     "micromark-extension-gfm": "^3.0.0"
   },