@hawkeyexl/manni 4.11.0 → 4.12.0

package/dist/chunk-QDC7JPFG.js

@@ -0,0 +1,685 @@
+#!/usr/bin/env node
+import {
+  DEFAULT_ABSTRACT_MAX_LENGTH,
+  DEFAULT_CRAWL_MIN_PAGES,
+  DEFAULT_TERM_BASELINE_PATH,
+  TERM_MATCH_FIELDS,
+  TERM_RULES,
+  TermError,
+  languageKey,
+  loadTerms
+} from "./chunk-FKAZUZQU.js";
+import {
+  TERM_RELATION_FIELDS
+} from "./chunk-PS257NIU.js";
+import {
+  isErrorSeverity,
+  resolveBaselineRequest,
+  settleBaseline
+} from "./chunk-RGLFV4KO.js";
+
+// src/term/commands/check.ts
+import { existsSync } from "node:fs";
+
+// src/term/core/severity.ts
+var RULE_ID_PREFIX = "manni:term";
+var DEFAULT_SEVERITY = {
+  "undefined-term": "error",
+  "duplicate-id": "error",
+  "label-collision": "error",
+  "alt-label-collision": "error",
+  "label-overlap": "error",
+  "dangling-reference": "error",
+  "broader-cycle": "error",
+  "see-not-empty": "error",
+  "missing-definition": "error",
+  "conflicting-matches": "error",
+  "asymmetric-hierarchy": "warning",
+  "asymmetric-related": "warning",
+  "related-in-hierarchy": "warning",
+  "alt-label-reference": "warning",
+  "ambiguous-alt-label": "warning",
+  "deprecated-label": "warning",
+  "abstract-too-long": "notice",
+  "unused-term": "notice",
+  "hierarchy-outside-termbase": "notice",
+  "related-siblings": "notice",
+  "orphan-term": "notice",
+  "keyword-candidate": "notice"
+};
+function ruleId(rule) {
+  return `${RULE_ID_PREFIX}/${rule}`;
+}
+function proseRuleId(check) {
+  return `${RULE_ID_PREFIX}/prose/${check}`;
+}
+function isTermRule(value) {
+  return TERM_RULES.includes(value);
+}
+function resolveSeverity(overrides) {
+  return { ...DEFAULT_SEVERITY, ...overrides };
+}
+function foldValeSeverity(severity) {
+  return severity === "suggestion" ? "notice" : severity;
+}
+
+// src/term/core/check.ts
+var RETIRED_STATUSES = /* @__PURE__ */ new Set(["deprecated", "superseded"]);
+var REFERENCE_FIELDS = TERM_RELATION_FIELDS;
+function checkTermSet(set, opts = {}) {
+  const levels = resolveSeverity(opts.severity);
+  const maxLength = opts.abstractMaxLength ?? DEFAULT_ABSTRACT_MAX_LENGTH;
+  const { terms } = set;
+  const drafts = [];
+  const fold = (value) => value.toLowerCase();
+  const where = (t) => `${t.location.file}:${String(t.location.line)}`;
+  const onEntry = (t, rule, message, field) => ({
+    rule,
+    message,
+    file: t.location.file,
+    line: (field === void 0 ? void 0 : t.location.fieldLines[field]) ?? t.location.line,
+    id: t.id,
+    ...field === void 0 ? {} : { field }
+  });
+  const byLabel = /* @__PURE__ */ new Map();
+  const byId = /* @__PURE__ */ new Map();
+  const inLanguage = /* @__PURE__ */ new Map();
+  const byAlt = /* @__PURE__ */ new Map();
+  const labelled = /* @__PURE__ */ new Map();
+  const altHeld = /* @__PURE__ */ new Map();
+  const claim = (map, key, index) => {
+    if (!map.has(key)) map.set(key, index);
+  };
+  terms.forEach((t, index) => {
+    claim(byLabel, fold(t.record.label), index);
+    const group = labelled.get(fold(t.record.label));
+    if (group === void 0) labelled.set(fold(t.record.label), [index]);
+    else group.push(index);
+    claim(byId, fold(t.id), index);
+    claim(inLanguage, `${languageKey(t)} label ${fold(t.record.label)}`, index);
+    claim(inLanguage, `${languageKey(t)} id ${fold(t.id)}`, index);
+    for (const alt of t.record["alt-labels"] ?? []) {
+      claim(byAlt, fold(alt), index);
+      claim(inLanguage, `${languageKey(t)} alt ${fold(alt)}`, index);
+      const holders = altHeld.get(fold(alt));
+      if (holders === void 0) altHeld.set(fold(alt), /* @__PURE__ */ new Set([index]));
+      else holders.add(index);
+    }
+  });
+  const clash = (t, a, other, b) => fold(a) === fold(b) && (languageKey(t) === languageKey(other) || a !== b);
+  const collider = (t, index, value, before) => {
+    for (const otherIndex of labelled.get(fold(value)) ?? []) {
+      if (otherIndex === index || before && otherIndex > index) continue;
+      const other = terms[otherIndex];
+      if (other !== void 0 && clash(t, value, other, other.record.label)) return other;
+    }
+    return void 0;
+  };
+  const altCollider = (t, index, value, before) => {
+    for (const otherIndex of altHeld.get(fold(value)) ?? []) {
+      if (otherIndex === index || before && otherIndex > index) continue;
+      const other = terms[otherIndex];
+      const alt = other?.record["alt-labels"]?.find((a) => fold(a) === fold(value));
+      if (other !== void 0 && alt !== void 0 && clash(t, value, other, alt)) return other;
+    }
+    return void 0;
+  };
+  const resolveReference = (from, value) => inLanguage.get(`${languageKey(from)} label ${fold(value)}`) ?? inLanguage.get(`${languageKey(from)} id ${fold(value)}`) ?? byLabel.get(fold(value)) ?? byId.get(fold(value));
+  const tagOf = (tag) => tag === void 0 || tag === "" ? void 0 : fold(tag);
+  const primaryOf = (tag) => tag.split("-")[0] ?? "";
+  const ids = /* @__PURE__ */ new Map();
+  const alts = /* @__PURE__ */ new Map();
+  const list = (map, key, index) => {
+    const held = map.get(key);
+    if (held === void 0) map.set(key, [index]);
+    else held.push(index);
+  };
+  terms.forEach((t, index) => {
+    list(ids, fold(t.id), index);
+    for (const alt of t.record["alt-labels"] ?? []) list(alts, fold(alt), index);
+  });
+  const tiers = [
+    [labelled, false],
+    [ids, false],
+    [alts, true]
+  ];
+  const resolvePageName = (value, lang) => {
+    const wanted = tagOf(lang);
+    const passes = wanted === void 0 ? [() => true] : [
+      (t) => tagOf(t.language) === wanted,
+      (t) => {
+        const own = tagOf(t.language);
+        return own !== void 0 && primaryOf(own) === primaryOf(wanted);
+      },
+      () => true
+    ];
+    for (const pass of passes) {
+      for (const [map, alt] of tiers) {
+        const index = map.get(fold(value))?.find((i) => {
+          const t = terms[i];
+          return t !== void 0 && pass(t);
+        });
+        if (index !== void 0) return { index, alt };
+      }
+    }
+    return void 0;
+  };
+  const resolveName = (value, lang) => resolvePageName(value, lang)?.index;
+  const usedIds = /* @__PURE__ */ new Set();
+  for (const reference of set.references) {
+    const field = reference.field ?? "concepts";
+    const at = { file: reference.file, ...reference.line === void 0 ? {} : { line: reference.line } };
+    const hit = resolvePageName(reference.label, reference.language);
+    const target = terms[hit?.index ?? -1];
+    if (target !== void 0) usedIds.add(fold(target.id));
+    if (hit !== void 0 && !hit.alt) continue;
+    drafts.push(
+      target === void 0 ? { rule: "undefined-term", message: `${field}: "${reference.label}" names no entry.`, ...at } : {
+        rule: "alt-label-reference",
+        message: `${field}: "${reference.label}" is an alt-label of "${target.record.label}", so name the label.`,
+        ...at
+      }
+    );
+  }
+  const sharing = /* @__PURE__ */ new Map();
+  for (const t of terms) {
+    const id = `${languageKey(t)} ${fold(t.id)}`;
+    const group = sharing.get(id);
+    if (group === void 0) sharing.set(id, [t]);
+    else group.push(t);
+  }
+  for (const group of sharing.values()) {
+    if (group.length < 2) continue;
+    for (const t of group) {
+      const others = group.filter((other) => other !== t).map(where);
+      drafts.push(onEntry(t, "duplicate-id", `id: "${t.id}" is also used by ${others.join(", ")}`));
+    }
+  }
+  terms.forEach((t, index) => {
+    const firstTerm = collider(t, index, t.record.label, true);
+    if (firstTerm !== void 0) {
+      drafts.push(
+        onEntry(
+          t,
+          "label-collision",
+          `"${t.record.label}" is claimed by ${where(firstTerm)} as "${firstTerm.record.label}"`,
+          "label"
+        )
+      );
+    }
+    for (const alt of t.record["alt-labels"] ?? []) {
+      const owner = collider(t, index, alt, false);
+      if (owner !== void 0) {
+        drafts.push(
+          onEntry(t, "alt-label-collision", `alt-labels: "${alt}" is the label of ${where(owner)}`, "alt-labels")
+        );
+      }
+      if (fold(alt) === fold(t.record.label)) {
+        drafts.push(onEntry(t, "label-overlap", `alt-labels: "${alt}" repeats this entry's label.`, "alt-labels"));
+      }
+      const sharer = altCollider(t, index, alt, true);
+      if (sharer !== void 0) {
+        drafts.push(
+          onEntry(
+            t,
+            "ambiguous-alt-label",
+            `alt-labels: "${alt}" is also an alt-label of ${where(sharer)}, so a reader can't tell which term it means.`,
+            "alt-labels"
+          )
+        );
+      }
+    }
+    const ownAlts = new Set((t.record["alt-labels"] ?? []).map(fold));
+    for (const hidden of t.record["hidden-labels"] ?? []) {
+      const labelOf = collider(t, index, hidden, false);
+      const altOf = labelOf === void 0 ? altCollider(t, index, hidden, false) : void 0;
+      const overlap = fold(hidden) === fold(t.record.label) ? "repeats this entry's label." : ownAlts.has(fold(hidden)) ? "repeats this entry's alt-label." : labelOf !== void 0 ? `is the label of ${where(labelOf)}.` : altOf !== void 0 ? `is an alt-label of ${where(altOf)}.` : void 0;
+      if (overlap !== void 0) {
+        drafts.push(onEntry(t, "label-overlap", `hidden-labels: "${hidden}" ${overlap}`, "hidden-labels"));
+      }
+    }
+    const status = t.record.designations?.find((d) => fold(d.term) === fold(t.record.label))?.["administrative-status"];
+    if (t.record.see === void 0 && status !== void 0 && RETIRED_STATUSES.has(fold(status))) {
+      drafts.push(
+        onEntry(
+          t,
+          "deprecated-label",
+          `label: "${t.record.label}" is deprecated in designations, so promote another label or redirect with see:.`,
+          "label"
+        )
+      );
+    }
+    for (const field of REFERENCE_FIELDS) {
+      for (const value of referenceValues(t, field)) {
+        if (resolveReference(t, value) === void 0) {
+          drafts.push(onEntry(t, "dangling-reference", `${field}: "${value}" names no entry`, field));
+        }
+      }
+    }
+    if (t.record.see !== void 0 && t.record.definition !== void 0) {
+      drafts.push(
+        onEntry(t, "see-not-empty", `see: "${t.record.see}" redirects this entry, so remove its definition`, "see")
+      );
+    }
+    if (t.record.see === void 0 && t.record.definition === void 0) {
+      drafts.push(
+        onEntry(t, "missing-definition", "definition: missing, so write one or run manni term fill.", "definition")
+      );
+    }
+    const kindOf = /* @__PURE__ */ new Map();
+    const conflicting = /* @__PURE__ */ new Set();
+    for (const field of TERM_MATCH_FIELDS) {
+      for (const iri of t.record[field] ?? []) {
+        const first = kindOf.get(iri);
+        if (first === void 0) kindOf.set(iri, field);
+        else if (first !== field && !conflicting.has(iri)) {
+          conflicting.add(iri);
+          drafts.push(
+            onEntry(t, "conflicting-matches", `${first}: "${iri}" is also in ${field}, and a mapping has one kind.`, first)
+          );
+        }
+      }
+    }
+    const abstract = t.record.abstract;
+    if (abstract !== void 0 && abstract.length > maxLength) {
+      drafts.push(
+        onEntry(
+          t,
+          "abstract-too-long",
+          `abstract: ${String(abstract.length)} characters is over the limit of ${String(maxLength)}, so shorten it`,
+          "abstract"
+        )
+      );
+    }
+    if (!usedIds.has(fold(t.id))) {
+      drafts.push(onEntry(t, "unused-term", "no page's concepts: names this term"));
+    }
+  });
+  const edges = (field) => terms.map((t) => {
+    const targets = /* @__PURE__ */ new Set();
+    for (const value of referenceValues(t, field)) {
+      const target = resolveReference(t, value);
+      if (target !== void 0) targets.add(target);
+    }
+    return targets;
+  });
+  const broader = edges("broader");
+  const narrower = edges("narrower");
+  const related = edges("related-terms");
+  terms.forEach((t, index) => {
+    for (const other of related[index] ?? []) {
+      const otherTerm = terms[other];
+      if (otherTerm !== void 0 && !(related[other]?.has(index) ?? false)) {
+        drafts.push(
+          onEntry(
+            otherTerm,
+            "asymmetric-related",
+            `related-terms: omits "${t.record.label}", which lists this entry as related.`,
+            "related-terms"
+          )
+        );
+      }
+    }
+  });
+  terms.forEach((t, index) => {
+    for (const parent of broader[index] ?? []) {
+      const parentTerm = terms[parent];
+      if (parentTerm !== void 0 && !(narrower[parent]?.has(index) ?? false)) {
+        drafts.push(
+          onEntry(
+            parentTerm,
+            "asymmetric-hierarchy",
+            `narrower: omits "${t.record.label}", which lists this entry as broader`,
+            "narrower"
+          )
+        );
+      }
+    }
+    for (const child of narrower[index] ?? []) {
+      const childTerm = terms[child];
+      if (childTerm !== void 0 && !(broader[child]?.has(index) ?? false)) {
+        drafts.push(
+          onEntry(
+            childTerm,
+            "asymmetric-hierarchy",
+            `broader: omits "${t.record.label}", which lists this entry as narrower`,
+            "broader"
+          )
+        );
+      }
+    }
+  });
+  const names = terms.map((t) => t.record.label);
+  const freeform = /* @__PURE__ */ new Map();
+  const node = (value, lang) => {
+    const index = resolveName(value, lang) ?? freeform.get(fold(value));
+    if (index !== void 0) return index;
+    freeform.set(fold(value), names.length);
+    names.push(value);
+    return names.length - 1;
+  };
+  const up = [];
+  const termEdges = /* @__PURE__ */ new Set();
+  const blockEdges = /* @__PURE__ */ new Map();
+  const link = (child, parent) => {
+    (up[child] ??= /* @__PURE__ */ new Set()).add(parent);
+    return `${String(child)}>${String(parent)}`;
+  };
+  broader.forEach((parents, child) => {
+    for (const parent of parents) termEdges.add(link(child, parent));
+  });
+  narrower.forEach((children, parent) => {
+    for (const child of children) termEdges.add(link(child, parent));
+  });
+  for (const block of set.blocks) {
+    const subject = node(block.label, block.language);
+    for (const edge of block.edges) {
+      if (edge.field === "related-concepts") continue;
+      const other = node(edge.value, block.language);
+      const key = edge.field === "broader" ? link(subject, other) : link(other, subject);
+      const line = edge.line ?? block.line;
+      if (!blockEdges.has(key)) blockEdges.set(key, { file: block.file, ...line === void 0 ? {} : { line } });
+    }
+  }
+  for (const [start, path] of broaderCycles(up)) {
+    const chain = [...path, start];
+    const message = `broader: ${chain.map((index) => names[index] ?? "").join(" > ")}`;
+    const hops = path.map((from, i) => `${String(from)}>${String(chain[i + 1])}`);
+    const viaBlock = hops.find((hop) => !termEdges.has(hop));
+    const startTerm = terms[start];
+    if (viaBlock === void 0 && startTerm !== void 0) {
+      drafts.push(onEntry(startTerm, "broader-cycle", message, "broader"));
+    } else {
+      const at = blockEdges.get(viaBlock ?? "");
+      if (at !== void 0) drafts.push({ rule: "broader-cycle", message, ...at });
+    }
+  }
+  const concept = (index, value) => {
+    const t = index === void 0 ? void 0 : terms[index];
+    return t === void 0 ? `name ${fold(value)}` : `id ${fold(t.id)}`;
+  };
+  for (const block of set.blocks) {
+    const t = terms[resolveName(block.label, block.language) ?? -1];
+    if (t === void 0) continue;
+    for (const edge of block.edges) {
+      const field = edge.field === "related-concepts" ? "related-terms" : edge.field;
+      const listed = referenceValues(t, field).map((value) => concept(resolveReference(t, value), value));
+      if (listed.includes(concept(resolveName(edge.value, block.language), edge.value))) continue;
+      const kind = t.location.construct === "page" ? "page" : "entry";
+      const line = edge.line ?? block.line;
+      drafts.push({
+        rule: "hierarchy-outside-termbase",
+        message: `graph: ${edge.field} "${edge.value}" on "${t.record.label}" is not on its term ${kind} (${t.location.file}), so add it there.`,
+        file: block.file,
+        ...line === void 0 ? {} : { line }
+      });
+    }
+  }
+  const ancestors = (start) => {
+    const seen = /* @__PURE__ */ new Set();
+    const stack = [...up[start] ?? []];
+    for (let next = stack.pop(); next !== void 0; next = stack.pop()) {
+      if (seen.has(next)) continue;
+      seen.add(next);
+      stack.push(...up[next] ?? []);
+    }
+    return seen;
+  };
+  const siblingPairs = /* @__PURE__ */ new Set();
+  terms.forEach((t, index) => {
+    const above = ancestors(index);
+    const seen = /* @__PURE__ */ new Set();
+    for (const value of referenceValues(t, "related-terms")) {
+      const other = resolveReference(t, value);
+      if (other === void 0 || other === index || seen.has(other)) continue;
+      seen.add(other);
+      const direction = above.has(other) ? "broader" : ancestors(other).has(index) ? "narrower" : void 0;
+      if (direction !== void 0) {
+        drafts.push(
+          onEntry(
+            t,
+            "related-in-hierarchy",
+            `related-terms: "${value}" is also ${direction} than this entry, so keep one of the two.`,
+            "related-terms"
+          )
+        );
+        continue;
+      }
+      const parent = [...up[index] ?? []].find((p) => up[other]?.has(p) ?? false);
+      const pair = `${String(Math.min(index, other))}~${String(Math.max(index, other))}`;
+      if (parent === void 0 || siblingPairs.has(pair)) continue;
+      siblingPairs.add(pair);
+      drafts.push(
+        onEntry(
+          t,
+          "related-siblings",
+          `related-terms: "${value}" shares the broader term "${names[parent] ?? ""}", which already relates them.`,
+          "related-terms"
+        )
+      );
+    }
+  });
+  const isTerm = (index) => index < terms.length;
+  if (up.some((parents, child) => isTerm(child) || [...parents].some(isTerm))) {
+    const placed = /* @__PURE__ */ new Set();
+    const place = (index) => {
+      if (index === void 0) return;
+      const t = terms[index];
+      if (t !== void 0) placed.add(fold(t.id));
+    };
+    up.forEach((parents, child) => {
+      place(child);
+      for (const parent of parents) place(parent);
+    });
+    related.forEach((others, index) => {
+      if (others.size > 0) place(index);
+      for (const other of others) place(other);
+    });
+    for (const block of set.blocks) {
+      for (const edge of block.edges) {
+        if (edge.field !== "related-concepts") continue;
+        place(resolveName(block.label, block.language));
+        place(resolveName(edge.value, block.language));
+      }
+    }
+    for (const t of terms) {
+      if (t.record.see === void 0 && !placed.has(fold(t.id))) {
+        drafts.push(onEntry(t, "orphan-term", "no broader, narrower or related term, so place it in the hierarchy."));
+      }
+    }
+  }
+  const minPages = opts.minPages ?? DEFAULT_CRAWL_MIN_PAGES;
+  const byKeyword = /* @__PURE__ */ new Map();
+  for (const keyword of set.keywords ?? []) {
+    const uses = byKeyword.get(fold(keyword.label));
+    if (uses === void 0) byKeyword.set(fold(keyword.label), [keyword]);
+    else uses.push(keyword);
+  }
+  for (const [key, uses] of byKeyword) {
+    if (byLabel.has(key) || byId.has(key) || byAlt.has(key)) continue;
+    const pages = new Set(uses.map((use) => use.file)).size;
+    const first = [...uses].sort((a, b) => compareText(a.file, b.file) || (a.line ?? 0) - (b.line ?? 0))[0];
+    if (pages < minPages || first === void 0) continue;
+    drafts.push({
+      rule: "keyword-candidate",
+      message: `keywords: "${first.label}" is on ${String(pages)} pages and names no term, so add it to concepts: or run manni term fill --crawl.`,
+      file: first.file,
+      ...first.line === void 0 ? {} : { line: first.line }
+    });
+  }
+  const findings = [];
+  for (const draft of drafts) {
+    const level = levels[draft.rule];
+    if (level === "off") continue;
+    findings.push({
+      rule: draft.rule,
+      ruleId: ruleId(draft.rule),
+      severity: level,
+      message: draft.message,
+      file: draft.file,
+      ...draft.line === void 0 ? {} : { line: draft.line },
+      ...draft.id === void 0 ? {} : { id: draft.id },
+      ...draft.field === void 0 ? {} : { field: draft.field }
+    });
+  }
+  return findings.sort(compareFindings);
+}
+function referenceValues(t, field) {
+  const value = t.record[field];
+  if (value === void 0) return [];
+  return typeof value === "string" ? [value] : value;
+}
+function broaderCycles(broader) {
+  const cycles = [];
+  for (let start = 0; start < broader.length; start++) {
+    const path = [start];
+    const onPath = /* @__PURE__ */ new Set([start]);
+    const walk = (node) => {
+      for (const next of broader[node] ?? []) {
+        if (next === start) {
+          cycles.push([start, [...path]]);
+        } else if (next > start && !onPath.has(next)) {
+          path.push(next);
+          onPath.add(next);
+          walk(next);
+          path.pop();
+          onPath.delete(next);
+        }
+      }
+    };
+    walk(start);
+  }
+  return cycles;
+}
+function compareText(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+function compareFindings(a, b) {
+  return compareText(a.file, b.file) || (a.line ?? 0) - (b.line ?? 0) || compareText(a.ruleId, b.ruleId) || compareText(a.message, b.message);
+}
+
+// src/term/commands/findings.ts
+var FINDING_FORMATS = ["pretty", "json", "github", "sarif", "junit"];
+var JUNIT_CLASSNAME = "manni.term";
+var LINE_REFERENCE = /:\d+\b/g;
+function toFieldError(finding) {
+  const keyword = finding.ruleId.startsWith(`${RULE_ID_PREFIX}/`) ? finding.ruleId.slice(RULE_ID_PREFIX.length + 1) : finding.ruleId;
+  const { field } = finding;
+  const subject = [finding.id ?? "", field ?? "", finding.message.replace(LINE_REFERENCE, "")].join("\0");
+  const error = {
+    schema: RULE_ID_PREFIX,
+    instancePath: field === void 0 ? "" : `/${field}`,
+    message: finding.message,
+    keyword,
+    subject,
+    severity: finding.severity
+  };
+  if (finding.line !== void 0) error.line = finding.line;
+  return error;
+}
+function toResults(set, findings) {
+  const origin = /* @__PURE__ */ new Map();
+  const byFile = /* @__PURE__ */ new Map();
+  for (const term of set.terms) {
+    if (!byFile.has(term.location.file)) byFile.set(term.location.file, []);
+  }
+  for (const finding of findings) {
+    const error = toFieldError(finding);
+    origin.set(error, finding);
+    const list = byFile.get(finding.file) ?? [];
+    list.push(error);
+    byFile.set(finding.file, list);
+  }
+  const results = [...byFile.keys()].sort().map((file) => {
+    const errors = byFile.get(file) ?? [];
+    return { file, format: "term", ok: !errors.some(isErrorSeverity), schemas: [RULE_ID_PREFIX], errors };
+  });
+  return { results, origin };
+}
+function summarize(results, baseline) {
+  const failed = results.filter((r) => !r.ok).length;
+  const count = (keep) => results.reduce((n, r) => n + r.errors.filter(keep).length, 0);
+  const warnings = count((e) => e.severity === "warning");
+  const notices = count((e) => e.severity === "notice");
+  return {
+    files: results.length,
+    passed: results.length - failed,
+    failed,
+    errors: count(isErrorSeverity),
+    ...warnings > 0 ? { warnings } : {},
+    ...notices > 0 ? { notices } : {},
+    ...baseline ? { baseline } : {}
+  };
+}
+function reportedFindings(results, origin) {
+  const kept = [];
+  for (const result of results) {
+    for (const error of result.errors) {
+      const finding = origin.get(error);
+      if (finding !== void 0) kept.push(finding);
+    }
+  }
+  return kept.sort(compareFindings2);
+}
+function compareFindings2(a, b) {
+  if (a.file !== b.file) return a.file < b.file ? -1 : 1;
+  const lineA = a.line ?? 0;
+  const lineB = b.line ?? 0;
+  if (lineA !== lineB) return lineA - lineB;
+  if (a.ruleId !== b.ruleId) return a.ruleId < b.ruleId ? -1 : 1;
+  return a.message < b.message ? -1 : a.message > b.message ? 1 : 0;
+}
+
+// src/term/commands/check.ts
+async function runCheck(opts) {
+  const { cwd, run, set } = await loadTerms(opts);
+  const config = run.config;
+  const findings = checkTermSet(set, {
+    ...config?.severity === void 0 ? {} : { severity: config.severity },
+    ...config?.abstractMaxLength === void 0 ? {} : { abstractMaxLength: config.abstractMaxLength },
+    ...config?.fill?.crawl?.minPages === void 0 ? {} : { minPages: config.fill.crawl.minPages }
+  });
+  const { results, origin } = toResults(set, findings);
+  const frame = { cwd, base: run.configDir ?? cwd, runBase: run.base };
+  let request = resolveBaselineRequest(
+    opts.baseline === true ? { baseline: true } : {},
+    config?.baseline,
+    run.configDir,
+    cwd,
+    { current: DEFAULT_TERM_BASELINE_PATH }
+  );
+  if (request !== null && !existsSync(request.absPath)) {
+    if (opts.baseline !== true) {
+      throw new TermError(
+        `Baseline "${request.label}" not found. Record one with \`manni term check --baseline\`.`
+      );
+    }
+    request = { ...request, write: true };
+  }
+  const { results: reported, baseline } = await settleBaseline(results, request, frame);
+  return {
+    findings: reportedFindings(reported, origin),
+    results: reported,
+    summary: summarize(reported, baseline),
+    frame,
+    terms: set.terms.length,
+    references: set.references.length,
+    ...baseline === void 0 ? {} : { baseline },
+    found: findings.length,
+    cwd
+  };
+}
+
+export {
+  RULE_ID_PREFIX,
+  proseRuleId,
+  isTermRule,
+  foldValeSeverity,
+  FINDING_FORMATS,
+  JUNIT_CLASSNAME,
+  toResults,
+  summarize,
+  reportedFindings,
+  runCheck
+};
+//# sourceMappingURL=chunk-QDC7JPFG.js.map