@hawkeyexl/manni 2.2.0 → 2.3.1

package/dist/cli.js

@@ -7,13 +7,15 @@ import {
   readStdin,
   reportConfig,
   splitList
-} from "./chunk-2Q5JUEIO.js";
+} from "./chunk-ESOEJTV2.js";
 import {
   CiteError,
   KeyError,
   SEVERITIES,
   SEVERITY_LIST,
   asCiteError,
+  codeEndAt,
+  codeRegions,
   isSeverity,
   meetsSeverity,
   renderCheckGithub,
@@ -30,35 +32,49 @@ import {
   shortPin,
   shortSrc,
   spellSource
-} from "./chunk-6JWX6JM2.js";
+} from "./chunk-CD3LHG26.js";
 import {
   COMMON_FORMAT_LIST,
   OMITTED_WHEN_CLEAN,
   REPORT_FORMATS,
   REPORT_FORMAT_LIST,
+  STDIN_LABEL,
   STDIN_TOKEN,
   ToolError,
+  assertNonEmpty,
+  errorMessage,
   escapeWorkflowCommandMessage,
   escapeWorkflowCommandProperty,
+  extractorByName,
+  extractorForExtension,
   fail,
   findConfigFile,
+  gitignoreOptions,
+  isErrorSeverity,
   isMachineFormat,
   isReportFormat,
+  locateFrontmatter,
   notice,
   package_default,
   palette,
   programName,
   readConfigFile,
   render,
+  renderJunit,
+  renderSarif,
+  resolveBaselineRequest,
+  resolveTargetSet,
   runIfMain,
   selectCollections,
+  settleBaseline,
   shouldColor,
   splitPageArgument,
-  terminalConfirm
-} from "./chunk-5O4FIGDJ.js";
+  terminalConfirm,
+  valeConfigPath
+} from "./chunk-HUHERW7E.js";
 
 // src/cli.ts
-import { Command as Command4 } from "commander";
+import { Command as Command5 } from "commander";
 
 // src/a11y/cli.ts
 import { Command } from "commander";
@@ -204,9 +220,9 @@ async function crawl(opts, analyzer) {
       progress({ kind: "checked", index, url, violations: 0, error });
     }
   }
-  const skipped = frontier.length - pages.length - duplicates;
-  progress({ kind: "done", checked: pages.length, skipped });
-  return { pages, discovered: frontier.length, skipped, duplicates };
+  const skipped2 = frontier.length - pages.length - duplicates;
+  progress({ kind: "done", checked: pages.length, skipped: skipped2 });
+  return { pages, discovered: frontier.length, skipped: skipped2, duplicates };
 }
 
 // src/a11y/core/seeds.ts
@@ -273,11 +289,11 @@ async function discoverSitemap(seed, fetcher = defaultFetcher) {
   }
   return { source: null, urls: [] };
 }
-function parseSitemapXml(text) {
-  if (text.trim() === "") return null;
+function parseSitemapXml(text2) {
+  if (text2.trim() === "") return null;
   let root;
   try {
-    const doc = new DOMParser({ onError: () => void 0 }).parseFromString(text, "text/xml");
+    const doc = new DOMParser({ onError: () => void 0 }).parseFromString(text2, "text/xml");
     root = doc.documentElement;
   } catch {
     return null;
@@ -335,10 +351,10 @@ function ancestorDirectories(pathname) {
   }
 }
 async function robotsSitemaps(url, fetcher) {
-  const text = await fetchText(url, fetcher);
-  if (text === null) return [];
+  const text2 = await fetchText(url, fetcher);
+  if (text2 === null) return [];
   const out = [];
-  for (const line of text.split(/\r?\n/)) {
+  for (const line of text2.split(/\r?\n/)) {
     const match = /^\s*sitemap\s*:\s*(\S+)/i.exec(line);
     const candidate = match?.[1];
     if (candidate !== void 0 && isHttpUrl(candidate) && !out.includes(candidate)) {
@@ -348,8 +364,8 @@ async function robotsSitemaps(url, fetcher) {
   return out;
 }
 async function fetchSitemap(url, fetcher) {
-  const text = await fetchText(url, fetcher);
-  return text === null ? null : parseSitemapXml(text);
+  const text2 = await fetchText(url, fetcher);
+  return text2 === null ? null : parseSitemapXml(text2);
 }
 async function fetchText(url, fetcher) {
   try {
@@ -423,7 +439,7 @@ function finishPage(page, floor) {
   const score = applicable === 0 ? null : Math.round(100 * page.passes / applicable);
   return { ...page, violations, score };
 }
-function summarize(results, { discovered, skipped, duplicates }, sitemap, crawl2) {
+function summarize(results, { discovered, skipped: skipped2, duplicates }, sitemap, crawl2) {
   const bySeverity = { notice: 0, warning: 0, error: 0 };
   let failed = 0;
   let violations = 0;
@@ -437,7 +453,7 @@ function summarize(results, { discovered, skipped, duplicates }, sitemap, crawl2
   return {
     discovered,
     checked: results.length,
-    skipped,
+    skipped: skipped2,
     duplicates,
     failed,
     violations,
@@ -706,10 +722,10 @@ function scoreText(page) {
   return page.score === null ? "n/a" : String(page.score);
 }
 function severityCounts(violations, c) {
-  const counts = { notice: 0, warning: 0, error: 0 };
-  for (const v of violations) counts[v.severity] += 1;
-  return [...SEVERITIES].reverse().filter((severity) => counts[severity] > 0).map((severity) => {
-    const n = counts[severity];
+  const counts2 = { notice: 0, warning: 0, error: 0 };
+  for (const v of violations) counts2[v.severity] += 1;
+  return [...SEVERITIES].reverse().filter((severity) => counts2[severity] > 0).map((severity) => {
+    const n = counts2[severity];
     return paintSeverity(`${n} ${severity}${n === 1 ? "" : "s"}`, severity, c);
   }).join(", ");
 }
@@ -729,14 +745,14 @@ function oneLine(summary) {
   if (head === void 0) return "";
   return rest.length === 0 ? head : `${head} ${rest.join("; ")}`;
 }
-function paintSeverity(text, severity, c) {
+function paintSeverity(text2, severity, c) {
   switch (severity) {
     case "notice":
-      return c.dim(text);
+      return c.dim(text2);
     case "warning":
-      return c.yellow(text);
+      return c.yellow(text2);
     case "error":
-      return c.red(text);
+      return c.red(text2);
   }
 }
 
@@ -779,8 +795,8 @@ function terminalReporter(opts) {
   const { stream } = opts;
   const c = palette(opts.color);
   let queued = 0;
-  const show = (text) => {
-    stream.write(`${CLEAR_LINE}${text}`);
+  const show = (text2) => {
+    stream.write(`${CLEAR_LINE}${text2}`);
   };
   const showUrl = (prefix, url, suffix = "") => {
     const columns = stream.columns ?? DEFAULT_COLUMNS;
@@ -816,8 +832,8 @@ function outcome(event, c) {
 }
 function plainReporter(stream) {
   let queued = 0;
-  const say = (text) => {
-    stream.write(`${programName()}: ${text}
+  const say = (text2) => {
+    stream.write(`${programName()}: ${text2}
 `);
   };
   return (event) => {
@@ -846,15 +862,15 @@ function plainReporter(stream) {
     }
   };
 }
-function visibleLength(text) {
-  return text.replace(/\x1b\[[0-9;]*m/g, "").length;
+function visibleLength(text2) {
+  return text2.replace(/\x1b\[[0-9;]*m/g, "").length;
 }
-function truncateMiddle(text, room) {
+function truncateMiddle(text2, room) {
   const max = Math.max(room, 8);
-  if (text.length <= max) return text;
+  if (text2.length <= max) return text2;
   const head = Math.ceil((max - 1) / 2);
   const tail = max - 1 - head;
-  return `${text.slice(0, head)}\u2026${text.slice(text.length - tail)}`;
+  return `${text2.slice(0, head)}\u2026${text2.slice(text2.length - tail)}`;
 }
 
 // src/a11y/cli.ts
@@ -955,9 +971,9 @@ function buildProgram2() {
         { analyzer: createPlaywrightAnalyzer(), onProgress: progress.listener }
       );
       const color = resolveColor(parent, process.stdout);
-      const text = render2(format, run, { color, quiet: Boolean(options.quiet) });
-      if (text.length > 0 || format !== "github") {
-        process.stdout.write(`${text}
+      const text2 = render2(format, run, { color, quiet: Boolean(options.quiet) });
+      if (text2.length > 0 || format !== "github") {
+        process.stdout.write(`${text2}
 `);
       }
       process.exitCode = run.summary.failed > 0 ? 1 : 0;
@@ -1002,7 +1018,7 @@ function addMessage(result) {
   const where2 = result.manifest === void 0 ? "frontmatter" : `${result.manifest.file}:${String(result.manifest.line)}`;
   const head = `${result.file}: added ${name} to ${where2}`;
   if (result.markerLine !== void 0) {
-    const at = claimLines === void 0 ? "" : `, claim pinned at line ${String(claimLines.start)}`;
+    const at = claimLines === void 0 ? "" : `, claim pinned at ${spellAt(claimLines)}`;
     return `${head}; marker at line ${String(result.markerLine)}${at}`;
   }
   if (claim === void 0 || claimLines === void 0) {
@@ -1087,10 +1103,10 @@ function buildProgram3() {
         showDiff: options.showDiff ? true : void 0,
         root: options.root
       });
-      let text;
+      let text2;
       switch (format) {
         case "pretty":
-          text = renderCheckPretty(run, {
+          text2 = renderCheckPretty(run, {
             color: colorFor(command, process.stdout.isTTY),
             quiet: Boolean(options.quiet),
             showDiff: Boolean(options.showDiff),
@@ -1098,20 +1114,20 @@ function buildProgram3() {
           });
           break;
         case "json":
-          text = renderCheckJson(run);
+          text2 = renderCheckJson(run);
           break;
         case "github":
-          text = renderCheckGithub(run);
+          text2 = renderCheckGithub(run);
           break;
         default:
-          text = render(format, run.results, run.summary, {
+          text2 = render(format, run.results, run.summary, {
             frame: run.frame,
             classname: JUNIT_CLASSNAME,
             onNotice: notice
           });
       }
-      if (text.length > 0 || !OMITTED_WHEN_CLEAN.has(format)) {
-        process.stdout.write(`${text}
+      if (text2.length > 0 || !OMITTED_WHEN_CLEAN.has(format)) {
+        process.stdout.write(`${text2}
 `);
       }
       process.exitCode = run.summary.failed > 0 ? 1 : 0;
@@ -1125,7 +1141,7 @@ function buildProgram3() {
   ).argument(
     "<src>",
     "path, path:L or path:L1-L2 relative to --root, or an encrypted ~source with the same line forms"
-  ).option("--id <id>", "kebab-case id, unique on the page; required with --marker").option("--marker", "write a cite <id> marker above the page lines and pin the text it anchors").option("--quote", "the page lines are a fenced block that reproduces the source").option(
+  ).option("--id <id>", "kebab-case id, unique on the page; required with --marker").option("--marker", "write a cite <id> marker above the paragraph holding the page lines and pin the text it anchors").option("--quote", "the page lines are a fenced block that reproduces the source").option(
     "--encrypt",
     "write source.file encrypted, with an hmac-sha256- pin; with no key, offer to create one (an available key encrypts without the flag)"
   ).option("--no-commit-sha", "do not record HEAD").option("--dry-run", "print the diff; write nothing").option("--as <format>", "force the page format").option("--root <dir>", "directory source paths resolve from (as check)").option("-c, --config <path>", "path to a manni config file").option("--no-config", "ignore any discovered config file").addHelpText(
@@ -1249,7 +1265,7 @@ function buildProgram3() {
         only: options.only.length > 0 ? options.only : void 0,
         dryRun
       });
-      const text = format === "json" ? renderUpdateJson(run) : renderUpdatePretty(run, {
+      const text2 = format === "json" ? renderUpdateJson(run) : renderUpdatePretty(run, {
         color: colorFor(command, process.stdout.isTTY),
         // The diffs are the point of a dry run; a real run prints
         // what it rewrote and leaves the file to say the rest.
@@ -1258,10 +1274,10 @@ function buildProgram3() {
       const stdinPage = pageToStdout ? run.pages.find((page) => page.content !== void 0) : void 0;
       if (stdinPage?.content !== void 0) {
         process.stdout.write(stdinPage.content);
-        process.stderr.write(`${text}
+        process.stderr.write(`${text2}
 `);
       } else {
-        process.stdout.write(`${text}
+        process.stdout.write(`${text2}
 `);
       }
       process.exitCode = run.exitCode;
@@ -1454,44 +1470,4032 @@ function buildProgram4() {
   return program;
 }
 
-// src/cli.ts
-function buildProgram5() {
-  const meta = buildProgram().name("meta").description(
-    "Validate, read, query and fill document metadata against JSON Schema"
-  );
-  const metaCommands = new Set(meta.commands.map((c) => c.name()));
-  const program = new Command4();
-  program.name("manni").description("Tools for documentation that is meant to be checked.").version(package_default.version, "-V, --version").showHelpAfterError("(add --help for usage)").exitOverride().configureOutput({
-    outputError: (str, write) => {
-      write(str);
-      const m = /unknown command '([^']+)'/.exec(str);
-      const name = m?.[1];
-      if (name !== void 0 && metaCommands.has(name)) {
-        write(
-          `(\`${name}\` is a metadata command: try \`manni meta ${name}\`)
-`
+// src/term/cli.ts
+import { Command as Command4 } from "commander";
+
+// src/term/commands/check.ts
+import { existsSync as existsSync2 } from "node:fs";
+
+// src/term/core/config.ts
+import { resolve } from "node:path";
+
+// src/term/errors.ts
+var TermError = class extends ToolError {
+  constructor(message) {
+    super(message);
+    this.name = "TermError";
+  }
+};
+
+// src/term/types.ts
+var TERM_FIELDS = [
+  "label",
+  "definition",
+  "abstract",
+  "alt-labels",
+  "hidden-labels",
+  "broader",
+  "narrower",
+  "related-terms",
+  "see",
+  "scope-note"
+];
+var TERM_LIST_FIELDS = [
+  "alt-labels",
+  "hidden-labels",
+  "broader",
+  "narrower",
+  "related-terms"
+];
+var TERM_WRITE_FORMATS = [
+  "markdown",
+  "mdx",
+  "asciidoc",
+  "rst",
+  "html",
+  "dita",
+  "docbook",
+  "tbx",
+  "skos",
+  "csv",
+  "json",
+  "vale"
+];
+var TERM_RULES = [
+  "undefined-term",
+  "duplicate-id",
+  "label-collision",
+  "alt-label-collision",
+  "dangling-reference",
+  "broader-cycle",
+  "see-not-empty",
+  "asymmetric-hierarchy",
+  "abstract-too-long",
+  "unused-term"
+];
+
+// src/term/core/config.ts
+var TERM_SECTION = "term";
+var DEFAULT_TERM_BASELINE_PATH = ".manni-term-baseline.json";
+var DEFAULT_ABSTRACT_MAX_LENGTH = 60;
+var CONFIG_KEYS2 = [
+  "manifests",
+  "abstractMaxLength",
+  "baseline",
+  "severity",
+  "allowEmpty",
+  "respectGitignore"
+];
+var COLLECTION_KEYS = ["paths", "exclude"];
+var TOOL_KEYS = ["vale"];
+var SEVERITY_LEVELS = [...SEVERITIES, "off"];
+var CONFIG_FILE2 = {
+  section: TERM_SECTION,
+  legacyNames: [],
+  toError: (message) => new TermError(message)
+};
+function isMapping(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isLevel(value) {
+  return typeof value === "string" && SEVERITY_LEVELS.includes(value);
+}
+function isTermRule(value) {
+  return TERM_RULES.includes(value);
+}
+function rejectUnknownKeys(obj, allowed, where2, source) {
+  for (const key of Object.keys(obj)) {
+    if (!allowed.includes(key)) {
+      throw new TermError(
+        `Unknown key "${key}" under ${where2}: in ${source}. Supported keys: ${allowed.join(", ")}.`
+      );
+    }
+  }
+}
+function wrongType(key, expected, source) {
+  return new TermError(`term.${key} in ${source} must be ${expected}.`);
+}
+function asBoolean2(value, key, source) {
+  if (typeof value !== "boolean") throw wrongType(key, "a boolean", source);
+  return value;
+}
+function asString(value, key, source) {
+  if (typeof value !== "string") throw wrongType(key, "a string", source);
+  return value;
+}
+function asStringList2(value, key, source) {
+  if (!Array.isArray(value) || !value.every((item2) => typeof item2 === "string" && item2.trim() !== "")) {
+    throw wrongType(key, "a list of non-empty strings", source);
+  }
+  return value;
+}
+function asNonNegativeInteger(value, key, source) {
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {
+    throw wrongType(key, "a non-negative integer", source);
+  }
+  return value;
+}
+function parseSeverity(value, source) {
+  if (!isMapping(value)) throw wrongType("severity", "a mapping", source);
+  rejectUnknownKeys(value, TERM_RULES, "term.severity", source);
+  const severity = {};
+  for (const [rule, level] of Object.entries(value)) {
+    if (!isTermRule(rule)) continue;
+    if (!isLevel(level)) {
+      const quoted = typeof level === "string" ? ` "${level}"` : "";
+      throw new TermError(
+        `${source}: term.severity.${rule}${quoted} is not a level. Expected ${SEVERITY_LEVELS.join(" | ")}.`
+      );
+    }
+    severity[rule] = level;
+  }
+  return severity;
+}
+function parseTermConfig(raw, source) {
+  if (raw == null) return {};
+  if (!isMapping(raw)) {
+    throw new TermError(`term: in ${source} must be a mapping.`);
+  }
+  for (const key of COLLECTION_KEYS) {
+    if (Object.hasOwn(raw, key)) {
+      throw new TermError(
+        `${source}: term does not carry "${key}". Name a collection under collections:.`
+      );
+    }
+  }
+  for (const key of TOOL_KEYS) {
+    if (Object.hasOwn(raw, key)) {
+      throw new TermError(
+        `${source}: term does not carry "${key}". Vale's settings live under tools.${key}.`
+      );
+    }
+  }
+  rejectUnknownKeys(raw, CONFIG_KEYS2, "term", source);
+  const config = {};
+  if (raw.manifests !== void 0) config.manifests = asStringList2(raw.manifests, "manifests", source);
+  if (raw.abstractMaxLength !== void 0) {
+    config.abstractMaxLength = asNonNegativeInteger(raw.abstractMaxLength, "abstractMaxLength", source);
+  }
+  if (raw.baseline !== void 0) config.baseline = asString(raw.baseline, "baseline", source);
+  if (raw.severity !== void 0) config.severity = parseSeverity(raw.severity, source);
+  if (raw.allowEmpty !== void 0) config.allowEmpty = asBoolean2(raw.allowEmpty, "allowEmpty", source);
+  if (raw.respectGitignore !== void 0) {
+    config.respectGitignore = asBoolean2(raw.respectGitignore, "respectGitignore", source);
+  }
+  return config;
+}
+function readTermConfigFile(explicitPath, cwd) {
+  return explicitPath ? readConfigFile(explicitPath, cwd, CONFIG_FILE2) : findConfigFile(cwd, CONFIG_FILE2);
+}
+function toLoaded(file) {
+  return {
+    config: parseTermConfig(file.value, file.source),
+    path: file.path,
+    dir: file.dir,
+    source: file.source,
+    collections: file.collections,
+    tools: file.tools
+  };
+}
+var STDIN = "-";
+async function resolveTermRun(opts) {
+  const cwd = resolve(opts.cwd);
+  const wanted = opts.collection ?? [];
+  if (wanted.length > 0 && opts.inputs.some((input) => input !== STDIN)) {
+    throw new TermError(
+      "--collection selects a configured collection; it cannot be combined with paths."
+    );
+  }
+  const file = opts.noConfig ? null : await readTermConfigFile(opts.configPath, cwd);
+  const loaded = file === null ? null : toLoaded(file);
+  if (wanted.length > 0 && loaded === null) {
+    throw new TermError("--collection needs a config file to select from.");
+  }
+  if (loaded) opts.onConfigLoaded?.({ path: loaded.path, dir: loaded.dir });
+  const collections = loaded ? selectCollections(loaded.collections, wanted, loaded.source, (message) => new TermError(message)) : [];
+  const fromCollections = opts.inputs.length === 0;
+  const inputs = fromCollections ? collections.flatMap((c) => c.paths) : opts.inputs;
+  const base = fromCollections && inputs.length > 0 && loaded ? loaded.dir : cwd;
+  const manifests = loaded ? (loaded.config.manifests ?? []).map((written) => ({ path: resolve(loaded.dir, written), written })) : [];
+  return {
+    config: loaded ? loaded.config : null,
+    inputs,
+    base,
+    collections,
+    fromCollections,
+    manifests,
+    tools: loaded ? loaded.tools : {},
+    ...loaded ? { configDir: loaded.dir, configPath: loaded.path, configSource: loaded.source } : {},
+    ...file === null ? {} : { configFile: file }
+  };
+}
+
+// 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",
+  "dangling-reference": "error",
+  "broader-cycle": "error",
+  "see-not-empty": "error",
+  "asymmetric-hierarchy": "warning",
+  "abstract-too-long": "notice",
+  "unused-term": "notice"
+};
+function ruleId(rule) {
+  return `${RULE_ID_PREFIX}/${rule}`;
+}
+function proseRuleId(check) {
+  return `${RULE_ID_PREFIX}/prose/${check}`;
+}
+function isTermRule2(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 REFERENCE_FIELDS = ["broader", "narrower", "related-terms", "see"];
+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 where2 = (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();
+  terms.forEach((t, index) => {
+    const label = fold(t.record.label);
+    if (!byLabel.has(label)) byLabel.set(label, index);
+    const id = fold(t.id);
+    if (!byId.has(id)) byId.set(id, index);
+  });
+  const resolveReference = (value) => byLabel.get(fold(value)) ?? byId.get(fold(value));
+  const referenced = /* @__PURE__ */ new Set();
+  for (const reference of set.references) {
+    const label = fold(reference.label);
+    referenced.add(label);
+    if (byLabel.has(label)) continue;
+    let message = `concepts: "${reference.label}" names no entry.`;
+    const synonym = terms.find((t) => (t.record["alt-labels"] ?? []).some((alt) => fold(alt) === label));
+    if (synonym !== void 0) {
+      message += ` "${synonym.record.label}" lists it as an alt-label.`;
+    }
+    drafts.push({
+      rule: "undefined-term",
+      message,
+      file: reference.file,
+      ...reference.line === void 0 ? {} : { line: reference.line }
+    });
+  }
+  const sharing = /* @__PURE__ */ new Map();
+  for (const t of terms) {
+    const group = sharing.get(t.id);
+    if (group === void 0) sharing.set(t.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(where2);
+      drafts.push(onEntry(t, "duplicate-id", `id: "${t.id}" is also used by ${others.join(", ")}`));
+    }
+  }
+  terms.forEach((t, index) => {
+    const first = byLabel.get(fold(t.record.label));
+    const firstTerm = first === void 0 ? void 0 : terms[first];
+    if (first !== void 0 && first !== index && firstTerm !== void 0) {
+      drafts.push(
+        onEntry(
+          t,
+          "label-collision",
+          `"${t.record.label}" is claimed by ${where2(firstTerm)} as "${firstTerm.record.label}"`,
+          "label"
+        )
+      );
+    }
+    for (const alt of t.record["alt-labels"] ?? []) {
+      const owner = terms.find((other, otherIndex) => otherIndex !== index && fold(other.record.label) === fold(alt));
+      if (owner !== void 0) {
+        drafts.push(
+          onEntry(t, "alt-label-collision", `alt-labels: "${alt}" is the label of ${where2(owner)}`, "alt-labels")
+        );
+      }
+    }
+    for (const field of REFERENCE_FIELDS) {
+      for (const value of referenceValues(t, field)) {
+        if (resolveReference(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")
+      );
+    }
+    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 (!referenced.has(fold(t.record.label))) {
+      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(value);
+      if (target !== void 0) targets.add(target);
+    }
+    return targets;
+  });
+  const broader = edges("broader");
+  const narrower = edges("narrower");
+  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"
+          )
         );
       }
     }
   });
-  program.addCommand(meta);
-  program.addCommand(
-    buildProgram2().name("a11y").description(
-      "Crawl a site and check every page for accessibility violations with axe-core"
-    )
-  );
-  program.addCommand(
-    buildProgram3().name("cite").description(
-      "Track citations from doc claims to source lines and check them for drift"
-    )
+  for (const [start2, path] of broaderCycles(broader)) {
+    const startTerm = terms[start2];
+    if (startTerm === void 0) continue;
+    const labels = [...path, start2].map((index) => terms[index]?.record.label ?? "");
+    drafts.push(onEntry(startTerm, "broader-cycle", `broader: ${labels.join(" > ")}`, "broader"));
+  }
+  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 start2 = 0; start2 < broader.length; start2++) {
+    const path = [start2];
+    const onPath = /* @__PURE__ */ new Set([start2]);
+    const walk = (node) => {
+      for (const next of broader[node] ?? []) {
+        if (next === start2) {
+          cycles.push([start2, [...path]]);
+        } else if (next > start2 && !onPath.has(next)) {
+          path.push(next);
+          onPath.add(next);
+          walk(next);
+          path.pop();
+          onPath.delete(next);
+        }
+      }
+    };
+    walk(start2);
+  }
+  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_CLASSNAME2 = "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 summarize2(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/run.ts
+import { existsSync } from "node:fs";
+import { isAbsolute, relative, resolve as resolve3 } from "node:path";
+
+// src/term/core/load-set.ts
+import { readFile } from "node:fs/promises";
+import { extname, resolve as resolve2 } from "node:path";
+
+// src/term/core/writers/markup.ts
+function xmlText(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+function xmlAttribute(value) {
+  return xmlText(value).replaceAll('"', "&quot;");
+}
+function paragraphsOf(definition) {
+  if (definition === void 0) return [];
+  return definition.split(/\r?\n[ \t]*\r?\n/).map(
+    (paragraph) => paragraph.split(/\r?\n/).map((line) => line.trim()).filter((line) => line !== "")
+  ).filter((lines) => lines.length > 0);
+}
+function paragraphText(lines) {
+  return lines.join(" ");
+}
+function isAcronym(label) {
+  return new RegExp("\\p{L}", "u").test(label) && !new RegExp("\\p{Ll}", "u").test(label);
+}
+function sharedLanguage(terms) {
+  const [first] = terms;
+  const language = first?.language;
+  if (language === void 0) return void 0;
+  return terms.every((t) => t.language === language) ? language : void 0;
+}
+function reindent(text2, indent, eol) {
+  return text2.split("\n").map((line, i) => i === 0 || line === "" ? line : `${indent}${line}`).join(eol);
+}
+function fileOf(lines) {
+  return lines.map((line) => `${line}
+`).join("");
+}
+
+// src/term/core/writers/entries.ts
+var LIST_HOLDS = ["label", "definition", "alt-labels"];
+var DITA_HOLDS = ["label", "definition", "alt-labels", "scope-note"];
+var DOCBOOK_HOLDS = ["label", "definition", "alt-labels", "see", "related-terms"];
+function labelsOf(record) {
+  return [record.label, ...record["alt-labels"] ?? []];
+}
+function markdownEntry(record) {
+  const lines = labelsOf(record);
+  const paragraphs = paragraphsOf(record.definition);
+  if (paragraphs.length === 0) return [...lines, ":"].join("\n");
+  paragraphs.forEach((paragraph, p) => {
+    if (p > 0) lines.push("");
+    paragraph.forEach((line, i) => {
+      lines.push(p === 0 && i === 0 ? `:   ${line}` : `    ${line}`);
+    });
+  });
+  return lines.join("\n");
+}
+function asciidocEntry(record) {
+  const labels = labelsOf(record);
+  const paragraphs = paragraphsOf(record.definition);
+  const lines = labels.map((label) => `${label}::`);
+  paragraphs.forEach((paragraph, p) => {
+    if (p > 0) lines.push("+");
+    paragraph.forEach((line, i) => {
+      if (p === 0 && i === 0) lines[lines.length - 1] = `${lines[lines.length - 1] ?? ""} ${line}`;
+      else lines.push(line);
+    });
+  });
+  return lines.join("\n");
+}
+function rstEntry(record) {
+  const lines = labelsOf(record);
+  paragraphsOf(record.definition).forEach((paragraph, p) => {
+    if (p > 0) lines.push("");
+    for (const line of paragraph) lines.push(`   ${line}`);
+  });
+  return lines.join("\n");
+}
+function blockDefinition(open, close, paragraph, definition) {
+  const paragraphs = paragraphsOf(definition);
+  const [only] = paragraphs;
+  if (only === void 0) return [];
+  if (paragraphs.length === 1) return [`${open}${xmlText(paragraphText(only))}${close}`];
+  return [
+    open,
+    ...paragraphs.map((lines) => `  <${paragraph}>${xmlText(paragraphText(lines))}</${paragraph}>`),
+    close
+  ];
+}
+function htmlDlEntry(term) {
+  const [label, ...alts] = labelsOf(term.record);
+  return [
+    `<dt id="${xmlAttribute(term.id)}">${xmlText(label ?? "")}</dt>`,
+    ...alts.map((alt) => `<dt>${xmlText(alt)}</dt>`),
+    ...blockDefinition("<dd>", "</dd>", "p", term.record.definition)
+  ].join("\n");
+}
+function ditaEntry(term, language) {
+  const { record } = term;
+  const alts = record["alt-labels"] ?? [];
+  const scopeNote = record["scope-note"];
+  const lang = language === void 0 ? "" : ` xml:lang="${xmlAttribute(language)}"`;
+  const body = scopeNote === void 0 && alts.length === 0 ? [] : [
+    "  <glossBody>",
+    ...scopeNote === void 0 ? [] : [`    <glossUsage>${xmlText(scopeNote)}</glossUsage>`],
+    ...alts.flatMap((alt) => {
+      const element = isAcronym(alt) ? "glossAcronym" : "glossSynonym";
+      return ["    <glossAlt>", `      <${element}>${xmlText(alt)}</${element}>`, "    </glossAlt>"];
+    }),
+    "  </glossBody>"
+  ];
+  return [
+    `<glossentry id="${xmlAttribute(term.id)}"${lang}>`,
+    `  <glossterm>${xmlText(record.label)}</glossterm>`,
+    ...blockDefinition("<glossdef>", "</glossdef>", "p", record.definition).map((line) => `  ${line}`),
+    ...body,
+    "</glossentry>"
+  ].join("\n");
+}
+function docbookEntry(term) {
+  const { record } = term;
+  const related = record["related-terms"] ?? [];
+  const paragraphs = paragraphsOf(record.definition);
+  const glossdef = paragraphs.length === 0 && related.length === 0 ? [] : [
+    "  <glossdef>",
+    ...paragraphs.map((lines) => `    <para>${xmlText(paragraphText(lines))}</para>`),
+    ...related.map((target) => `    <glossseealso>${xmlText(target)}</glossseealso>`),
+    "  </glossdef>"
+  ];
+  return [
+    `<glossentry xml:id="${xmlAttribute(term.id)}">`,
+    `  <glossterm>${xmlText(record.label)}</glossterm>`,
+    ...(record["alt-labels"] ?? []).map(
+      (alt) => isAcronym(alt) ? `  <acronym>${xmlText(alt)}</acronym>` : `  <glossterm>${xmlText(alt)}</glossterm>`
+    ),
+    ...glossdef,
+    ...record.see === void 0 ? [] : [`  <glosssee>${xmlText(record.see)}</glosssee>`],
+    "</glossentry>"
+  ].join("\n");
+}
+
+// src/term/core/id.ts
+import { slug } from "github-slugger";
+function slugOf(label) {
+  return slug(label.trim());
+}
+
+// src/term/core/readers/normalize.ts
+function nothing() {
+  return { terms: [], notices: [] };
+}
+function textOf(value) {
+  let text2;
+  if (typeof value === "string") text2 = value;
+  else if (typeof value === "number" && Number.isFinite(value)) text2 = String(value);
+  else return void 0;
+  const trimmed = text2.trim();
+  return trimmed === "" ? void 0 : trimmed;
+}
+function listOf(value) {
+  const items = Array.isArray(value) ? value : [value];
+  const list = items.map(textOf).filter((item2) => item2 !== void 0);
+  return list.length === 0 ? void 0 : list;
+}
+function collapse(text2) {
+  return text2.replace(/\s+/g, " ").trim();
+}
+function isListField(field) {
+  return TERM_LIST_FIELDS.includes(field);
+}
+function recordOf(raw) {
+  const label = textOf(raw.label);
+  if (label === void 0) return void 0;
+  const record = { label };
+  for (const field of TERM_FIELDS) {
+    if (isListField(field)) {
+      const list = listOf(raw[field]);
+      if (list !== void 0) record[field] = list;
+    } else if (field !== "label") {
+      const text2 = textOf(raw[field]);
+      if (text2 !== void 0) record[field] = text2;
+    }
+  }
+  return record;
+}
+function ignoredFields(raw) {
+  const ignored = [];
+  for (const field of TERM_FIELDS) {
+    if (field === "label" || isListField(field)) continue;
+    const value = raw[field];
+    if (value === void 0 || value === null || typeof value === "string") continue;
+    if (textOf(value) !== void 0) continue;
+    const given = Array.isArray(value) ? "list" : typeof value === "object" ? "mapping" : "other";
+    ignored.push({ field, given });
+  }
+  return ignored;
+}
+function ignoredNotice(input, line, label, ignored) {
+  const { field, given } = ignored;
+  const article = /^[aeiou]/.test(field) ? "an" : "a";
+  const holds = given === "list" ? "holds one value, not a list" : given === "mapping" ? "holds text, not a mapping" : "holds text";
+  return `${input.file}:${line}: ignored ${field} on "${label}": ${article} ${field} ${holds}.`;
+}
+function linesFor(record, lines) {
+  const kept = {};
+  for (const field of TERM_FIELDS) {
+    const line = lines[field];
+    if (line !== void 0 && record[field] !== void 0) kept[field] = line;
+  }
+  return kept;
+}
+function idFor(record, recordId, constructId) {
+  return textOf(recordId) ?? textOf(constructId) ?? slugOf(record.label);
+}
+function languageOf(input) {
+  return textOf(input.metadata["language"]) ?? textOf(input.metadata["xml:lang"]);
+}
+function declares(input, type) {
+  const value = input.metadata["type"];
+  return typeof value === "string" && value.trim() === type;
+}
+function skipped(input, line, label) {
+  return `${input.file}:${line}: skipped a ${label} entry with no term.`;
+}
+function termOf(input, parts) {
+  const language = languageOf(input);
+  const location = {
+    file: input.file,
+    ...input.path === void 0 ? {} : { path: input.path },
+    construct: parts.construct,
+    line: parts.line,
+    fieldLines: linesFor(parts.record, parts.lines),
+    ...parts.span === void 0 ? {} : { span: parts.span }
+  };
+  return {
+    id: idFor(parts.record, parts.recordId, parts.constructId),
+    record: parts.record,
+    ...language === void 0 ? {} : { language },
+    location
+  };
+}
+
+// src/term/core/readers/splice.ts
+function sameValue(a, b) {
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+function sameFields(a, b, fields) {
+  return fields.every((field) => sameValue(a[field], b[field]));
+}
+function lineEnding(content) {
+  return content.includes("\r\n") ? "\r\n" : "\n";
+}
+function indentAt(content, offset) {
+  const lineStart = content.lastIndexOf("\n", offset - 1) + 1;
+  return /^[ \t]*/.exec(content.slice(lineStart, offset))?.[0] ?? "";
+}
+function applyEntries(input, read8, terms, write) {
+  const { content } = input;
+  const current = read8(input).terms;
+  const eol = lineEnding(content);
+  const edits = [];
+  for (const term of terms) {
+    const span = term.location.span;
+    if (span === void 0) {
+      throw new TermError(
+        `${input.file}: term "${term.id}" cannot be written in place, because its entry has no position in the file.`
+      );
+    }
+    const found = current.find((t) => t.location.span?.start === span.start && t.location.span.end === span.end);
+    if (found === void 0) {
+      throw new TermError(
+        `${input.file}: term "${term.id}" does not match an entry in the file. Read the file again before writing it.`
+      );
+    }
+    if (sameFields(found.record, term.record, write.holds) && (!write.id || found.id === term.id)) continue;
+    const text2 = reindent(write.serialize(term, input), indentAt(content, span.start), eol);
+    edits.push({ start: span.start, end: span.end, text: text2 });
+  }
+  let next = content;
+  for (const edit of [...edits].sort((a, b) => b.start - a.start)) {
+    next = next.slice(0, edit.start) + edit.text + next.slice(edit.end);
+  }
+  return next;
+}
+
+// src/term/core/readers/xml.ts
+import { DOMParser as DOMParser2 } from "@xmldom/xmldom";
+var cache = /* @__PURE__ */ new WeakMap();
+var LINE_BREAK = /\r\n|\r|\n|\u0085|\u2028|\u2029/g;
+function lineStarts(source) {
+  const starts = [0];
+  for (const match of source.matchAll(LINE_BREAK)) starts.push(match.index + match[0].length);
+  return starts;
+}
+function parseXml(input) {
+  const cached = cache.get(input);
+  if (cached !== void 0) return cached;
+  const shift = input.content.charCodeAt(0) === 65279 ? 1 : 0;
+  const body = input.content.slice(shift);
+  const errors = [];
+  let parsed = null;
+  try {
+    const doc = new DOMParser2({
+      onError: (level, message) => {
+        if (level !== "error" && level !== "fatalError") return;
+        if (/entity not found/i.test(message)) return;
+        errors.push(message);
+      }
+    }).parseFromString(body, "text/xml");
+    const root = doc.documentElement;
+    if (errors.length === 0 && root !== null) parsed = { root, body, shift, starts: lineStarts(body) };
+  } catch {
+    parsed = null;
+  }
+  cache.set(input, parsed);
+  return parsed;
+}
+function nameOf2(el) {
+  return (el.localName ?? el.nodeName).toLowerCase();
+}
+function childrenOf(el, name) {
+  const out = [];
+  for (let i = 0; i < el.children.length; i++) {
+    const child = el.children.item(i);
+    if (child !== null && (name === void 0 || nameOf2(child) === name)) out.push(child);
+  }
+  return out;
+}
+function descendantsOf(el, name) {
+  const out = [];
+  const walk = (parent) => {
+    for (const child of childrenOf(parent)) {
+      if (nameOf2(child) === name) out.push(child);
+      walk(child);
+    }
+  };
+  walk(el);
+  return out;
+}
+function textOfElement(el) {
+  return collapse(el.textContent ?? "");
+}
+function lineOfElement(el) {
+  return el.lineNumber ?? 1;
+}
+function skipOpaque(body, from) {
+  const opaque = [
+    ["<!--", "-->"],
+    ["<![CDATA[", "]]>"],
+    ["<?", "?>"],
+    ["<!", ">"]
+  ];
+  for (const [open, close] of opaque) {
+    if (body.startsWith(open, from)) {
+      const end = body.indexOf(close, from + open.length);
+      return end === -1 ? body.length : end + close.length;
+    }
+  }
+  return void 0;
+}
+function tagEnd(body, from) {
+  let quote;
+  for (let i = from + 1; i < body.length; i++) {
+    const ch = body[i];
+    if (quote !== void 0) {
+      if (ch === quote) quote = void 0;
+    } else if (ch === '"' || ch === "'") {
+      quote = ch;
+    } else if (ch === ">") {
+      return { end: i + 1, selfClosing: body[i - 1] === "/" };
+    }
+  }
+  return void 0;
+}
+function namedAt(body, at, name) {
+  if (!body.startsWith(name, at)) return false;
+  const after = body[at + name.length];
+  return after === void 0 || /[\s/>]/.test(after);
+}
+function spanOfElement(xml, el) {
+  const lineStart = xml.starts[(el.lineNumber ?? 1) - 1];
+  if (lineStart === void 0) return void 0;
+  const start2 = lineStart + (el.columnNumber ?? 1) - 1;
+  const { body } = xml;
+  if (body[start2] !== "<") return void 0;
+  const name = el.nodeName;
+  const open = tagEnd(body, start2);
+  if (open === void 0) return void 0;
+  if (open.selfClosing) return { start: start2 + xml.shift, end: open.end + xml.shift };
+  let depth = 1;
+  let i = open.end;
+  while (i < body.length) {
+    const lt = body.indexOf("<", i);
+    if (lt === -1) return void 0;
+    const skipTo = skipOpaque(body, lt);
+    if (skipTo !== void 0) {
+      i = skipTo;
+      continue;
+    }
+    const tag = tagEnd(body, lt);
+    if (tag === void 0) return void 0;
+    if (body[lt + 1] === "/" && namedAt(body, lt + 2, name)) {
+      depth -= 1;
+      if (depth === 0) return { start: start2 + xml.shift, end: tag.end + xml.shift };
+    } else if (namedAt(body, lt + 1, name) && !tag.selfClosing) {
+      depth += 1;
+    }
+    i = tag.end;
+  }
+  return void 0;
+}
+
+// src/term/core/readers/dita.ts
+function definitionOf(glossdef) {
+  const paragraphs = childrenOf(glossdef, "p");
+  if (paragraphs.length === 0) return textOfElement(glossdef);
+  return paragraphs.map(textOfElement).filter((text2) => text2 !== "").join("\n\n");
+}
+function readEntry(input, xml, entry, construct, label) {
+  const raw = {};
+  const lines = {};
+  const [glossterm] = childrenOf(entry, "glossterm");
+  if (glossterm !== void 0) {
+    raw.label = textOfElement(glossterm);
+    lines.label = lineOfElement(glossterm);
+  }
+  const [glossdef] = childrenOf(entry, "glossdef");
+  if (glossdef !== void 0) {
+    raw.definition = definitionOf(glossdef);
+    lines.definition = lineOfElement(glossdef);
+  }
+  const alts = [];
+  for (const body of childrenOf(entry, "glossbody")) {
+    const [usage] = childrenOf(body, "glossusage");
+    if (usage !== void 0 && raw["scope-note"] === void 0) {
+      raw["scope-note"] = textOfElement(usage);
+      lines["scope-note"] = lineOfElement(usage);
+    }
+    for (const alt of childrenOf(body, "glossalt")) {
+      for (const form of childrenOf(alt)) {
+        const name = nameOf2(form);
+        if (name !== "glosssynonym" && name !== "glossacronym") continue;
+        alts.push(textOfElement(form));
+        lines["alt-labels"] ??= lineOfElement(form);
+      }
+    }
+  }
+  raw["alt-labels"] = alts;
+  const line = lineOfElement(entry);
+  const record = recordOf(raw);
+  if (record === void 0) return skipped(input, line, label);
+  const span = spanOfElement(xml, entry);
+  return termOf(input, {
+    record,
+    constructId: entry.getAttribute("id"),
+    construct,
+    line,
+    lines,
+    ...span === void 0 ? {} : { span }
+  });
+}
+function collect3(input, xml, entries, construct, label) {
+  const result = nothing();
+  for (const entry of entries) {
+    const read8 = readEntry(input, xml, entry, construct, label);
+    if (typeof read8 === "string") result.notices.push(read8);
+    else result.terms.push(read8);
+  }
+  return result;
+}
+var GLOSSENTRY_LABEL = "DITA glossentry";
+var GLOSSGROUP_LABEL = "DITA glossgroup";
+function readGlossentry(input) {
+  const xml = parseXml(input);
+  if (xml === null || nameOf2(xml.root) !== "glossentry") return nothing();
+  return collect3(input, xml, [xml.root], "dita-glossentry", GLOSSENTRY_LABEL);
+}
+function readGlossgroup(input) {
+  const xml = parseXml(input);
+  if (xml === null || nameOf2(xml.root) !== "glossgroup") return nothing();
+  return collect3(input, xml, descendantsOf(xml.root, "glossentry"), "dita-glossgroup", GLOSSGROUP_LABEL);
+}
+var ditaGlossentryReader = {
+  construct: "dita-glossentry",
+  label: GLOSSENTRY_LABEL,
+  formats: ["xml"],
+  read: readGlossentry,
+  // The glossentry is the file's root, so the file's `xml:lang` sits on it and
+  // is written again when the entry is.
+  apply: (input, terms) => applyEntries(input, readGlossentry, terms, {
+    holds: DITA_HOLDS,
+    id: true,
+    serialize: (term, file) => ditaEntry(term, textOf(file.metadata["xml:lang"]) === void 0 ? void 0 : term.language)
+  })
+};
+var ditaGlossgroupReader = {
+  construct: "dita-glossgroup",
+  label: GLOSSGROUP_LABEL,
+  formats: ["xml"],
+  read: readGlossgroup,
+  apply: (input, terms) => applyEntries(input, readGlossgroup, terms, { holds: DITA_HOLDS, id: true, serialize: (term) => ditaEntry(term) })
+};
+
+// src/term/core/readers/docbook.ts
+var LABEL = "DocBook glossary";
+function referenceOf(el) {
+  return textOf(textOfElement(el)) ?? textOf(el.getAttribute("otherterm"));
+}
+function definitionOf2(glossdef) {
+  const children = childrenOf(glossdef);
+  const blocks = children.filter((child) => nameOf2(child) !== "glossseealso");
+  if (blocks.length === 0) return children.length === 0 ? textOfElement(glossdef) : "";
+  return blocks.map(textOfElement).filter((text2) => text2 !== "").join("\n\n");
+}
+function read(input) {
+  const xml = parseXml(input);
+  if (xml === null) return nothing();
+  const glossaries = nameOf2(xml.root) === "glossary" ? [xml.root] : descendantsOf(xml.root, "glossary");
+  if (glossaries.length === 0) return nothing();
+  const seen = /* @__PURE__ */ new Set();
+  const result = nothing();
+  for (const glossary of glossaries) {
+    for (const entry of descendantsOf(glossary, "glossentry")) {
+      if (seen.has(entry)) continue;
+      seen.add(entry);
+      const raw = {};
+      const lines = {};
+      const alts = [];
+      const definitions = [];
+      const related = [];
+      for (const child of childrenOf(entry)) {
+        const name = nameOf2(child);
+        if (name === "glossterm" && raw.label === void 0) {
+          raw.label = textOfElement(child);
+          lines.label = lineOfElement(child);
+        } else if (name === "glossterm" || name === "acronym") {
+          alts.push(textOfElement(child));
+          lines["alt-labels"] ??= lineOfElement(child);
+        } else if (name === "glossdef") {
+          definitions.push(definitionOf2(child));
+          lines.definition ??= lineOfElement(child);
+          for (const seeAlso of childrenOf(child, "glossseealso")) {
+            const target = referenceOf(seeAlso);
+            if (target !== void 0) related.push(target);
+            lines["related-terms"] ??= lineOfElement(seeAlso);
+          }
+        } else if (name === "glosssee" && raw.see === void 0) {
+          raw.see = referenceOf(child);
+          lines.see = lineOfElement(child);
+        }
+      }
+      raw["alt-labels"] = alts;
+      raw.definition = definitions.filter((text2) => text2 !== "").join("\n\n");
+      raw["related-terms"] = related;
+      const line = lineOfElement(entry);
+      const record = recordOf(raw);
+      if (record === void 0) {
+        result.notices.push(skipped(input, line, LABEL));
+        continue;
+      }
+      const span = spanOfElement(xml, entry);
+      result.terms.push(
+        termOf(input, {
+          record,
+          constructId: entry.getAttribute("xml:id"),
+          construct: "docbook-glossary",
+          line,
+          lines,
+          ...span === void 0 ? {} : { span }
+        })
+      );
+    }
+  }
+  return result;
+}
+var docbookGlossaryReader = {
+  construct: "docbook-glossary",
+  label: LABEL,
+  formats: ["xml"],
+  read,
+  apply: (input, terms) => applyEntries(input, read, terms, { holds: DOCBOOK_HOLDS, id: true, serialize: docbookEntry })
+};
+
+// src/term/core/readers/html.ts
+import { parse as parse2 } from "parse5";
+var cache2 = /* @__PURE__ */ new WeakMap();
+function parseHtml(input) {
+  const cached = cache2.get(input);
+  if (cached !== void 0) return cached;
+  const shift = input.content.charCodeAt(0) === 65279 ? 1 : 0;
+  const parsed = { root: parse2(input.content.slice(shift), { sourceCodeLocationInfo: true }), shift };
+  cache2.set(input, parsed);
+  return parsed;
+}
+function isElement(node) {
+  return "tagName" in node;
+}
+function childElements2(node) {
+  return node.childNodes.filter(isElement);
+}
+function elementsNamed(node, name) {
+  const out = [];
+  const walk = (parent) => {
+    for (const child of childElements2(parent)) {
+      if (child.tagName === name) out.push(child);
+      walk(child);
+    }
+  };
+  walk(node);
+  return out;
+}
+function rawText(node) {
+  let text2 = "";
+  for (const child of node.childNodes) {
+    if (child.nodeName === "#text" && "value" in child) text2 += child.value;
+    else if (isElement(child)) text2 += rawText(child);
+  }
+  return text2;
+}
+function textOfNode(node) {
+  return collapse(rawText(node));
+}
+function attr(el, name) {
+  return el.attrs.find((a) => a.name === name)?.value;
+}
+function lineOf(el) {
+  return el.sourceCodeLocation?.startLine ?? 1;
+}
+function spanOf(parsed, first, last) {
+  const start2 = first.sourceCodeLocation?.startOffset;
+  const end = last.sourceCodeLocation?.endOffset;
+  if (start2 === void 0 || end === void 0) return void 0;
+  return { start: start2 + parsed.shift, end: end + parsed.shift };
+}
+function definitionOf3(dd) {
+  const paragraphs = childElements2(dd).filter((child) => child.tagName === "p");
+  if (paragraphs.length === 0) return textOfNode(dd);
+  return paragraphs.map(textOfNode).filter((text2) => text2 !== "").join("\n\n");
+}
+function listItems(dl) {
+  return childElements2(dl).flatMap((child) => child.tagName === "div" ? childElements2(child) : [child]);
+}
+var DL_LABEL = "dl";
+function readDl(input) {
+  if (!declares(input, "term-set")) return nothing();
+  const parsed = parseHtml(input);
+  const result = nothing();
+  for (const dl of elementsNamed(parsed.root, "dl")) {
+    const items = listItems(dl).filter((item2) => item2.tagName === "dt" || item2.tagName === "dd");
+    let i = 0;
+    while (i < items.length) {
+      const dts = [];
+      const dds = [];
+      for (let item2 = items[i]; item2?.tagName === "dt"; item2 = items[++i]) dts.push(item2);
+      for (let item2 = items[i]; item2?.tagName === "dd"; item2 = items[++i]) dds.push(item2);
+      const first = dts[0] ?? dds[0];
+      const last = dds[dds.length - 1] ?? dts[dts.length - 1];
+      if (first === void 0 || last === void 0) break;
+      const named = dts.filter((dt) => textOfNode(dt) !== "");
+      const [labelDt, ...altDts] = named;
+      const [dd] = dds;
+      const raw = {
+        label: labelDt === void 0 ? void 0 : textOfNode(labelDt),
+        "alt-labels": altDts.map(textOfNode),
+        definition: dd === void 0 ? void 0 : definitionOf3(dd)
+      };
+      const lines = {
+        label: labelDt === void 0 ? void 0 : lineOf(labelDt),
+        "alt-labels": altDts[0] === void 0 ? void 0 : lineOf(altDts[0]),
+        definition: dd === void 0 ? void 0 : lineOf(dd)
+      };
+      const line = lineOf(first);
+      const record = recordOf(raw);
+      if (record === void 0) {
+        result.notices.push(skipped(input, line, DL_LABEL));
+        continue;
+      }
+      const span = spanOf(parsed, first, last);
+      const constructId = dts.map((dt) => textOf(attr(dt, "id"))).find((id) => id !== void 0);
+      result.terms.push(
+        termOf(input, {
+          record,
+          constructId,
+          construct: "html-dl",
+          line,
+          lines,
+          ...span === void 0 ? {} : { span }
+        })
+      );
+    }
+  }
+  return result;
+}
+var DFN_LABEL = "dfn";
+function insideDt(el) {
+  let parent = el.parentNode;
+  while (parent !== null && "tagName" in parent) {
+    if (parent.tagName === "dt") return true;
+    parent = parent.parentNode;
+  }
+  return false;
+}
+function dfnFields(dfn) {
+  const title = textOf(attr(dfn, "title"));
+  if (title !== void 0) return { label: title };
+  const content = dfn.childNodes.filter(
+    (child) => child.nodeName === "#text" && "value" in child ? child.value.trim() !== "" : isElement(child)
+  );
+  const [only] = content;
+  if (content.length === 1 && only !== void 0 && isElement(only) && only.tagName === "abbr") {
+    const abbrTitle = textOf(attr(only, "title"));
+    if (abbrTitle !== void 0) return { label: abbrTitle, alt: textOfNode(only) };
+  }
+  return { label: textOfNode(dfn) };
+}
+function readDfn(input) {
+  if (!declares(input, "term-set")) return nothing();
+  const parsed = parseHtml(input);
+  const result = nothing();
+  for (const dfn of elementsNamed(parsed.root, "dfn")) {
+    if (insideDt(dfn)) continue;
+    const { label, alt } = dfnFields(dfn);
+    const line = lineOf(dfn);
+    const record = recordOf({ label, "alt-labels": alt });
+    if (record === void 0) {
+      result.notices.push(skipped(input, line, DFN_LABEL));
+      continue;
+    }
+    const span = spanOf(parsed, dfn, dfn);
+    const term = termOf(input, {
+      record,
+      constructId: attr(dfn, "id"),
+      construct: "html-dfn",
+      line,
+      lines: { label: line, "alt-labels": line },
+      ...span === void 0 ? {} : { span }
+    });
+    result.terms.push(term);
+  }
+  return result;
+}
+var htmlDlReader = {
+  construct: "html-dl",
+  label: DL_LABEL,
+  formats: ["html"],
+  read: readDl,
+  apply: (input, terms) => applyEntries(input, readDl, terms, { holds: LIST_HOLDS, id: true, serialize: htmlDlEntry })
+};
+var htmlDfnReader = {
+  construct: "html-dfn",
+  label: DFN_LABEL,
+  formats: ["html"],
+  read: readDfn
+};
+
+// src/term/core/readers/manifest.ts
+import { isMap, isNode, isScalar, isSeq, LineCounter, parseDocument, stringify as stringifyYaml } from "yaml";
+var LABEL2 = "manifest";
+var FIELDS = new Set(TERM_FIELDS);
+function isField(key) {
+  return FIELDS.has(key);
+}
+function read2(input) {
+  if ((input.path ?? input.file).toLowerCase().endsWith(".json")) {
+    try {
+      JSON.parse(input.content);
+    } catch (error) {
+      throw new TermError(`${input.file}: could not be parsed as JSON: ${errorMessage(error)}`);
+    }
+  }
+  const lineCounter = new LineCounter();
+  const doc = parseDocument(input.content, { lineCounter, prettyErrors: false });
+  const [firstError] = doc.errors;
+  if (firstError !== void 0) {
+    throw new TermError(`${input.file}: could not be parsed as YAML: ${firstError.message}`);
+  }
+  const lineOf2 = (node) => {
+    const range = node?.range;
+    return range === void 0 || range === null ? void 0 : lineCounter.linePos(range[0]).line;
+  };
+  const root = doc.contents;
+  if (root === null) return { terms: [], notices: [] };
+  if (!isMap(root)) {
+    throw new TermError(`${input.file}: a term manifest is a mapping of id to entry.`);
+  }
+  const terms = [];
+  const notices = [];
+  for (const pair of root.items) {
+    const keyNode = isScalar(pair.key) ? pair.key : void 0;
+    const id = textOf(keyNode?.value);
+    const line = lineOf2(keyNode) ?? 1;
+    if (id === void 0) {
+      throw new TermError(`${input.file}:${line}: an entry's key is its id, and must be a non-empty string.`);
+    }
+    const value = pair.value;
+    if (!isMap(value)) {
+      throw new TermError(`${input.file}:${line}: entry "${id}" is not a mapping of fields.`);
+    }
+    const raw = {};
+    const lines = {};
+    for (const field of value.items) {
+      const fieldKey = isScalar(field.key) ? field.key : void 0;
+      const name = fieldKey?.value;
+      if (typeof name !== "string" || !isField(name)) continue;
+      const fieldValue = field.value;
+      raw[name] = isNode(fieldValue) ? fieldValue.toJSON() : fieldValue;
+      lines[name] = lineOf2(fieldKey);
+    }
+    const record = recordOf(raw);
+    if (record === void 0) {
+      notices.push(skipped(input, line, LABEL2));
+      continue;
+    }
+    for (const ignored of ignoredFields(raw)) {
+      notices.push(ignoredNotice(input, lines[ignored.field] ?? line, record.label, ignored));
+    }
+    terms.push(termOf(input, { record, recordId: id, construct: "manifest", line, lines }));
+  }
+  return { terms, notices };
+}
+function entryOf(record) {
+  const entry = {};
+  for (const field of TERM_FIELDS) {
+    const value = record[field];
+    if (value !== void 0) entry[field] = value;
+  }
+  return entry;
+}
+function currentRecord(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return {};
+  const raw = {};
+  for (const field of TERM_FIELDS) raw[field] = value[field];
+  return recordOf(raw) ?? {};
+}
+function changedFields(current, record) {
+  return TERM_FIELDS.filter((field) => JSON.stringify(current[field]) !== JSON.stringify(record[field]));
+}
+function applyJson(input, terms) {
+  let data;
+  try {
+    data = JSON.parse(input.content);
+  } catch (error) {
+    throw new TermError(`${input.file}: could not be parsed as JSON: ${errorMessage(error)}`);
+  }
+  if (typeof data !== "object" || data === null || Array.isArray(data)) {
+    throw new TermError(`${input.file}: a term manifest is a mapping of id to entry.`);
+  }
+  const root = data;
+  let changed = false;
+  for (const term of terms) {
+    const existing = root[term.id];
+    if (typeof existing !== "object" || existing === null || Array.isArray(existing)) {
+      if (existing !== void 0) {
+        throw new TermError(`${input.file}: entry "${term.id}" is not a mapping of fields.`);
+      }
+      root[term.id] = entryOf(term.record);
+      changed = true;
+      continue;
+    }
+    const entry = existing;
+    const fields = changedFields(currentRecord(entry), term.record);
+    if (fields.length === 0) continue;
+    const next = {};
+    for (const [key, value] of Object.entries(entry)) {
+      if (!isField(key) || !fields.includes(key)) next[key] = value;
+      else if (term.record[key] !== void 0) next[key] = term.record[key];
+    }
+    for (const field of fields) {
+      if (term.record[field] !== void 0 && !(field in next)) next[field] = term.record[field];
+    }
+    root[term.id] = next;
+    changed = true;
+  }
+  if (!changed) return input.content;
+  const text2 = `${JSON.stringify(root, null, 2)}
+`;
+  return input.content.includes("\r\n") ? text2.replaceAll("\n", "\r\n") : text2;
+}
+function entryRanges(root) {
+  const ranges = /* @__PURE__ */ new Map();
+  for (const pair of root.items) {
+    if (!isScalar(pair.key)) continue;
+    const id = textOf(pair.key.value);
+    const start2 = pair.key.range?.[0];
+    const end = isNode(pair.value) ? pair.value.range?.[1] : pair.key.range?.[1];
+    if (id !== void 0 && start2 !== void 0 && end !== void 0) ranges.set(id, { start: start2, end });
+  }
+  return ranges;
+}
+function editEntry(doc, entry, record) {
+  const fields = changedFields(currentRecord(entry.toJSON()), record);
+  for (const field of fields) {
+    const value = record[field];
+    if (value === void 0) {
+      entry.delete(field);
+    } else if (Array.isArray(value)) {
+      const previous = entry.get(field, true);
+      const node = doc.createNode(value);
+      node.flow = isSeq(previous) && previous.flow === true;
+      entry.set(field, node);
+    } else {
+      entry.set(field, value);
+    }
+  }
+  return fields.length > 0;
+}
+function applyYaml(input, terms) {
+  const { content } = input;
+  const doc = parseDocument(content, { prettyErrors: false });
+  const [firstError] = doc.errors;
+  if (firstError !== void 0) {
+    throw new TermError(`${input.file}: could not be parsed as YAML: ${firstError.message}`);
+  }
+  const eol = content.includes("\r\n") ? "\r\n" : "\n";
+  const root = doc.contents;
+  if (root === null) {
+    if (terms.length === 0) return content;
+    const entries = Object.fromEntries(terms.map((term) => [term.id, entryOf(term.record)]));
+    return stringifyYaml(entries, { lineWidth: 0 }).replaceAll("\n", eol);
+  }
+  if (!isMap(root)) {
+    throw new TermError(`${input.file}: a term manifest is a mapping of id to entry.`);
+  }
+  const wholeFile = root.flow === true;
+  const before = entryRanges(root);
+  const changed = [];
+  const added = [];
+  for (const term of terms) {
+    const pair = root.items.find((item2) => isScalar(item2.key) && textOf(item2.key.value) === term.id);
+    if (pair === void 0) {
+      root.add(doc.createPair(term.id, entryOf(term.record)));
+      added.push(term.id);
+      continue;
+    }
+    if (!isMap(pair.value)) {
+      throw new TermError(`${input.file}: entry "${term.id}" is not a mapping of fields.`);
+    }
+    if (editEntry(doc, pair.value, term.record)) changed.push(term.id);
+  }
+  if (changed.length === 0 && added.length === 0) return content;
+  const text2 = doc.toString({ lineWidth: 0 });
+  if (wholeFile) return text2.replaceAll("\n", eol);
+  const written = parseDocument(text2).contents;
+  const after = isMap(written) ? entryRanges(written) : /* @__PURE__ */ new Map();
+  const entryText = (id) => {
+    const range = after.get(id);
+    if (range === void 0) throw new TermError(`${input.file}: could not write entry "${id}".`);
+    return text2.slice(range.start, range.end).replaceAll("\n", eol);
+  };
+  let next = content;
+  const edits = changed.map((id) => ({ id, range: before.get(id) })).sort((a, b) => (b.range?.start ?? 0) - (a.range?.start ?? 0));
+  for (const { id, range } of edits) {
+    if (range === void 0) throw new TermError(`${input.file}: could not write entry "${id}".`);
+    next = next.slice(0, range.start) + entryText(id) + next.slice(range.end);
+  }
+  if (added.length > 0) {
+    if (next !== "" && !next.endsWith("\n")) next += eol;
+    next += added.map((id) => `${entryText(id)}${eol}`).join("");
+  }
+  return next;
+}
+function isJson(input) {
+  return (input.path ?? input.file).toLowerCase().endsWith(".json");
+}
+var manifestReader = {
+  construct: "manifest",
+  label: LABEL2,
+  formats: ["manifest"],
+  read: read2,
+  apply: (input, terms) => isJson(input) ? applyJson(input, terms) : applyYaml(input, terms)
+};
+
+// src/term/core/readers/page.ts
+var LABEL3 = "page";
+function read3(input) {
+  if (!declares(input, "term")) return nothing();
+  const raw = {};
+  const lines = {};
+  for (const field of TERM_FIELDS) {
+    raw[field] = input.metadata[field];
+    lines[field] = input.lineFor(`/${field}`);
+  }
+  const record = recordOf(raw);
+  if (record === void 0) return { terms: [], notices: [skipped(input, 1, LABEL3)] };
+  return {
+    terms: [termOf(input, { record, recordId: input.metadata["id"], construct: "page", line: 1, lines })],
+    notices: ignoredFields(raw).map(
+      (ignored) => ignoredNotice(input, lines[ignored.field] ?? 1, record.label, ignored)
+    )
+  };
+}
+function apply(input, terms) {
+  const [term] = terms;
+  if (term === void 0) return input.content;
+  const [current] = read3(input).terms;
+  if (current === void 0) {
+    throw new TermError(`${input.file}: is not a term page any more. Read the file again before writing it.`);
+  }
+  const patch = {};
+  const deletions = [];
+  for (const field of TERM_FIELDS) {
+    if (sameFields(current.record, term.record, [field])) continue;
+    const value = term.record[field];
+    if (value === void 0) deletions.push(field);
+    else patch[field] = value;
+  }
+  if (Object.keys(patch).length === 0 && deletions.length === 0) return input.content;
+  const extractor = extractorByName(input.format);
+  if (extractor?.apply === void 0) {
+    throw new TermError(`${input.file}: manni cannot write ${input.format} metadata.`);
+  }
+  const filePath = input.path ?? input.file;
+  let next;
+  try {
+    next = extractor.apply(input.content, patch, { deletions, filePath });
+  } catch (error) {
+    throw new TermError(`${input.file}: ${errorMessage(error)}`);
+  }
+  const written = extractor.extract(next, filePath).data;
+  for (const field of deletions) {
+    if (written[field] !== void 0) {
+      throw new TermError(`${input.file}: could not remove ${field} from its ${input.format} metadata. Remove it by hand.`);
+    }
+  }
+  return next;
+}
+var pageReader = {
+  construct: "page",
+  label: LABEL3,
+  formats: ["markdown", "mdx", "asciidoc", "rst", "html", "xml"],
+  read: read3,
+  apply
+};
+
+// src/term/core/readers/structured.ts
+var STRUCTURED_READERS = [
+  pageReader,
+  manifestReader,
+  ditaGlossentryReader,
+  ditaGlossgroupReader,
+  docbookGlossaryReader,
+  htmlDlReader,
+  htmlDfnReader
+];
+
+// src/term/core/readers/body.ts
+function textStart(line) {
+  return line.start + (line.text.length - line.text.trimStart().length);
+}
+function isBlank(line) {
+  return line.text.trim() === "";
+}
+function nextNonBlank(lines, from) {
+  let k = from;
+  for (let line = lines[k]; line !== void 0 && !line.code && isBlank(line); line = lines[k]) k++;
+  return k;
+}
+function bodyLines(input) {
+  const { content } = input;
+  const bodyStart = locateFrontmatter(content)?.closeEnd ?? 0;
+  const body = content.slice(bodyStart);
+  const code = codeRegions(body, input.format, { spans: false });
+  let line = 1;
+  for (let i = 0; i < bodyStart; i++) {
+    if (content.charCodeAt(i) === 10) line++;
+  }
+  const out = [];
+  let pos = bodyStart;
+  while (pos < content.length) {
+    const nl = content.indexOf("\n", pos);
+    const stop = nl === -1 ? content.length : nl;
+    const end = stop > pos && content.charCodeAt(stop - 1) === 13 ? stop - 1 : stop;
+    out.push({
+      text: content.slice(pos, end),
+      start: pos,
+      end,
+      line,
+      code: codeEndAt(code, pos - bodyStart) !== void 0
+    });
+    line++;
+    pos = stop + 1;
+  }
+  return out;
+}
+function definitionText(paragraphs) {
+  const text2 = paragraphs.map(
+    (lines) => lines.map((l) => l.trim()).filter((l) => l !== "").join(" ")
+  ).filter((p) => p !== "").join("\n\n");
+  return text2 === "" ? void 0 : text2;
+}
+function termOf2(input, construct, entry) {
+  const [first, ...rest] = entry.labels;
+  const label = first?.text.trim() ?? "";
+  const record = { label };
+  const fieldLines = { label: first?.line ?? entry.definitionLine };
+  const alts = rest.map((l) => l.text.trim()).filter((t) => t !== "");
+  const [firstAlt] = rest;
+  if (alts.length > 0 && firstAlt !== void 0) {
+    record["alt-labels"] = alts;
+    fieldLines["alt-labels"] = firstAlt.line;
+  }
+  record.definition = entry.definition;
+  fieldLines.definition = entry.definitionLine;
+  const language = input.metadata["language"];
+  return {
+    id: slugOf(label),
+    record,
+    ...typeof language === "string" && language.trim() !== "" ? { language: language.trim() } : {},
+    location: {
+      file: input.file,
+      ...input.path === void 0 ? {} : { path: input.path },
+      construct,
+      line: first?.line ?? entry.definitionLine,
+      fieldLines,
+      span: { start: entry.start, end: entry.end }
+    }
+  };
+}
+function skippedNotice(input, line, label, missing) {
+  return `${input.file}:${String(line)}: skipped a ${label} entry with no ${missing}.`;
+}
+
+// src/term/core/readers/asciidoc-glossary.ts
+var LABEL4 = "[glossary] list";
+var ATTRIBUTE = /^\[glossary\][ \t]*$/;
+var ITEM = /^[ \t]*(.*?[^:\s])::(?:[ \t]+(.*))?$/;
+var BLOCK_TITLE = /^\.[^.\s]/;
+var LIST_END = /^(?:=+[ \t]|\[.*\][ \t]*$|(?:-{4,}|={4,}|\*{4,}|\.{4,}|_{4,}|\+{4,}|\|===)[ \t]*$)/;
+function item(line) {
+  const match = ITEM.exec(line.text);
+  const term = match?.[1];
+  if (match === null || term === void 0) return void 0;
+  const text2 = match[2]?.trim();
+  return { term, text: text2 === "" ? void 0 : text2 };
+}
+function read4(input) {
+  const terms = [];
+  const notices = [];
+  const lines = bodyLines(input);
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    i++;
+    if (line === void 0 || line.code || !ATTRIBUTE.test(line.text)) continue;
+    let start2 = i;
+    for (let l = lines[start2]; l !== void 0 && !l.code && (isBlank(l) || BLOCK_TITLE.test(l.text)); l = lines[start2]) {
+      start2++;
+    }
+    const first = lines[start2];
+    if (first === void 0 || first.code || item(first) === void 0) continue;
+    i = readList(input, lines, start2, terms, notices);
+  }
+  return { terms, notices };
+}
+function readList(input, lines, at, terms, notices) {
+  let pending = [];
+  let open;
+  const close = () => {
+    if (open !== void 0) {
+      const text2 = definitionText(open.paragraphs);
+      const [firstLabel] = open.labels;
+      if (text2 !== void 0 && firstLabel !== void 0) {
+        terms.push(
+          termOf2(input, "asciidoc-glossary", {
+            labels: open.labels.map((l) => ({ text: itemTerm(l), line: l.line })),
+            definition: text2,
+            definitionLine: open.definitionLine,
+            start: textStart(firstLabel),
+            end: open.last.end
+          })
+        );
+      } else if (firstLabel !== void 0) {
+        notices.push(skippedNotice(input, firstLabel.line, LABEL4, "definition"));
+      }
+      open = void 0;
+    }
+    const [firstPending] = pending;
+    if (firstPending !== void 0) {
+      notices.push(skippedNotice(input, firstPending.line, LABEL4, "definition"));
+      pending = [];
+    }
+  };
+  let i = at;
+  for (; ; ) {
+    const line = lines[i];
+    if (line === void 0 || line.code) break;
+    if (isBlank(line)) {
+      close();
+      const k = nextNonBlank(lines, i);
+      const next = lines[k];
+      if (next === void 0 || next.code || item(next) === void 0) break;
+      i = k;
+      continue;
+    }
+    const entry = item(line);
+    if (entry !== void 0) {
+      if (open !== void 0) close();
+      pending.push(line);
+      if (entry.text !== void 0) {
+        open = { labels: pending, definitionLine: line.line, paragraphs: [[entry.text]], last: line };
+        pending = [];
+      }
+      i++;
+      continue;
+    }
+    if (line.text.trim() === "+" && open !== void 0) {
+      open.paragraphs.push([]);
+      i++;
+      continue;
+    }
+    if (LIST_END.test(line.text) || BLOCK_TITLE.test(line.text)) break;
+    if (open !== void 0) {
+      open.paragraphs.at(-1)?.push(line.text);
+      open.last = line;
+    } else if (pending.length > 0) {
+      open = { labels: pending, definitionLine: line.line, paragraphs: [[line.text]], last: line };
+      pending = [];
+    } else {
+      break;
+    }
+    i++;
+  }
+  close();
+  return i;
+}
+function itemTerm(line) {
+  return item(line)?.term ?? line.text;
+}
+var asciidocGlossaryReader = {
+  construct: "asciidoc-glossary",
+  label: LABEL4,
+  formats: ["asciidoc"],
+  read: read4,
+  apply: (input, terms) => applyEntries(input, read4, terms, { holds: LIST_HOLDS, id: false, serialize: (term) => asciidocEntry(term.record) })
+};
+
+// src/term/core/readers/markdown-deflist.ts
+var LABEL5 = "definition list";
+var DEFINITION = /^:(?:[ \t]+(.*))?$/;
+var INDENTED = /^(?: {4}|\t)/;
+var HEADING = /^#{1,6}(?:[ \t]|$)/;
+function definitionStart(line) {
+  if (line === void 0 || line.code) return void 0;
+  const match = DEFINITION.exec(line.text);
+  return match === null ? void 0 : match[1] ?? "";
+}
+function read5(input) {
+  const terms = [];
+  const notices = [];
+  if (input.metadata["type"] !== "term-set") return { terms, notices };
+  const lines = bodyLines(input);
+  let i = 0;
+  while (i < lines.length) {
+    const first = lines[i];
+    if (first === void 0) break;
+    if (first.code || isBlank(first)) {
+      i++;
+      continue;
+    }
+    const labels = [];
+    let j = i;
+    for (; ; ) {
+      const line = lines[j];
+      if (line === void 0 || line.code || isBlank(line) || definitionStart(line) !== void 0) break;
+      labels.push(line);
+      j++;
+    }
+    const opener = definitionStart(lines[j]);
+    if (opener === void 0) {
+      i = j === i ? i + 1 : j;
+      continue;
+    }
+    if (labels.length === 0 || labels.some((l) => HEADING.test(l.text))) {
+      const orphan = lines[j];
+      if (orphan !== void 0) notices.push(skippedNotice(input, orphan.line, LABEL5, "term"));
+      i = readDefinitions(lines, j, []);
+      continue;
+    }
+    const definitions = [];
+    i = readDefinitions(lines, j, definitions);
+    const firstLabel = labels[0];
+    const [kept] = definitions;
+    if (firstLabel === void 0 || kept === void 0) continue;
+    const text2 = definitionText(kept.paragraphs);
+    if (text2 === void 0) {
+      notices.push(skippedNotice(input, firstLabel.line, LABEL5, "definition"));
+      continue;
+    }
+    for (const extra of definitions.slice(1)) {
+      notices.push(
+        `${input.file}:${String(extra.line)}: kept the first of ${String(definitions.length)} definitions for "${firstLabel.text.trim()}".`
+      );
+    }
+    const last = lastContentLine(lines, i);
+    terms.push(
+      termOf2(input, "markdown-deflist", {
+        labels: labels.map((l) => ({ text: l.text, line: l.line })),
+        definition: text2,
+        definitionLine: kept.line,
+        start: textStart(firstLabel),
+        end: last?.end ?? firstLabel.end
+      })
+    );
+  }
+  return { terms, notices };
+}
+function lastContentLine(lines, stop) {
+  for (let k = stop - 1; k >= 0; k--) {
+    const line = lines[k];
+    if (line !== void 0 && !isBlank(line)) return line;
+  }
+  return void 0;
+}
+function readDefinitions(lines, at, out) {
+  let i = at;
+  for (; ; ) {
+    const opener = lines[i];
+    const text2 = definitionStart(opener);
+    if (opener === void 0 || text2 === void 0) return i;
+    const definition = { line: opener.line, paragraphs: [[text2]] };
+    out.push(definition);
+    i++;
+    for (; ; ) {
+      const line = lines[i];
+      if (line === void 0 || line.code) return i;
+      if (definitionStart(line) !== void 0) break;
+      if (!isBlank(line)) {
+        definition.paragraphs.at(-1)?.push(line.text.replace(INDENTED, ""));
+        i++;
+        continue;
+      }
+      const k = nextNonBlank(lines, i);
+      const next = lines[k];
+      if (next === void 0 || next.code) return i;
+      if (definitionStart(next) !== void 0) {
+        i = k;
+        break;
+      }
+      if (!INDENTED.test(next.text)) return i;
+      definition.paragraphs.push([]);
+      i = k;
+    }
+  }
+}
+var markdownDeflistReader = {
+  construct: "markdown-deflist",
+  label: LABEL5,
+  formats: ["markdown", "mdx"],
+  read: read5,
+  apply: (input, terms) => applyEntries(input, read5, terms, { holds: LIST_HOLDS, id: false, serialize: (term) => markdownEntry(term.record) })
+};
+
+// src/term/core/readers/rst-glossary.ts
+var LABEL6 = ".. glossary::";
+var DIRECTIVE = /^[ \t]*\.\.[ \t]+glossary::[ \t]*$/;
+var CODE_DIRECTIVE = /^[ \t]*\.\.[ \t]+(?:code-block|code|sourcecode)::/;
+var EXPLICIT_MARKUP = /^[ \t]*\.\.(?:[ \t]|$)/;
+var OPTION = /^[ \t]*:[^:\s][^:]*:(?:[ \t].*)?$/;
+var CLASSIFIER = /[ \t]+:[ \t]+/;
+function indentOf(text2) {
+  let width = 0;
+  for (const ch of text2) {
+    if (ch === " ") width++;
+    else if (ch === "	") width += 8 - width % 8;
+    else break;
+  }
+  return width;
+}
+function opensLiteral(line) {
+  if (CODE_DIRECTIVE.test(line.text)) return true;
+  return !EXPLICIT_MARKUP.test(line.text) && line.text.trimEnd().endsWith("::");
+}
+function read6(input) {
+  const terms = [];
+  const notices = [];
+  const lines = bodyLines(input);
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (line === void 0) break;
+    if (isBlank(line)) {
+      i++;
+      continue;
+    }
+    if (DIRECTIVE.test(line.text)) {
+      i = readGlossary(input, lines, i, terms, notices);
+      continue;
+    }
+    i = opensLiteral(line) ? blockEnd(lines, i + 1, indentOf(line.text)) : i + 1;
+  }
+  return { terms, notices };
+}
+function blockEnd(lines, from, indent) {
+  let k = from;
+  for (let l = lines[k]; l !== void 0 && (isBlank(l) || indentOf(l.text) > indent); l = lines[k]) k++;
+  return k;
+}
+function readGlossary(input, lines, at, terms, notices) {
+  const directive = lines[at];
+  if (directive === void 0) return at + 1;
+  const end = blockEnd(lines, at + 1, indentOf(directive.text));
+  let i = at + 1;
+  for (let l = lines[i]; i < end && l !== void 0 && !isBlank(l) && OPTION.test(l.text); l = lines[i]) i++;
+  let base;
+  let labels = [];
+  let definition;
+  let orphan = false;
+  const close = () => {
+    const [first] = labels;
+    if (first !== void 0) {
+      const text2 = definition === void 0 ? void 0 : definitionText(definition.paragraphs);
+      if (definition !== void 0 && text2 !== void 0) {
+        terms.push(
+          termOf2(input, "rst-glossary", {
+            labels: labels.map((l) => ({ text: termText(l), line: l.line })),
+            definition: text2,
+            definitionLine: definition.line,
+            start: textStart(first),
+            end: definition.last.end
+          })
+        );
+      } else {
+        notices.push(skippedNotice(input, first.line, LABEL6, "definition"));
+      }
+    }
+    labels = [];
+    definition = void 0;
+  };
+  let blank = false;
+  for (; i < end; i++) {
+    const line = lines[i];
+    if (line === void 0) break;
+    if (isBlank(line)) {
+      if (definition !== void 0) definition.gap = true;
+      blank = true;
+      continue;
+    }
+    const indent = indentOf(line.text);
+    base ??= indent;
+    if (indent <= base) {
+      if (definition !== void 0 || blank) close();
+      orphan = false;
+      blank = false;
+      labels.push(line);
+      continue;
+    }
+    blank = false;
+    if (definition !== void 0) {
+      if (definition.gap) {
+        definition.paragraphs.push([]);
+        definition.gap = false;
+      }
+      definition.paragraphs.at(-1)?.push(line.text);
+      definition.last = line;
+    } else if (labels.length > 0) {
+      definition = { line: line.line, paragraphs: [[line.text]], last: line, gap: false };
+    } else if (!orphan) {
+      notices.push(skippedNotice(input, line.line, LABEL6, "term"));
+      orphan = true;
+    }
+  }
+  close();
+  return end;
+}
+function termText(line) {
+  const text2 = line.text.trim();
+  const match = CLASSIFIER.exec(text2);
+  return match === null ? text2 : text2.slice(0, match.index);
+}
+var rstGlossaryReader = {
+  construct: "rst-glossary",
+  label: LABEL6,
+  formats: ["rst"],
+  read: read6,
+  apply: (input, terms) => applyEntries(input, read6, terms, { holds: LIST_HOLDS, id: false, serialize: (term) => rstEntry(term.record) })
+};
+
+// src/term/core/readers/text.ts
+var TEXT_READERS = [
+  markdownDeflistReader,
+  asciidocGlossaryReader,
+  rstGlossaryReader
+];
+
+// src/term/core/readers/index.ts
+var TERM_READERS = [...STRUCTURED_READERS, ...TEXT_READERS];
+function readersForFormat(format, readers = TERM_READERS) {
+  return readers.filter((reader) => reader.formats.includes(format));
+}
+function readerForConstruct(construct, readers = TERM_READERS) {
+  return readers.find((reader) => reader.construct === construct);
+}
+
+// src/term/core/load-set.ts
+var MANIFEST_FORMAT = "manifest";
+var MANIFEST_EXTENSIONS = /* @__PURE__ */ new Set([".yaml", ".yml", ".json"]);
+function manifestInput(content, file, path) {
+  return { content, file, path, format: MANIFEST_FORMAT, metadata: {}, lineFor: () => void 0 };
+}
+function labelsOf2(value) {
+  if (typeof value === "string") return value.trim() === "" ? [] : [value];
+  if (Array.isArray(value)) {
+    return value.filter((item2) => typeof item2 === "string" && item2.trim() !== "");
+  }
+  return [];
+}
+function referencesOf(input) {
+  const references2 = [];
+  const add = (value, pointer) => {
+    for (const label of labelsOf2(value)) {
+      const line = input.lineFor(pointer);
+      references2.push({ file: input.file, label, ...line === void 0 ? {} : { line } });
+    }
+  };
+  add(input.metadata["concepts"], "/concepts");
+  const kg = input.metadata["kg"];
+  if (typeof kg === "object" && kg !== null && !Array.isArray(kg)) {
+    add(kg["concepts"], "/kg/concepts");
+  }
+  return references2;
+}
+function read7(input, readers, set) {
+  for (const reader of readersForFormat(input.format, readers)) {
+    const result = reader.read(input);
+    set.terms.push(...result.terms);
+    set.notices.push(...result.notices);
+  }
+}
+function extractInput(content, file, path, format) {
+  const extractor = extractorByName(format);
+  if (extractor === void 0) {
+    throw new TermError(`${file}: no reader for format "${format}".`);
+  }
+  let extracted;
+  try {
+    extracted = extractor.extract(content, path ?? file);
+  } catch (error) {
+    throw new TermError(`${file}: could not be read as ${format}: ${errorMessage(error)}`);
+  }
+  return {
+    content,
+    file,
+    ...path === void 0 ? {} : { path },
+    format: extractor.name,
+    metadata: extracted.data,
+    lineFor: extracted.lineFor
+  };
+}
+async function loadTermSet(opts) {
+  const { run } = opts;
+  const readers = opts.readers ?? TERM_READERS;
+  const exclude = opts.exclude ?? [];
+  const allowEmpty = opts.allowEmpty ?? run.config?.allowEmpty === true;
+  const usingStdin = run.inputs.includes(STDIN_TOKEN);
+  const inputs = run.inputs.filter((input) => input !== STDIN_TOKEN);
+  if (usingStdin && (opts.as === void 0 || opts.as === "")) {
+    throw new TermError("reading stdin needs --as <format>.");
+  }
+  if (inputs.length === 0 && !usingStdin && run.manifests.length === 0) {
+    throw new TermError(
+      "No files to read. Pass paths/globs, or declare a collection under `collections:` in manni.config.yaml."
+    );
+  }
+  const set = { terms: [], references: [], notices: [] };
+  if (inputs.length > 0) {
+    const { files, gitignoreSkipped, named } = await resolveTargetSet({
+      inputs,
+      cwd: run.base,
+      exclude,
+      ...opts.exts === void 0 ? {} : { exts: opts.exts },
+      allowEmpty,
+      ...gitignoreOptions({
+        ...opts.noGitignore === true ? { flag: false } : {},
+        ...run.config?.respectGitignore === void 0 ? {} : { configured: run.config.respectGitignore },
+        ...opts.onNotice ? { onNotice: opts.onNotice } : {}
+      })
+    });
+    assertNonEmpty({
+      files,
+      inputs,
+      usingStdin,
+      allowEmpty,
+      exclude,
+      ...opts.exts === void 0 ? {} : { exts: opts.exts },
+      gitignoreSkipped,
+      action: "read"
+    });
+    const namedFiles = new Set(named);
+    for (const file of files) {
+      const path = resolve2(run.base, file);
+      if (namedFiles.has(file) && MANIFEST_EXTENSIONS.has(extname(file).toLowerCase())) {
+        let content2;
+        try {
+          content2 = await readFile(path, "utf8");
+        } catch (error) {
+          throw new TermError(`${file}: could not be read: ${errorMessage(error)}`);
+        }
+        read7(manifestInput(content2, file, path), readers, set);
+        continue;
+      }
+      const extractor = extractorForExtension(extname(file));
+      if (extractor === void 0) {
+        throw new TermError(`${file}: no reader for its extension. Pass --as <format> through stdin to read it.`);
+      }
+      let content;
+      try {
+        content = await readFile(path, "utf8");
+      } catch (error) {
+        throw new TermError(`${file}: could not be read: ${errorMessage(error)}`);
+      }
+      const input = extractInput(content, file, path, extractor.name);
+      set.references.push(...referencesOf(input));
+      read7(input, readers, set);
+    }
+  }
+  if (usingStdin && opts.as !== void 0) {
+    const input = extractInput(opts.stdin ?? "", STDIN_LABEL, void 0, opts.as);
+    set.references.push(...referencesOf(input));
+    read7(input, readers, set);
+  }
+  for (const { path, written } of run.manifests) {
+    let content;
+    try {
+      content = await readFile(path, "utf8");
+    } catch {
+      const source = run.configSource ?? "manni.config.yaml";
+      throw new TermError(`${source}: term.manifests "${written}" does not exist.`);
+    }
+    read7(manifestInput(content, path, path), readers, set);
+  }
+  if (set.terms.length === 0 && !allowEmpty) {
+    throw new TermError(
+      "no terms found. A term is a page declaring type: term, or an entry in a file declaring type: term-set."
+    );
+  }
+  return set;
+}
+
+// src/term/commands/run.ts
+async function loadTerms(opts) {
+  const cwd = resolve3(opts.cwd ?? process.cwd());
+  const run = await resolveTermRun({
+    cwd,
+    inputs: opts.inputs,
+    ...opts.configPath === void 0 ? {} : { configPath: opts.configPath },
+    ...opts.collection === void 0 ? {} : { collection: opts.collection }
+  });
+  const set = await loadSet(run, opts);
+  return { cwd, run, set };
+}
+async function loadSet(run, opts) {
+  const exclude = [
+    .../* @__PURE__ */ new Set([
+      ...opts.exclude ?? [],
+      ...run.fromCollections ? run.collections.flatMap((c) => c.exclude) : []
+    ])
+  ];
+  const set = await loadTermSet({
+    run,
+    exclude,
+    ...opts.exts === void 0 ? {} : { exts: opts.exts },
+    ...opts.allowEmpty === true ? { allowEmpty: true } : {},
+    ...opts.noGitignore === true ? { noGitignore: true } : {},
+    ...opts.stdin === void 0 ? {} : { stdin: opts.stdin },
+    ...opts.as === void 0 ? {} : { as: opts.as },
+    ...opts.onNotice === void 0 ? {} : { onNotice: opts.onNotice },
+    ...opts.readers === void 0 ? {} : { readers: opts.readers }
+  });
+  for (const message of set.notices) opts.onNotice?.(message);
+  return set;
+}
+function formatChoice(value, allowed) {
+  const found = allowed.find((candidate) => candidate === value);
+  if (found === void 0) {
+    throw new TermError(`unknown format "${value}". Expected ${allowed.join(" | ")}.`);
+  }
+  return found;
+}
+function displayPath(path, cwd) {
+  if (!isAbsolute(path)) return path;
+  const rel = relative(cwd, path);
+  return (rel === "" ? "." : rel).replaceAll("\\", "/");
+}
+function valeConfigFor(run) {
+  if (run.configDir === void 0) return void 0;
+  const path = valeConfigPath(run.tools, run.configDir);
+  if (path !== void 0 && !existsSync(path)) {
+    const source = run.configSource ?? "manni.config.yaml";
+    throw new TermError(`${source}: tools.vale.config "${run.tools.vale?.config ?? path}" does not exist.`);
+  }
+  return path;
+}
+function plural3(n, one, many = `${one}s`) {
+  return `${String(n)} ${n === 1 ? one : many}`;
+}
+
+// src/term/commands/check.ts
+async function runCheck3(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 }
+  });
+  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 && !existsSync2(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: summarize2(reported, baseline),
+    frame,
+    terms: set.terms.length,
+    references: set.references.length,
+    ...baseline === void 0 ? {} : { baseline },
+    found: findings.length,
+    cwd
+  };
+}
+
+// src/term/core/writers/documents.ts
+import { join } from "node:path";
+
+// src/term/core/writers/page.ts
+import { parse as parseYaml, stringify as stringifyYaml2 } from "yaml";
+function pageMetadata(term) {
+  const { record } = term;
+  const metadata = { title: record.label };
+  if (record.abstract !== void 0) metadata["description"] = record.abstract;
+  metadata["type"] = "term";
+  metadata["id"] = term.id;
+  if (term.language !== void 0) metadata["language"] = term.language;
+  for (const field of TERM_FIELDS) {
+    const value = record[field];
+    if (value !== void 0) metadata[field] = value;
+  }
+  return metadata;
+}
+function metadataPage(format, term) {
+  const apply2 = extractorByName(format)?.apply;
+  if (apply2 === void 0) throw new TermError(`manni cannot write ${format} metadata.`);
+  return apply2("---\n---\n", pageMetadata(term));
+}
+function yamlFrontmatter(metadata) {
+  return `---
+${stringifyYaml2(metadata, { lineWidth: 0 })}---
+`;
+}
+function metaContent(value) {
+  if (typeof value === "string" && !value.includes("\n")) {
+    try {
+      if (parseYaml(value) === value) return value;
+    } catch {
+    }
+  }
+  return JSON.stringify(value);
+}
+function htmlPage(term) {
+  const metadata = pageMetadata(term);
+  const metas = Object.entries(metadata).filter(([key]) => key !== "title").map(([key, value]) => `    <meta name="${xmlAttribute(key)}" content="${xmlAttribute(metaContent(value))}">`);
+  return fileOf([
+    "<!DOCTYPE html>",
+    "<html>",
+    "  <head>",
+    `    <title>${xmlText(term.record.label)}</title>`,
+    ...metas,
+    "  </head>",
+    "  <body></body>",
+    "</html>"
+  ]);
+}
+
+// src/term/core/writers/render-util.ts
+var DEFAULT_LANGUAGE = "en";
+function droppedFields(terms, held) {
+  const dropped = [];
+  for (const term of terms) {
+    for (const field of TERM_FIELDS) {
+      if (term.record[field] !== void 0 && !held.includes(field)) dropped.push({ id: term.id, field });
+    }
+  }
+  return dropped;
+}
+function requireShape(format, target, shape) {
+  if (target.shape === shape) return;
+  throw new TermError(
+    shape === "file" ? `-f ${format} writes one file, not a directory. Pass -o <file>.` : `-f ${format} writes a styles directory, not a file. Pass -o <styles directory>.`
+  );
+}
+
+// src/term/core/writers/documents.ts
+var UNSAFE_NAME = /[/\\:*?"<>|]/;
+function pagePaths(terms, target, extension) {
+  const seen = /* @__PURE__ */ new Set();
+  return terms.map((term) => {
+    if (UNSAFE_NAME.test(term.id) || term.id === "." || term.id === "..") {
+      throw new TermError(`the id "${term.id}" cannot name a file. Give the term an id without path characters.`);
+    }
+    if (seen.has(term.id)) {
+      throw new TermError(`two terms have the id "${term.id}", and a directory holds one file per id.`);
+    }
+    seen.add(term.id);
+    return join(target.path, `${term.id}${extension}`);
+  });
+}
+function documentWriter(spec) {
+  const { directory } = spec;
+  return {
+    format: spec.format,
+    shapes: directory === void 0 ? ["file"] : ["file", "directory"],
+    holds: (shape) => shape === "directory" && directory !== void 0 ? directory.holds : spec.file.holds,
+    render(terms, target) {
+      if (target.shape === "directory" && directory !== void 0) {
+        const paths = pagePaths(terms, target, spec.extension);
+        return {
+          files: terms.map((term, i) => ({ path: paths[i] ?? "", content: directory.render(term) })),
+          removals: [],
+          dropped: droppedFields(terms, directory.holds),
+          skipped: []
+        };
+      }
+      requireShape(spec.format, target, "file");
+      const written = spec.file.needsDefinition ? terms.filter((t) => t.record.definition !== void 0) : terms;
+      return {
+        files: [{ path: target.path, content: spec.file.render(written) }],
+        removals: [],
+        dropped: droppedFields(written, spec.file.holds),
+        skipped: terms.filter((t) => !written.includes(t)).map((t) => t.id)
+      };
+    }
+  };
+}
+function entriesBlock(entries, indent = "") {
+  return entries.flatMap((entry, i) => [
+    ...i === 0 ? [] : [""],
+    `${indent}${reindent(entry, indent, "\n")}`
+  ]);
+}
+function markupBlock(entries, indent) {
+  return entries.map((entry) => `${indent}${reindent(entry, indent, "\n")}`);
+}
+function textPage(format) {
+  return (term) => metadataPage(format, term);
+}
+function listFrontmatter(terms, type) {
+  const metadata = {};
+  if (type) metadata["type"] = "term-set";
+  const language = sharedLanguage(terms);
+  if (language !== void 0) metadata["language"] = language;
+  if (Object.keys(metadata).length === 0) return [];
+  return [yamlFrontmatter(metadata).replace(/\n$/, ""), ""];
+}
+function markdownList(terms) {
+  return fileOf([...listFrontmatter(terms, true), ...entriesBlock(terms.map((t) => markdownEntry(t.record)))]);
+}
+var XML_DECLARATION = '<?xml version="1.0" encoding="UTF-8"?>';
+function langAttribute(language) {
+  return language === void 0 ? "" : ` xml:lang="${xmlAttribute(language)}"`;
+}
+var markdownWriter = documentWriter({
+  format: "markdown",
+  extension: ".md",
+  file: { holds: LIST_HOLDS, render: markdownList, needsDefinition: true },
+  directory: { holds: TERM_FIELDS, render: textPage("markdown") }
+});
+var mdxWriter = documentWriter({
+  format: "mdx",
+  extension: ".mdx",
+  file: { holds: LIST_HOLDS, render: markdownList, needsDefinition: true },
+  directory: { holds: TERM_FIELDS, render: textPage("mdx") }
+});
+var asciidocWriter = documentWriter({
+  format: "asciidoc",
+  extension: ".adoc",
+  file: {
+    holds: LIST_HOLDS,
+    needsDefinition: true,
+    render: (terms) => fileOf([...listFrontmatter(terms, false), "[glossary]", ...entriesBlock(terms.map((t) => asciidocEntry(t.record)))])
+  },
+  directory: { holds: TERM_FIELDS, render: textPage("asciidoc") }
+});
+var rstWriter = documentWriter({
+  format: "rst",
+  extension: ".rst",
+  file: {
+    holds: LIST_HOLDS,
+    needsDefinition: true,
+    render: (terms) => fileOf([
+      ...listFrontmatter(terms, false),
+      ".. glossary::",
+      "",
+      ...entriesBlock(
+        terms.map((t) => rstEntry(t.record)),
+        "   "
+      )
+    ])
+  },
+  directory: { holds: TERM_FIELDS, render: textPage("rst") }
+});
+var htmlWriter = documentWriter({
+  format: "html",
+  extension: ".html",
+  file: {
+    holds: LIST_HOLDS,
+    needsDefinition: true,
+    render: (terms) => {
+      const language = sharedLanguage(terms);
+      return fileOf([
+        "<!DOCTYPE html>",
+        "<html>",
+        "  <head>",
+        "    <title>Glossary</title>",
+        '    <meta name="type" content="term-set">',
+        ...language === void 0 ? [] : [`    <meta name="language" content="${xmlAttribute(language)}">`],
+        "  </head>",
+        "  <body>",
+        "    <dl>",
+        ...markupBlock(terms.map(htmlDlEntry), "      "),
+        "    </dl>",
+        "  </body>",
+        "</html>"
+      ]);
+    }
+  },
+  directory: { holds: TERM_FIELDS, render: htmlPage }
+});
+var ditaWriter = documentWriter({
+  format: "dita",
+  extension: ".dita",
+  file: {
+    holds: DITA_HOLDS,
+    needsDefinition: false,
+    render: (terms) => fileOf([
+      XML_DECLARATION,
+      '<!DOCTYPE glossgroup PUBLIC "-//OASIS//DTD DITA 2.0 Glossary Group//EN" "glossgroup.dtd">',
+      `<glossgroup id="glossary"${langAttribute(sharedLanguage(terms))}>`,
+      "  <title>Glossary</title>",
+      ...markupBlock(terms.map((t) => ditaEntry(t)), "  "),
+      "</glossgroup>"
+    ])
+  },
+  directory: {
+    holds: DITA_HOLDS,
+    render: (term) => fileOf([
+      XML_DECLARATION,
+      '<!DOCTYPE glossentry PUBLIC "-//OASIS//DTD DITA 2.0 Glossary Entry//EN" "glossentry.dtd">',
+      ditaEntry(term, term.language)
+    ])
+  }
+});
+var docbookWriter = documentWriter({
+  format: "docbook",
+  extension: ".xml",
+  file: {
+    holds: DOCBOOK_HOLDS,
+    needsDefinition: false,
+    render: (terms) => fileOf([
+      XML_DECLARATION,
+      `<glossary xmlns="http://docbook.org/ns/docbook" version="5.0"${langAttribute(sharedLanguage(terms))}>`,
+      "  <title>Glossary</title>",
+      ...markupBlock(terms.map(docbookEntry), "  "),
+      "</glossary>"
+    ])
+  }
+});
+var DOCUMENT_WRITERS = [
+  markdownWriter,
+  mdxWriter,
+  asciidocWriter,
+  rstWriter,
+  htmlWriter,
+  ditaWriter,
+  docbookWriter
+];
+
+// src/term/core/writers/csv.ts
+var LANGUAGE_COLUMNS = [
+  ["label", "Term"],
+  ["definition", "Definition"],
+  ["abstract", "Abstract"],
+  ["alt-labels", "Alt labels"],
+  ["hidden-labels", "Hidden labels"],
+  ["scope-note", "Scope note"]
+];
+var NEUTRAL_COLUMNS = [
+  ["broader", "Broader"],
+  ["narrower", "Narrower"],
+  ["related-terms", "Related terms"],
+  ["see", "See"]
+];
+var LIST_SEPARATOR = " | ";
+function cell(value) {
+  return /[",\r\n]/.test(value) ? `"${value.replaceAll('"', '""')}"` : value;
+}
+function fieldText(term, field) {
+  const value = term.record[field];
+  if (value === void 0) return "";
+  return typeof value === "string" ? value : value.join(LIST_SEPARATOR);
+}
+var csvWriter = {
+  format: "csv",
+  shapes: ["file"],
+  holds: (_shape) => TERM_FIELDS,
+  render(terms, target) {
+    requireShape("csv", target, "file");
+    const languages = [];
+    for (const term of terms) {
+      const language = term.language ?? DEFAULT_LANGUAGE;
+      if (!languages.includes(language)) languages.push(language);
+    }
+    const header = [
+      "ID",
+      ...languages.flatMap((language) => LANGUAGE_COLUMNS.map(([, name]) => `${name} [${language}]`)),
+      ...NEUTRAL_COLUMNS.map(([, name]) => name)
+    ];
+    const rows = terms.map((term) => {
+      const own = term.language ?? DEFAULT_LANGUAGE;
+      return [
+        term.id,
+        ...languages.flatMap(
+          (language) => LANGUAGE_COLUMNS.map(([field]) => language === own ? fieldText(term, field) : "")
+        ),
+        ...NEUTRAL_COLUMNS.map(([field]) => fieldText(term, field))
+      ];
+    });
+    const content = [header, ...rows].map((row) => `${row.map(cell).join(",")}
+`).join("");
+    return {
+      files: [{ path: target.path, content }],
+      removals: [],
+      dropped: droppedFields(terms, TERM_FIELDS),
+      skipped: []
+    };
+  }
+};
+
+// src/term/core/writers/json.ts
+var jsonWriter = {
+  format: "json",
+  shapes: ["file"],
+  holds: (_shape) => TERM_FIELDS,
+  render(terms, target) {
+    requireShape("json", target, "file");
+    const entries = terms.map((term) => {
+      const entry = { id: term.id };
+      if (term.language !== void 0) entry["language"] = term.language;
+      for (const field of TERM_FIELDS) {
+        const value = term.record[field];
+        if (value !== void 0) entry[field] = value;
+      }
+      return entry;
+    });
+    const content = `${JSON.stringify({ terms: entries }, null, 2)}
+`;
+    return {
+      files: [{ path: target.path, content }],
+      removals: [],
+      dropped: droppedFields(terms, TERM_FIELDS),
+      skipped: []
+    };
+  }
+};
+
+// src/term/core/writers/skos.ts
+var HOLDS = [
+  "label",
+  "definition",
+  "alt-labels",
+  "hidden-labels",
+  "broader",
+  "narrower",
+  "related-terms",
+  "scope-note"
+];
+var CONTEXT = {
+  skos: "http://www.w3.org/2004/02/skos/core#",
+  dcterms: "http://purl.org/dc/terms/"
+};
+var SCHEME_ID = "";
+function literal(term, value) {
+  return term.language === void 0 ? value : { "@value": value, "@language": term.language };
+}
+function resolve4(terms, self, value) {
+  const wanted = value.toLowerCase();
+  const others = terms.filter((t) => t !== self);
+  return others.find((t) => t.record.label.toLowerCase() === wanted) ?? others.find((t) => t.id.toLowerCase() === wanted);
+}
+function references(terms, self, values) {
+  const ids = [];
+  for (const value of values ?? []) {
+    const target = resolve4(terms, self, value);
+    if (target !== void 0 && !ids.includes(target.id)) ids.push(target.id);
+  }
+  return ids.map((id) => ({ "@id": `#${id}` }));
+}
+function concept(terms, term) {
+  const { record } = term;
+  const node = {
+    "@id": `#${term.id}`,
+    "@type": "skos:Concept",
+    "skos:inScheme": { "@id": SCHEME_ID },
+    "skos:prefLabel": literal(term, record.label)
+  };
+  if (record["alt-labels"] !== void 0) node["skos:altLabel"] = record["alt-labels"].map((v) => literal(term, v));
+  if (record["hidden-labels"] !== void 0) {
+    node["skos:hiddenLabel"] = record["hidden-labels"].map((v) => literal(term, v));
+  }
+  if (record.definition !== void 0) node["skos:definition"] = literal(term, record.definition);
+  if (record["scope-note"] !== void 0) node["skos:scopeNote"] = literal(term, record["scope-note"]);
+  const relations = [
+    ["skos:broader", record.broader],
+    ["skos:narrower", record.narrower],
+    ["skos:related", record["related-terms"]]
+  ];
+  for (const [key, values] of relations) {
+    const refs = references(terms, term, values);
+    if (refs.length > 0) node[key] = refs;
+  }
+  return node;
+}
+var skosWriter = {
+  format: "skos",
+  shapes: ["file"],
+  holds: (_shape) => HOLDS,
+  render(terms, target) {
+    requireShape("skos", target, "file");
+    const document = {
+      "@context": CONTEXT,
+      "@graph": [
+        {
+          "@id": SCHEME_ID,
+          "@type": "skos:ConceptScheme",
+          "dcterms:description": "Generated by manni term write."
+        },
+        ...terms.map((term) => concept(terms, term))
+      ]
+    };
+    const content = `${JSON.stringify(document, null, 2)}
+`;
+    return {
+      files: [{ path: target.path, content }],
+      removals: [],
+      dropped: droppedFields(terms, HOLDS),
+      skipped: []
+    };
+  }
+};
+
+// src/term/core/writers/tbx.ts
+var HOLDS2 = ["label", "definition", "alt-labels", "hidden-labels"];
+function text(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+function attribute(value) {
+  return text(value).replaceAll('"', "&quot;");
+}
+function tig(designation, status) {
+  return [
+    "          <tig>",
+    `            <term>${text(designation)}</term>`,
+    `            <termNote type="administrativeStatus">${status}</termNote>`,
+    "          </tig>"
+  ];
+}
+function termEntry(term) {
+  const { record } = term;
+  return [
+    `      <termEntry id="${attribute(term.id)}">`,
+    ...record.definition === void 0 ? [] : [`        <descrip type="definition">${text(record.definition)}</descrip>`],
+    `        <langSet xml:lang="${attribute(term.language ?? DEFAULT_LANGUAGE)}">`,
+    ...tig(record.label, "preferredTerm-admn-sts"),
+    ...(record["alt-labels"] ?? []).flatMap((label) => tig(label, "admittedTerm-admn-sts")),
+    ...(record["hidden-labels"] ?? []).flatMap((label) => tig(label, "deprecatedTerm-admn-sts")),
+    "        </langSet>",
+    "      </termEntry>"
+  ];
+}
+var tbxWriter = {
+  format: "tbx",
+  shapes: ["file"],
+  holds: (_shape) => HOLDS2,
+  render(terms, target) {
+    requireShape("tbx", target, "file");
+    const language = terms[0]?.language ?? DEFAULT_LANGUAGE;
+    const lines = [
+      '<?xml version="1.0" encoding="UTF-8"?>',
+      `<martif type="TBX" xml:lang="${attribute(language)}">`,
+      "  <martifHeader>",
+      "    <fileDesc>",
+      "      <sourceDesc>",
+      "        <p>manni term write</p>",
+      "      </sourceDesc>",
+      "    </fileDesc>",
+      "  </martifHeader>",
+      "  <text>",
+      "    <body>",
+      ...terms.flatMap(termEntry),
+      "    </body>",
+      "  </text>",
+      "</martif>"
+    ];
+    const content = lines.map((line) => `${line}
+`).join("");
+    return {
+      files: [{ path: target.path, content }],
+      removals: [],
+      dropped: droppedFields(terms, HOLDS2),
+      skipped: []
+    };
+  }
+};
+
+// src/term/core/writers/vale.ts
+import { isAbsolute as isAbsolute2, join as join2, relative as relative2, sep } from "node:path";
+import { stringify } from "yaml";
+var VALE_MARKER = "# Generated by manni term write. Edit the terms, not this file.";
+var STYLE = "Terms";
+var HOLDS3 = ["label", "alt-labels", "hidden-labels"];
+var OWN_FILES = ["Casing", "Lowercase", "SentenceStart", "Deprecated"];
+var REGEX_METACHARACTERS = /[\\^$.|?*+()[\]{}]/g;
+function escapeRegex(value) {
+  return value.replace(REGEX_METACHARACTERS, "\\$&");
+}
+function swapValue(value) {
+  return value.search(REGEX_METACHARACTERS) === -1 ? value : escapeRegex(value);
+}
+function scalar(value) {
+  if (/[\r\n]/.test(value)) return JSON.stringify(value);
+  const out = stringify(value, { version: "1.1", lineWidth: 0 });
+  return out.endsWith("\n") ? out.slice(0, -1) : out;
+}
+function doubleQuoted(value) {
+  const escaped = value.replaceAll("\\", "\\\\").replaceAll('"', '\\"').replaceAll("\n", "\\n").replaceAll("\r", "\\r");
+  return `"${escaped}"`;
+}
+function singleQuoted(value) {
+  return `'${value.replaceAll("'", "''").replaceAll(/[\r\n]+/g, " ")}'`;
+}
+function messageText(value) {
+  return value.replaceAll("%", "%%");
+}
+function casingOf(value) {
+  if (!/[\p{Lu}\p{Ll}\p{Lt}]/u.test(value)) return "none";
+  const letters = value.match(new RegExp("\\p{L}", "gu"))?.length ?? 0;
+  if (letters >= 2 && !/[\p{Ll}\p{Lt}]/u.test(value)) return "all-caps";
+  if (!/[\p{Lu}\p{Lt}]/u.test(value)) return "lowercase";
+  if (new RegExp("^\\p{Ll}", "u").test(value)) return "lowercase-initial";
+  return "mixed";
+}
+function sentenceStartPattern(value) {
+  const [first = "", ...rest] = Array.from(value);
+  const upper = first.toUpperCase();
+  const head = upper !== first && Array.from(upper).length === 1 ? `[${upper}${first}]` : escapeRegex(first);
+  return `${head}${escapeRegex(rest.join(""))}`;
+}
+var Swaps = class {
+  entries = /* @__PURE__ */ new Map();
+  add(key, value) {
+    if (!this.entries.has(key)) this.entries.set(key, value);
+  }
+  get size() {
+    return this.entries.size;
+  }
+  lines() {
+    return [...this.entries].map(([key, value]) => `  ${scalar(key)}: ${scalar(value)}`);
+  }
+};
+var ASCII_WORD = /^[A-Za-z0-9_]$/;
+function bounded(pattern, text2) {
+  const chars = Array.from(text2);
+  const edge = (char) => char !== void 0 && ASCII_WORD.test(char) ? "\\b" : "\\B";
+  return `${edge(chars[0])}${pattern}${edge(chars.at(-1))}`;
+}
+function substitution(message, level, options, swaps) {
+  return [
+    VALE_MARKER,
+    "extends: substitution",
+    `message: ${doubleQuoted(message)}`,
+    `level: ${level}`,
+    "ignorecase: true",
+    "nonword: true",
+    ...options,
+    "swap:",
+    ...swaps.lines()
+  ].map((line) => `${line}
+`).join("");
+}
+function acronymRule(acronym, label) {
+  const expansion = escapeRegex(label).replaceAll(/[\r\n]+/g, " ");
+  return [
+    VALE_MARKER,
+    "extends: conditional",
+    `message: ${doubleQuoted(messageText(`Spell out '${acronym}' on first use, as '${label} (${acronym})'.`))}`,
+    "level: warning",
+    "ignorecase: false",
+    `first: ${singleQuoted(`\\b(${escapeRegex(acronym)})\\b`)}`,
+    `second: ${singleQuoted(`(?i)${expansion} \\((${escapeRegex(acronym)})\\)`)}`
+  ].map((line) => `${line}
+`).join("");
+}
+function acronymFileName(acronym) {
+  return acronym.replaceAll(/[^\p{L}\p{N}_-]/gu, "-");
+}
+function firstLine(content) {
+  const end = content.search(/\r?\n/);
+  return end === -1 ? content : content.slice(0, end);
+}
+var valeWriter = {
+  format: "vale",
+  shapes: ["directory"],
+  holds: (_shape) => HOLDS3,
+  render(terms, target, context) {
+    requireShape("vale", target, "directory");
+    const termsDir = join2(target.path, STYLE);
+    const marked = [];
+    for (const [path, content] of context.existing) {
+      const rel = relative2(termsDir, path);
+      if (rel === "" || rel === ".." || rel.startsWith(`..${sep}`) || isAbsolute2(rel)) continue;
+      if (firstLine(content) !== VALE_MARKER) {
+        throw new TermError(`${path} was not written by manni. Move it, or pass -o <styles directory>.`);
+      }
+      if (!rel.includes(sep) && !rel.includes("/")) marked.push(path);
+    }
+    const casing = new Swaps();
+    const lowercase = new Swaps();
+    const sentenceStart = new Swaps();
+    const deprecated = new Swaps();
+    const acronyms = [];
+    const labels = new Set(terms.map((t) => t.record.label));
+    for (const term of terms) {
+      const { label } = term.record;
+      const labelIsAllCaps = casingOf(label) === "all-caps";
+      for (const designation of [label, ...term.record["alt-labels"] ?? []]) {
+        const kind = casingOf(designation);
+        if (kind === "lowercase") lowercase.add(bounded(escapeRegex(designation), designation), sentenceStartPattern(designation));
+        if (kind === "lowercase-initial") {
+          sentenceStart.add(bounded(escapeRegex(designation.toLowerCase()), designation), sentenceStartPattern(designation));
+        }
+        if (kind === "mixed") casing.add(bounded(escapeRegex(designation.toLowerCase()), designation), swapValue(designation));
+        if (kind !== "all-caps" || designation === label || labelIsAllCaps || labels.has(designation)) continue;
+        const name = acronymFileName(designation);
+        const own = OWN_FILES.find((file) => file.toLowerCase() === name.toLowerCase());
+        if (own !== void 0) {
+          throw new TermError(`the acronym "${designation}" would replace Terms/${own}.yml. Rename the alt-label.`);
+        }
+        const taken = acronyms.find((a) => a.name.toLowerCase() === name.toLowerCase());
+        if (taken?.acronym === designation) continue;
+        if (taken !== void 0) {
+          throw new TermError(
+            `the acronyms "${taken.acronym}" and "${designation}" would both write Terms/${taken.name}.yml. Rename one.`
+          );
+        }
+        acronyms.push({ acronym: designation, name, content: acronymRule(designation, label) });
+      }
+      for (const hidden of term.record["hidden-labels"] ?? []) {
+        deprecated.add(bounded(escapeRegex(hidden), hidden), swapValue(label));
+      }
+    }
+    const files = [];
+    const add = (name, content) => {
+      files.push({ path: join2(termsDir, `${name}.yml`), content });
+    };
+    if (casing.size > 0) {
+      add("Casing", substitution("Use '%s' instead of '%s'.", "error", ["vocab: false"], casing));
+    }
+    if (lowercase.size > 0) {
+      add(
+        "Lowercase",
+        substitution("Write '%[2]s' in lowercase, except to start a sentence.", "error", ["vocab: false"], lowercase)
+      );
+    }
+    if (sentenceStart.size > 0) {
+      add(
+        "SentenceStart",
+        substitution(
+          "Write '%[2]s' as the term list spells it, with a capital only to start a sentence.",
+          "error",
+          ["vocab: false"],
+          sentenceStart
+        )
+      );
+    }
+    if (deprecated.size > 0) {
+      add("Deprecated", substitution("Use '%s' instead of '%s'.", "warning", ["matchcase: true"], deprecated));
+    }
+    for (const acronym of acronyms) add(acronym.name, acronym.content);
+    const produced = new Set(files.map((f) => relative2(termsDir, f.path).toLowerCase()));
+    const removals = marked.filter((path) => !produced.has(relative2(termsDir, path).toLowerCase())).sort();
+    return { files, removals, dropped: droppedFields(terms, HOLDS3), skipped: [] };
+  }
+};
+
+// src/term/core/writers/interchange.ts
+var INTERCHANGE_WRITERS = [tbxWriter, skosWriter, csvWriter, jsonWriter, valeWriter];
+
+// src/term/core/writers/index.ts
+var TERM_WRITERS = [...DOCUMENT_WRITERS, ...INTERCHANGE_WRITERS];
+
+// src/term/commands/formats.ts
+var FORMATS_FORMATS = ["pretty", "json"];
+var DOCUMENT_RENDERS = {
+  markdown: { input: "markdown", shapes: { directory: "page", file: "markdown-deflist" } },
+  mdx: { input: "mdx", shapes: { directory: "page", file: "markdown-deflist" } },
+  asciidoc: { input: "asciidoc", shapes: { directory: "page", file: "asciidoc-glossary" } },
+  rst: { input: "rst", shapes: { directory: "page", file: "rst-glossary" } },
+  html: { input: "html", shapes: { directory: "page", file: "html-dl" } },
+  dita: { input: "xml", shapes: { directory: "dita-glossentry", file: "dita-glossgroup" } },
+  docbook: { input: "xml", shapes: { file: "docbook-glossary" } }
+};
+var INTERCHANGE_LABELS = {
+  tbx: "TBX v2 Core",
+  skos: "JSON-LD",
+  vale: "style"
+};
+function rendered(writers, format, construct) {
+  return writers.some((writer) => {
+    const render3 = DOCUMENT_RENDERS[writer.format];
+    if (render3?.input !== format) return false;
+    return writer.shapes.some((shape) => render3.shapes[shape] === construct);
+  });
+}
+function listFormats(opts = {}) {
+  const readers = opts.readers ?? TERM_READERS;
+  const writers = opts.writers ?? TERM_WRITERS;
+  const formats = [];
+  for (const reader of readers) {
+    for (const format of reader.formats) if (!formats.includes(format)) formats.push(format);
+  }
+  const rows = [];
+  for (const format of formats) {
+    for (const reader of readers.filter((r) => r.formats.includes(format))) {
+      rows.push({
+        format,
+        construct: reader.construct,
+        label: reader.label,
+        read: true,
+        write: reader.apply !== void 0 || rendered(writers, format, reader.construct)
+      });
+    }
+  }
+  for (const writer of writers) {
+    if (DOCUMENT_RENDERS[writer.format] !== void 0) continue;
+    rows.push({ format: writer.format, label: INTERCHANGE_LABELS[writer.format] ?? "", read: false, write: true });
+  }
+  return rows;
+}
+
+// src/term/commands/get.ts
+var GET_FORMATS = ["pretty", "json"];
+function findTerm(terms, query) {
+  const folded = query.toLowerCase();
+  return terms.find((t) => t.id === query) ?? terms.find((t) => t.record.label.toLowerCase() === folded) ?? terms.find((t) => (t.record["alt-labels"] ?? []).some((alt) => alt.toLowerCase() === folded));
+}
+function editDistance(a, b) {
+  let prev = Array.from({ length: b.length + 1 }, (_, i) => i);
+  for (let i = 1; i <= a.length; i++) {
+    const row = [i];
+    for (let j = 1; j <= b.length; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      row.push(Math.min((row[j - 1] ?? 0) + 1, (prev[j] ?? 0) + 1, (prev[j - 1] ?? 0) + cost));
+    }
+    prev = row;
+  }
+  return prev[b.length] ?? 0;
+}
+function closestName(query, names) {
+  const limit = Math.max(2, Math.floor(query.length / 3));
+  let best;
+  let bestDistance = Number.POSITIVE_INFINITY;
+  for (const name of names) {
+    const distance = editDistance(query, name);
+    if (distance < bestDistance) {
+      best = name;
+      bestDistance = distance;
+    }
+  }
+  return bestDistance <= limit ? best : void 0;
+}
+async function runGet(opts) {
+  const { set } = await loadTerms(opts);
+  const found = findTerm(set.terms, opts.term);
+  if (found !== void 0) return found;
+  const nearest = closestName(
+    opts.term,
+    set.terms.flatMap((t) => [t.id, t.record.label])
+  );
+  const hint = nearest === void 0 ? "." : `; did you mean "${nearest}"?`;
+  throw new TermError(`no term "${opts.term}". ${plural3(set.terms.length, "term")}${hint}`);
+}
+
+// src/term/core/lint.ts
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join as join3 } from "node:path";
+
+// src/term/core/vale.ts
+import { execFile } from "node:child_process";
+var MAX_BUFFER = 64 * 1024 * 1024;
+var SEVERITIES2 = ["error", "warning", "suggestion"];
+var spawnVale = (args, opts) => new Promise((settle, reject) => {
+  execFile(
+    "vale",
+    args,
+    { cwd: opts.cwd, windowsHide: true, maxBuffer: MAX_BUFFER, encoding: "utf8" },
+    (error, stdout, stderr) => {
+      if (!error) {
+        settle({ code: 0, stdout, stderr });
+        return;
+      }
+      if (typeof error.code === "number") {
+        settle({ code: error.code, stdout, stderr });
+        return;
+      }
+      if (error.code === void 0 && error.signal) {
+        settle({ code: null, stdout, stderr });
+        return;
+      }
+      const failure = error;
+      reject(failure);
+    }
+  );
+});
+function isEnoent(err) {
+  return typeof err === "object" && err !== null && "code" in err && err.code === "ENOENT";
+}
+async function start(spawn, args, cwd, missing) {
+  try {
+    return await spawn(args, { cwd });
+  } catch (err) {
+    if (isEnoent(err)) throw new TermError(missing);
+    throw err;
+  }
+}
+function isMapping2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function failureText(result) {
+  const stderr = result.stderr.trim();
+  try {
+    const parsed = JSON.parse(stderr);
+    if (isMapping2(parsed) && typeof parsed["Text"] === "string") return parsed["Text"].trim();
+  } catch {
+  }
+  return stderr === "" ? `exit code ${String(result.code)}` : stderr;
+}
+function parseJson(stdout, what) {
+  try {
+    return JSON.parse(stdout);
+  } catch {
+    throw new TermError(`vale printed ${what} that is not JSON: ${stdout.trim().slice(0, 200)}`);
+  }
+}
+function parseAlert(raw, path) {
+  const unreadable = () => new TermError(`vale printed an alert for ${path} that manni cannot read: ${JSON.stringify(raw)}`);
+  if (!isMapping2(raw)) throw unreadable();
+  const { Check, Message, Line, Span, Severity } = raw;
+  if (typeof Check !== "string" || typeof Message !== "string" || typeof Line !== "number") throw unreadable();
+  if (!Array.isArray(Span) || Span.length !== 2) throw unreadable();
+  const span = Span;
+  const [from, to] = span;
+  if (typeof from !== "number" || typeof to !== "number") throw unreadable();
+  const severity = SEVERITIES2.find((s) => s === Severity);
+  if (severity === void 0) throw unreadable();
+  return { Check, Message, Line, Span: [from, to], Severity: severity };
+}
+function parseAlerts(stdout) {
+  const parsed = parseJson(stdout, "alerts");
+  if (!isMapping2(parsed)) throw new TermError("vale printed alerts that are not a JSON object.");
+  const alerts = {};
+  for (const [path, list] of Object.entries(parsed)) {
+    if (!Array.isArray(list)) throw new TermError(`vale printed alerts for ${path} that are not a list.`);
+    alerts[path] = list.map((raw) => parseAlert(raw, path));
+  }
+  return alerts;
+}
+async function runValeJson(files, opts, spawn = spawnVale) {
+  const args = ["--output=JSON", ...opts.config === void 0 ? [] : ["--config", opts.config], ...files];
+  const result = await start(spawn, args, opts.cwd, "vale is not on PATH. Install Vale to lint definitions.");
+  if (result.code !== 0 && result.code !== 1) {
+    throw new TermError(`vale could not lint definitions: ${failureText(result)}`);
+  }
+  return parseAlerts(result.stdout);
+}
+var NO_CONFIG = /no config file found|\.vale\.ini not found/i;
+function stringList(value) {
+  if (!Array.isArray(value)) return void 0;
+  const list = [];
+  for (const item2 of value) {
+    if (typeof item2 !== "string") return void 0;
+    list.push(item2);
+  }
+  return list;
+}
+async function valeLsConfig(opts, spawn = spawnVale) {
+  const args = [...opts.config === void 0 ? [] : ["--config", opts.config], "ls-config"];
+  const result = await start(
+    spawn,
+    args,
+    opts.cwd,
+    "vale is not on PATH. Install Vale, or pass -o <styles directory>."
+  );
+  if (result.code !== 0) {
+    const text2 = failureText(result);
+    if (NO_CONFIG.test(text2)) return null;
+    throw new TermError(`vale could not resolve its configuration: ${text2}`);
+  }
+  const parsed = parseJson(result.stdout, "a configuration");
+  if (!isMapping2(parsed)) throw new TermError("vale printed a configuration that is not a JSON object.");
+  const paths = stringList(parsed["Paths"]);
+  const stylesPath = paths?.[paths.length - 1];
+  if (stylesPath === void 0 || stylesPath === "") {
+    throw new TermError(
+      "vale's configuration names no styles directory. Set StylesPath in it, or pass -o <styles directory>."
+    );
+  }
+  const root = parsed["RootINI"];
+  const configFiles = stringList(parsed["ConfigFiles"]);
+  const rootIni = typeof root === "string" && root !== "" ? root : configFiles?.[configFiles.length - 1] ?? opts.config ?? "";
+  const baseStyles = {};
+  const sections = parsed["SBaseStyles"];
+  if (sections !== null && sections !== void 0) {
+    if (!isMapping2(sections)) throw new TermError("vale printed SBaseStyles that is not a JSON object.");
+    for (const [glob, styles] of Object.entries(sections)) {
+      const list = stringList(styles);
+      if (list === void 0) throw new TermError(`vale printed styles for ${glob} that are not a list of names.`);
+      baseStyles[glob] = list;
+    }
+  }
+  return { stylesPath, rootIni, baseStyles };
+}
+
+// src/term/core/lint.ts
+var PROSE_FIELDS = ["definition", "abstract", "scope-note"];
+function fileStem(id) {
+  const safe = id.replace(/[^A-Za-z0-9._-]/g, "_");
+  return safe === "" ? "_" : safe;
+}
+function baseName(path) {
+  const parts = path.split(/[\\/]/);
+  return parts[parts.length - 1] ?? path;
+}
+function sourceLine(written, proseLine) {
+  const { term, field, value } = written;
+  const fieldLine = term.location.fieldLines[field] ?? term.location.line;
+  if (!value.includes("\n")) return fieldLine;
+  const { construct } = term.location;
+  return construct === "page" || construct === "manifest" ? fieldLine + proseLine : fieldLine + proseLine - 1;
+}
+function compareFindings3(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;
+  if (a.message !== b.message) return a.message < b.message ? -1 : 1;
+  return 0;
+}
+async function lintTermSet(set, opts = {}) {
+  const byName = /* @__PURE__ */ new Map();
+  const files = [];
+  const stemCount = /* @__PURE__ */ new Map();
+  for (const term of set.terms) {
+    const fields = PROSE_FIELDS.filter((field) => term.record[field] !== void 0);
+    if (fields.length === 0) continue;
+    const stem = fileStem(term.id);
+    const seen = (stemCount.get(stem.toLowerCase()) ?? 0) + 1;
+    stemCount.set(stem.toLowerCase(), seen);
+    const prefix = seen === 1 ? stem : `${stem}.${String(seen)}`;
+    for (const field of fields) {
+      const value = term.record[field];
+      if (value === void 0) continue;
+      const name = `${prefix}.${field}.md`;
+      byName.set(name.toLowerCase(), { term, field, value });
+      files.push({ name, content: `${value}
+` });
+    }
+  }
+  if (files.length === 0) return [];
+  const runVale = opts.runVale ?? runValeJson;
+  const dir = await mkdtemp(join3(tmpdir(), "manni-term-lint-"));
+  try {
+    for (const file of files) await writeFile(join3(dir, file.name), file.content, "utf8");
+    const alerts = await runVale([dir], { config: opts.valeConfig, cwd: opts.cwd });
+    const findings = [];
+    for (const [path, list] of Object.entries(alerts)) {
+      const written = byName.get(baseName(path).toLowerCase());
+      if (written === void 0) continue;
+      for (const alert of list) {
+        findings.push({
+          ruleId: proseRuleId(alert.Check),
+          severity: foldValeSeverity(alert.Severity),
+          message: alert.Message,
+          file: written.term.location.file,
+          line: sourceLine(written, alert.Line),
+          id: written.term.id,
+          tool: "vale",
+          check: alert.Check,
+          toolSeverity: alert.Severity,
+          field: written.field
+        });
+      }
+    }
+    return findings.sort(compareFindings3);
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+}
+
+// src/term/commands/lint.ts
+async function runLint(opts) {
+  const { cwd, run, set } = await loadTerms(opts);
+  const valeConfig = valeConfigFor(run);
+  const findings = await lintTermSet(set, {
+    cwd,
+    ...valeConfig === void 0 ? {} : { valeConfig },
+    ...opts.runVale === void 0 ? {} : { runVale: opts.runVale }
+  });
+  const { results, origin } = toResults(set, findings);
+  return {
+    findings: reportedFindings(results, origin),
+    results,
+    summary: summarize2(results),
+    frame: { cwd, base: run.configDir ?? cwd, runBase: run.base },
+    terms: set.terms.length,
+    references: set.references.length,
+    found: findings.length,
+    cwd
+  };
+}
+
+// src/term/commands/list.ts
+var LIST_FORMATS = ["pretty", "json", "csv"];
+async function runList(opts) {
+  const { set } = await loadTerms(opts);
+  return { terms: set.terms, set };
+}
+
+// src/term/commands/write.ts
+import { existsSync as existsSync3, statSync } from "node:fs";
+import { lstat, mkdir, readdir, readFile as readFile2, rm as rm2, writeFile as writeFile2 } from "node:fs/promises";
+import { dirname, extname as extname2, join as join4, resolve as resolve5 } from "node:path";
+var SUGGESTED_SECTION = "*.md";
+var STYLE2 = "Terms";
+function writeFormats(writers = TERM_WRITERS) {
+  return TERM_WRITE_FORMATS.filter((format) => writers.some((writer) => writer.format === format));
+}
+function isDirectory(path) {
+  try {
+    return statSync(path).isDirectory();
+  } catch {
+    return false;
+  }
+}
+var MAX_EXISTING_FILE_BYTES = 1024 * 1024;
+async function filesUnder(dir, into) {
+  let entries;
+  try {
+    entries = await readdir(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const path = join4(dir, entry.name);
+    if (entry.isDirectory()) await filesUnder(path, into);
+    else if (entry.isFile()) {
+      const { size } = await lstat(path);
+      into.set(path, size > MAX_EXISTING_FILE_BYTES ? "" : await readFile2(path, "utf8"));
+    }
+  }
+}
+async function existingFor(target) {
+  const existing = /* @__PURE__ */ new Map();
+  if (target.shape === "directory") {
+    await filesUnder(target.path, existing);
+  } else if (existsSync3(target.path) && !isDirectory(target.path)) {
+    existing.set(target.path, await readFile2(target.path, "utf8"));
+  }
+  return existing;
+}
+function relativized(error, paths, cwd) {
+  let message = error.message;
+  for (const path of [...paths].sort((a, b) => b.length - a.length)) {
+    if (message.includes(path)) message = message.replaceAll(path, displayPath(path, cwd));
+  }
+  return message === error.message ? error : new TermError(message);
+}
+function droppedFrom(format, shape, readers) {
+  const construct = DOCUMENT_RENDERS[format]?.shapes[shape];
+  const reader = construct === void 0 ? void 0 : readerForConstruct(construct, readers);
+  return reader === void 0 ? format : `a ${reader.label}`;
+}
+async function applyChanges(files, removals, existing, cwd, write) {
+  const changes = [];
+  for (const file of files) {
+    const before = existing.get(file.path) ?? (existsSync3(file.path) ? await readFile2(file.path, "utf8") : void 0);
+    if (before === file.content) continue;
+    changes.push({ path: displayPath(file.path, cwd), action: before === void 0 ? "create" : "change" });
+    if (write) {
+      await mkdir(dirname(file.path), { recursive: true });
+      await writeFile2(file.path, file.content, "utf8");
+    }
+  }
+  for (const path of removals) {
+    if (!existsSync3(path)) continue;
+    changes.push({ path: displayPath(path, cwd), action: "remove" });
+    if (write) await rm2(path, { force: true });
+  }
+  return changes;
+}
+async function runWrite(opts) {
+  const cwd = resolve5(opts.cwd ?? process.cwd());
+  const writers = opts.writers ?? TERM_WRITERS;
+  const readers = opts.readers ?? TERM_READERS;
+  const check = opts.check === true;
+  const dryRun = opts.dryRun === true;
+  if (check && dryRun) throw new TermError("--check and --dry-run cannot be combined.");
+  if (opts.format === void 0) {
+    if (opts.out !== void 0) throw new TermError("-o needs -f <format>.");
+    return writeInPlace({ ...opts, cwd, readers }, check, dryRun);
+  }
+  const format = formatChoice(opts.format, writeFormats(writers));
+  const writer = writers.find((w) => w.format === format);
+  if (writer === void 0) throw new TermError(`unknown format "${format}".`);
+  if (opts.out === void 0 && format !== "vale") {
+    throw new TermError(`-f ${format} needs -o <path>.`);
+  }
+  const { run, set } = await loadTerms({ ...opts, cwd, readers });
+  let targetPath;
+  let wiring;
+  if (opts.out === void 0) {
+    const lsConfig = opts.lsConfig ?? ((o) => valeLsConfig(o));
+    const config = valeConfigFor(run);
+    const resolved = await lsConfig({ cwd, ...config === void 0 ? {} : { config } });
+    if (resolved === null) {
+      throw new TermError(
+        "Vale found no config file. Set tools.vale.config in manni.config.yaml, or pass -o <styles directory>."
+      );
+    }
+    targetPath = resolve5(cwd, resolved.stylesPath);
+    if (!Object.values(resolved.baseStyles).some((styles) => styles.includes(STYLE2))) {
+      const first = Object.entries(resolved.baseStyles)[0];
+      const [section, styles] = first ?? [SUGGESTED_SECTION, []];
+      wiring = {
+        rootIni: displayPath(resolve5(cwd, resolved.rootIni), cwd),
+        section,
+        styles: [...styles, STYLE2],
+        addSection: first === void 0
+      };
+    }
+  } else {
+    targetPath = resolve5(cwd, opts.out);
+  }
+  const shape = format === "vale" || /[\\/]$/.test(opts.out ?? "") || isDirectory(targetPath) ? "directory" : "file";
+  const target = { path: targetPath, shape };
+  const existing = await existingFor(target);
+  let render3;
+  try {
+    render3 = writer.render(set.terms, target, { existing });
+  } catch (error) {
+    if (error instanceof TermError) throw relativized(error, [...existing.keys(), targetPath], cwd);
+    throw error;
+  }
+  const changes = await applyChanges(render3.files, render3.removals, existing, cwd, !check && !dryRun);
+  const shown = format === "vale" ? displayPath(join4(targetPath, STYLE2), cwd) : opts.out ?? displayPath(targetPath, cwd);
+  return {
+    mode: "render",
+    format,
+    shape,
+    target: shown,
+    terms: set.terms.length,
+    changes,
+    files: render3.files.map((file) => ({ path: displayPath(file.path, cwd), content: file.content })),
+    // A Vale style holds designations only, by design; its dropped definitions are not news.
+    dropped: format === "vale" ? [] : render3.dropped,
+    droppedFrom: droppedFrom(format, shape, readers),
+    skipped: render3.skipped,
+    check,
+    dryRun,
+    ...wiring === void 0 ? {} : { wiring }
+  };
+}
+function inputFor(content, path, construct, file) {
+  if (construct === "manifest") {
+    return { content, file, path, format: MANIFEST_FORMAT, metadata: {}, lineFor: () => void 0 };
+  }
+  const extractor = extractorForExtension(extname2(path));
+  if (extractor === void 0) throw new TermError(`${file}: no reader for its extension.`);
+  return extractInput(content, file, path, extractor.name);
+}
+function carryRecords(current, edited) {
+  const count = (terms, id) => terms.filter((t) => t.id === id).length;
+  return current.map((entry, index) => {
+    const unique2 = count(current, entry.id) === 1 && count(edited, entry.id) === 1;
+    const match = unique2 ? edited.find((t) => t.id === entry.id) : edited[index];
+    return match?.id === entry.id ? { ...entry, record: match.record } : entry;
+  });
+}
+function applyInPlace(original, path, file, constructs, readers) {
+  let content = original;
+  let first = true;
+  for (const [construct, terms] of constructs) {
+    const reader = readerForConstruct(construct, readers);
+    if (reader?.apply === void 0) continue;
+    const input = inputFor(content, path, construct, file);
+    content = reader.apply(input, first ? terms : carryRecords(reader.read(input).terms, terms));
+    first = false;
+  }
+  return content;
+}
+async function writeInPlace(opts, check, dryRun) {
+  const { cwd, readers } = opts;
+  const { set } = await loadTerms(opts);
+  const byPath = /* @__PURE__ */ new Map();
+  for (const term of set.terms) {
+    const { path, construct } = term.location;
+    if (path === void 0) {
+      throw new TermError(`${term.location.file} has nowhere to write back to. Pass -f <format> -o <path>.`);
+    }
+    const reader = readerForConstruct(construct, readers);
+    if (reader?.apply === void 0) {
+      const name = reader?.label ?? construct;
+      throw new TermError(
+        `${displayPath(term.location.file, cwd)}: a ${name} cannot be written in place. Pass -f <format> -o <path>.`
+      );
+    }
+    const entry = byPath.get(path) ?? { file: term.location.file, constructs: /* @__PURE__ */ new Map() };
+    entry.constructs.set(construct, [...entry.constructs.get(construct) ?? [], term]);
+    byPath.set(path, entry);
+  }
+  const files = [];
+  const existing = /* @__PURE__ */ new Map();
+  for (const [path, { file, constructs }] of byPath) {
+    let original;
+    try {
+      original = await readFile2(path, "utf8");
+    } catch (error) {
+      throw new TermError(`${file}: could not be read: ${errorMessage(error)}`);
+    }
+    existing.set(path, original);
+    files.push({ path, content: applyInPlace(original, path, file, constructs, readers) });
+  }
+  const changes = await applyChanges(files, [], existing, cwd, !check && !dryRun);
+  return {
+    mode: "in-place",
+    terms: set.terms.length,
+    changes,
+    files: files.map((f) => ({ path: displayPath(f.path, cwd), content: f.content })),
+    dropped: [],
+    skipped: [],
+    check,
+    dryRun
+  };
+}
+
+// src/term/reporters/csv.ts
+var LIST_SEPARATOR2 = "|";
+function cell2(value) {
+  return /[",\r\n]/.test(value) ? `"${value.replaceAll('"', '""')}"` : value;
+}
+function renderListCsv(terms) {
+  const rows = [
+    ["id", "label", "alt-labels", "abstract"],
+    ...terms.map((t) => [
+      t.id,
+      t.record.label,
+      (t.record["alt-labels"] ?? []).join(LIST_SEPARATOR2),
+      t.record.abstract ?? ""
+    ])
+  ];
+  return rows.map((row) => row.map(cell2).join(",")).join("\n");
+}
+
+// src/term/reporters/github.ts
+function renderFindingsGithub(report) {
+  return report.findings.map((finding) => {
+    const params = [`file=${escapeWorkflowCommandProperty(displayPath(finding.file, report.cwd))}`];
+    if (finding.line !== void 0) params.push(`line=${String(finding.line)}`);
+    params.push(`title=${escapeWorkflowCommandProperty(finding.ruleId)}`);
+    return `::${finding.severity} ${params.join(",")}::${escapeWorkflowCommandMessage(finding.message)}`;
+  }).join("\n");
+}
+
+// src/term/reporters/json.ts
+function termEntry2(term) {
+  const entry = { id: term.id };
+  if (term.language !== void 0) entry["language"] = term.language;
+  for (const field of TERM_FIELDS) {
+    const value = term.record[field];
+    if (value !== void 0) entry[field] = value;
+  }
+  return entry;
+}
+function renderListJson(terms) {
+  return JSON.stringify({ terms: terms.map(termEntry2) }, null, 2);
+}
+function renderGetJson(term) {
+  return JSON.stringify(termEntry2(term), null, 2);
+}
+function renderFindingsJson(report) {
+  const count = (severity) => report.findings.filter((f) => f.severity === severity).length;
+  return JSON.stringify(
+    {
+      findings: report.findings.map((finding) => ({ ...finding, file: displayPath(finding.file, report.cwd) })),
+      summary: {
+        terms: report.terms,
+        references: report.references,
+        errors: count("error"),
+        warnings: count("warning"),
+        notices: count("notice"),
+        ...report.baseline === void 0 ? {} : { baseline: report.baseline }
+      }
+    },
+    null,
+    2
+  );
+}
+function renderFormatsJson(rows) {
+  return JSON.stringify({ formats: rows }, null, 2);
+}
+
+// src/term/reporters/sarif.ts
+var INFORMATION_URI = "https://hawkeyexl.github.io/manni/term/";
+var RULES_URI = "https://hawkeyexl.github.io/manni/term/reference/rules/";
+var RULE_DESCRIPTIONS = {
+  "undefined-term": "A page's concepts: names a label no entry claims as its preferred label.",
+  "duplicate-id": "Two entries share an id.",
+  "label-collision": "Two entries claim the same preferred label, ignoring case.",
+  "alt-label-collision": "An entry's alt-label is another entry's preferred label, ignoring case.",
+  "dangling-reference": "A value of broader, narrower, related-terms or see names no entry, by label or by id.",
+  "broader-cycle": "A chain of broader returns to where it started.",
+  "see-not-empty": "An entry with see also carries a definition.",
+  "asymmetric-hierarchy": "A names B as broader, and B omits A from narrower, or the reverse.",
+  "abstract-too-long": "An abstract is longer than term.abstractMaxLength.",
+  "unused-term": "No page's concepts: names the entry's preferred label."
+};
+var PROSE_PREFIX = `${RULE_ID_PREFIX}/prose/`;
+var FIELD_LABEL = new RegExp(`^(?:\\(root\\)|/(?:${TERM_FIELDS.join("|")})) `);
+function describe(rule) {
+  if (rule.id.startsWith(PROSE_PREFIX)) {
+    const check = rule.id.slice(PROSE_PREFIX.length);
+    return { id: rule.id, shortDescription: { text: `Vale's ${check} rule flagged the prose of an entry's field.` } };
+  }
+  const name = rule.id.slice(RULE_ID_PREFIX.length + 1);
+  if (!isTermRule2(name)) return rule;
+  return { id: rule.id, shortDescription: { text: RULE_DESCRIPTIONS[name] }, helpUri: `${RULES_URI}#${name}` };
+}
+function renderFindingsSarif(report, opts = {}) {
+  const log = JSON.parse(
+    renderSarif(report.results, {
+      frame: report.frame,
+      ...opts.onNotice === void 0 ? {} : { onNotice: opts.onNotice }
+    })
+  );
+  for (const run of log.runs) {
+    run.tool.driver.informationUri = INFORMATION_URI;
+    run.tool.driver.rules = run.tool.driver.rules.map(describe);
+    for (const result of run.results) result.message.text = result.message.text.replace(FIELD_LABEL, "");
+  }
+  return JSON.stringify(log, null, 2);
+}
+
+// src/term/reporters/junit.ts
+var MESSAGE_LABEL = new RegExp(`message="${FIELD_LABEL.source.slice(1)}`, "g");
+function renderFindingsJunit(report) {
+  return renderJunit(report.results, { frame: report.frame, classname: JUNIT_CLASSNAME2 }).replace(
+    MESSAGE_LABEL,
+    'message="'
+  );
+}
+
+// src/term/reporters/pretty.ts
+var WIDTH = 80;
+function wrapWords(text2, width) {
+  const lines = [];
+  let line = "";
+  for (const word of text2.split(/\s+/).filter((w) => w !== "")) {
+    if (line === "") line = word;
+    else if (line.length + 1 + word.length <= width) line = `${line} ${word}`;
+    else {
+      lines.push(line);
+      line = word;
+    }
+  }
+  if (line !== "") lines.push(line);
+  return lines.length === 0 ? [""] : lines;
+}
+function wrapSentences(text2, width) {
+  if (text2.length <= width) return [text2];
+  const lines = [];
+  let line = "";
+  for (const sentence of text2.split(/(?<=\.)\s+(?=\S)/)) {
+    if (line === "") line = sentence;
+    else if (line.length + 1 + sentence.length <= width) line = `${line} ${sentence}`;
+    else {
+      lines.push(line);
+      line = sentence;
+    }
+  }
+  if (line !== "") lines.push(line);
+  return lines;
+}
+function hanging(first, lines) {
+  const indent = " ".repeat(first.length);
+  return lines.map((line, i) => `${i === 0 ? first : indent}${line}`.trimEnd());
+}
+function renderListPretty(terms) {
+  const idWidth = Math.max(0, ...terms.map((t) => t.id.length)) + 3;
+  const labelWidth = Math.max(0, ...terms.map((t) => t.record.label.length)) + 3;
+  const rows = terms.map(
+    (t) => `${t.id.padEnd(idWidth)}${t.record.label.padEnd(labelWidth)}${(t.record["alt-labels"] ?? []).join(", ")}`.trimEnd()
+  );
+  return [...rows, plural3(terms.length, "term")].join("\n");
+}
+var GET_FIELDS = [
+  "alt-labels",
+  "hidden-labels",
+  "broader",
+  "narrower",
+  "related-terms",
+  "see",
+  "abstract",
+  "scope-note",
+  "definition"
+];
+var KEY_WIDTH = Math.max("language".length, ...TERM_FIELDS.map((f) => f.length)) + 2;
+function renderGetPretty(term, opts) {
+  const c = palette(opts.color);
+  const where2 = `${displayPath(term.location.file, opts.cwd ?? process.cwd())}:${String(term.location.line)}`;
+  const lines = [`${c.bold(term.record.label.padEnd(40))}${c.dim(where2)}`];
+  const row = (key, value) => {
+    const prefix = `  ${key.padEnd(KEY_WIDTH)}`;
+    lines.push(...hanging(prefix, wrapWords(value, WIDTH - prefix.length)));
+  };
+  row("id", term.id);
+  if (term.language !== void 0) row("language", term.language);
+  for (const field of GET_FIELDS) {
+    const value = term.record[field];
+    if (value === void 0) continue;
+    row(field, typeof value === "string" ? value : value.join(", "));
+  }
+  return lines.join("\n");
+}
+var RULE_WIDTH = 32;
+function severityText(c, severity) {
+  const padded = severity.padEnd(6);
+  if (severity === "error") return c.red(padded);
+  if (severity === "warning") return c.yellow(padded);
+  return c.cyan(padded);
+}
+function counts(findings) {
+  const parts = [];
+  const n = (severity) => findings.filter((f) => f.severity === severity).length;
+  if (n("error") > 0) parts.push(plural3(n("error"), "error"));
+  if (n("warning") > 0) parts.push(plural3(n("warning"), "warning"));
+  if (n("notice") > 0) parts.push(plural3(n("notice"), "notice"));
+  return parts.join(", ");
+}
+function renderFindingsPretty(report, opts) {
+  const c = palette(opts.color);
+  const { baseline } = report;
+  if (baseline?.written === true) {
+    return `${c.green("\u2713")} ${plural3(report.found, "finding")} recorded in ${baseline.path}`;
+  }
+  const baselined = baseline !== void 0 && baseline.suppressed > 0 ? `, ${String(baseline.suppressed)} baselined` : "";
+  const terms = plural3(report.terms, "term");
+  if (report.findings.length === 0) {
+    const references2 = opts.references === false ? "" : `, ${plural3(report.references, "reference")}`;
+    return `${c.green("\u2713")} ${terms}${references2}, no findings${baselined}`;
+  }
+  const ruleWidth = Math.max(RULE_WIDTH, ...report.findings.map((f) => f.ruleId.length + 2));
+  const lines = [];
+  let group;
+  for (const finding of report.findings) {
+    const file = displayPath(finding.file, report.cwd);
+    const header = finding.line === void 0 ? file : `${file}:${String(finding.line)}`;
+    if (header !== group) {
+      lines.push(c.bold(header));
+      group = header;
+    }
+    const prefixWidth = 2 + 6 + 1 + ruleWidth;
+    const message = wrapSentences(finding.message, WIDTH - prefixWidth);
+    const indent = " ".repeat(prefixWidth);
+    message.forEach((text2, i) => {
+      lines.push(
+        i === 0 ? `  ${severityText(c, finding.severity)} ${finding.ruleId.padEnd(ruleWidth)}${text2}` : `${indent}${text2}`
+      );
+    });
+  }
+  lines.push("", `${counts(report.findings)} in ${terms}${baselined}`);
+  return lines.join("\n");
+}
+function changeLine(change) {
+  switch (change.action) {
+    case "create":
+      return `${change.path} would be created`;
+    case "change":
+      return `${change.path} would change`;
+    case "remove":
+      return `${change.path} would be removed`;
+  }
+}
+function swapCount(content) {
+  const lines = content.split(/\r?\n/);
+  const start2 = lines.indexOf("swap:");
+  if (start2 === -1) return 0;
+  return lines.slice(start2 + 1).filter((line) => line.startsWith("  ")).length;
+}
+function baseName2(path) {
+  return path.split(/[\\/]/).pop() ?? path;
+}
+var CASING_RULES = /* @__PURE__ */ new Set(["Casing.yml", "Lowercase.yml", "SentenceStart.yml"]);
+function valeLines(report) {
+  const rows = [];
+  const acronyms = [];
+  for (const file of report.files) {
+    const name = baseName2(file.path);
+    if (CASING_RULES.has(name)) rows.push([name, plural3(swapCount(file.content), "label")]);
+    else if (name === "Deprecated.yml") rows.push([name, plural3(swapCount(file.content), "swap")]);
+    else acronyms.push(name);
+  }
+  if (acronyms.length > 0) rows.push([acronyms.join(", "), plural3(acronyms.length, "acronym")]);
+  const width = Math.max(0, ...rows.map(([name]) => name.length)) + 2;
+  return rows.map(([name, what]) => `  ${name.padEnd(width)}${what}`);
+}
+function droppedLine(report) {
+  if (report.dropped.length === 0) return void 0;
+  const ids = /* @__PURE__ */ new Map();
+  for (const { id, field } of report.dropped) {
+    const set = ids.get(field) ?? /* @__PURE__ */ new Set();
+    set.add(id);
+    ids.set(field, set);
+  }
+  const fields = [...ids.entries()].map(([field, set]) => ({ field, n: set.size })).sort((a, b) => a.n - b.n || TERM_FIELDS.indexOf(a.field) - TERM_FIELDS.indexOf(b.field));
+  const parts = fields.map(({ field, n }, i) => `${field} on ${i === 0 ? plural3(n, "term") : String(n)}`);
+  return `  dropped from ${report.droppedFrom ?? report.format ?? "the render"}: ${parts.join(", ")}`;
+}
+function skippedLine(report) {
+  if (report.skipped.length === 0) return void 0;
+  const construct = report.droppedFrom ?? report.format ?? "the render";
+  const count = plural3(report.skipped.length, "term");
+  return `  skipped ${count} ${construct} cannot read without a definition: ${report.skipped.join(", ")}`;
+}
+function renderNotes(report) {
+  return [droppedLine(report), skippedLine(report)].filter((line) => line !== void 0);
+}
+function unchangedLine(report) {
+  return report.mode === "in-place" ? "Nothing to write" : `${report.target ?? ""} is up to date`;
+}
+function renderWritePretty(report) {
+  if (report.check) {
+    return report.changes.length > 0 ? report.changes.map(changeLine).join("\n") : unchangedLine(report);
+  }
+  if (report.dryRun) {
+    const changes = report.changes.length > 0 ? report.changes.map(changeLine) : [unchangedLine(report)];
+    return [...changes, ...renderNotes(report)].join("\n");
+  }
+  if (report.mode === "in-place") {
+    return report.changes.length === 0 ? "Nothing to write" : `Wrote ${plural3(report.changes.length, "file")}`;
+  }
+  const each = report.shape === "directory" && report.format !== "vale" ? ", one file each" : "";
+  const written = report.terms - report.skipped.length;
+  const lines = [`Wrote ${plural3(written, "term")} to ${report.target ?? ""}${each}`];
+  if (report.format === "vale") lines.push(...valeLines(report));
+  lines.push(...renderNotes(report));
+  return lines.join("\n");
+}
+function renderValeWiring(wiring) {
+  return [
+    wiring.addSection ? `notice: ${wiring.rootIni} has no section with BasedOnStyles. Add one that uses the Terms style:` : `notice: no section of ${wiring.rootIni} uses the Terms style. Add it to BasedOnStyles:`,
+    `  [${wiring.section}]`,
+    `  BasedOnStyles = ${wiring.styles.join(", ")}`
+  ].join("\n");
+}
+function renderFormatsPretty(rows) {
+  const formatWidth = Math.max(0, ...rows.map((r) => r.format.length)) + 3;
+  const labelWidth = Math.max(0, ...rows.map((r) => r.label.length)) + 3;
+  return rows.map(
+    (r) => `${r.format.padEnd(formatWidth)}${r.label.padEnd(labelWidth)}${r.read ? "read  " : "      "}${r.write ? "write" : ""}`.trimEnd()
+  ).join("\n");
+}
+
+// src/term/cli.ts
+function colorFor2(options) {
+  return shouldColor({ noColor: !options.color, isTTY: process.stdout.isTTY });
+}
+async function coreOptions(paths, options) {
+  return {
+    inputs: paths,
+    ...paths.includes(STDIN_TOKEN) ? { stdin: await readStdin() } : {},
+    ...options.as === void 0 ? {} : { as: options.as },
+    ...options.ext === void 0 ? {} : { exts: splitList(options.ext) },
+    exclude: options.exclude,
+    collection: options.collection,
+    ...options.allowEmpty === true ? { allowEmpty: true } : {},
+    ...options.gitignore ? {} : { noGitignore: true },
+    ...options.config === void 0 ? {} : { configPath: options.config },
+    onNotice: notice
+  };
+}
+function withInputs(command) {
+  return command.option("--as <format>", "input format for stdin (-)").option("--ext <list>", "comma-separated extensions for directory walks").option("--exclude <glob>", "glob to exclude; repeatable", collect, []).option("--collection <name>", "configured collection to read; repeatable", collect, []).option("--allow-empty", "treat zero matched files as success").option("--no-gitignore", "read files .gitignore covers").option("-c, --config <path>", "path to a manni config file").option("--no-color", "disable colored output");
+}
+function print(text2) {
+  process.stdout.write(`${text2}
+`);
+}
+function renderFindings(report, format, options, references2) {
+  let text2;
+  switch (format) {
+    case "pretty":
+      text2 = renderFindingsPretty(report, { color: colorFor2(options), references: references2 });
+      break;
+    case "json":
+      text2 = renderFindingsJson(report);
+      break;
+    case "github":
+      text2 = renderFindingsGithub(report);
+      break;
+    case "sarif":
+      text2 = renderFindingsSarif(report, { onNotice: notice });
+      break;
+    case "junit":
+      text2 = renderFindingsJunit(report);
+      break;
+  }
+  if (text2.length > 0 || !OMITTED_WHEN_CLEAN.has(format)) print(text2);
+  process.exitCode = report.summary.failed > 0 ? 1 : 0;
+}
+function buildProgram5() {
+  const program = new Command4();
+  program.name("term").description("Check, lint and render a docset's terms and the references into them.").version(package_default.version, "-V, --version").showHelpAfterError("(add --help for usage)").exitOverride();
+  withInputs(
+    program.command("list").description("List the resolved entries").argument("[paths...]", "files, directories, or globs to read (use - for stdin)")
+  ).option("-f, --format <format>", `output: ${LIST_FORMATS.join(" | ")}`, "pretty").addHelpText(
+    "after",
+    [
+      "",
+      "Examples:",
+      "  manni term list                       # every collection",
+      "  manni term list docs/terms/           # one directory",
+      "  manni term list -f csv | head -2      # for a script"
+    ].join("\n")
+  ).action(async (paths, options) => {
+    try {
+      const format = formatChoice(options.format, LIST_FORMATS);
+      const { terms } = await runList(await coreOptions(paths, options));
+      print(format === "json" ? renderListJson(terms) : format === "csv" ? renderListCsv(terms) : renderListPretty(terms));
+      process.exitCode = 0;
+    } catch (err) {
+      fail(err);
+    }
+  });
+  withInputs(
+    program.command("get").description("Show one entry").argument("<term>", "the entry's id, or its label or an alt-label in any case").argument("[paths...]", "files, directories, or globs to read (use - for stdin)")
+  ).option("-f, --format <format>", `output: ${GET_FORMATS.join(" | ")}`, "pretty").addHelpText(
+    "after",
+    ["", "Examples:", "  manni term get progressive-lens", '  manni term get "progressive lens" -f json'].join("\n")
+  ).action(async (term, paths, options) => {
+    try {
+      const format = formatChoice(options.format, GET_FORMATS);
+      const found = await runGet({ ...await coreOptions(paths, options), term });
+      print(format === "json" ? renderGetJson(found) : renderGetPretty(found, { color: colorFor2(options) }));
+      process.exitCode = 0;
+    } catch (err) {
+      fail(err);
+    }
+  });
+  withInputs(
+    program.command("check").description("Check the set and every reference into it").argument("[paths...]", "files, directories, or globs to read (use - for stdin)")
+  ).option("-f, --format <format>", `output: ${FINDING_FORMATS.join(" | ")}`, "pretty").option("--baseline", "record the findings on the first run; after that, fail only on new ones").addHelpText(
+    "after",
+    [
+      "",
+      "Examples:",
+      "  manni term check                      # every collection",
+      "  manni term check -f github            # CI annotations",
+      "  manni term check --baseline           # ramp in on an existing docset"
+    ].join("\n")
+  ).action(async (paths, options) => {
+    try {
+      const format = formatChoice(options.format, FINDING_FORMATS);
+      const report = await runCheck3({
+        ...await coreOptions(paths, options),
+        ...options.baseline === true ? { baseline: true } : {}
+      });
+      renderFindings(report, format, options, true);
+    } catch (err) {
+      fail(err);
+    }
+  });
+  withInputs(
+    program.command("lint").description("Run Vale over the definitions").argument("[paths...]", "files, directories, or globs to read (use - for stdin)")
+  ).option("-f, --format <format>", `output: ${FINDING_FORMATS.join(" | ")}`, "pretty").addHelpText(
+    "after",
+    ["", "Examples:", "  manni term lint", "  manni term lint -f github"].join("\n")
+  ).action(async (paths, options) => {
+    try {
+      const format = formatChoice(options.format, FINDING_FORMATS);
+      const report = await runLint(await coreOptions(paths, options));
+      renderFindings(report, format, options, false);
+    } catch (err) {
+      fail(err);
+    }
+  });
+  withInputs(
+    program.command("write").description("Write the set back, or render it elsewhere").argument("[paths...]", "files, directories, or globs to read (use - for stdin)")
+  ).option("-f, --format <format>", `render as: ${writeFormats().join(" | ")} (default: each entry's own, in place)`).option("-o, --out <path>", "file or directory to render into; a trailing / means a directory").option("--check", "write nothing; exit 1 when the target differs from the render").option("--dry-run", "write nothing; print what would change").addHelpText(
+    "after",
+    [
+      "",
+      "Examples:",
+      "  manni term write                            # each entry back to its source",
+      "  manni term write -f json -o build/terms.json",
+      "  manni term write -f vale                    # into Vale's styles directory",
+      "  manni term write -f vale --check            # keep the style in step"
+    ].join("\n")
+  ).action(async (paths, options) => {
+    try {
+      const report = await runWrite({
+        ...await coreOptions(paths, options),
+        ...options.format === void 0 ? {} : { format: options.format },
+        ...options.out === void 0 ? {} : { out: options.out },
+        ...options.check === true ? { check: true } : {},
+        ...options.dryRun === true ? { dryRun: true } : {}
+      });
+      print(renderWritePretty(report));
+      if (report.wiring !== void 0) process.stderr.write(`${renderValeWiring(report.wiring)}
+`);
+      process.exitCode = report.check && report.changes.length > 0 ? 1 : 0;
+    } catch (err) {
+      fail(err);
+    }
+  });
+  program.command("formats").description("List the constructs read and written, per format").option("-f, --format <format>", `output: ${FORMATS_FORMATS.join(" | ")}`, "pretty").action((options) => {
+    try {
+      const format = formatChoice(options.format, FORMATS_FORMATS);
+      const rows = listFormats();
+      print(format === "json" ? renderFormatsJson(rows) : renderFormatsPretty(rows));
+      process.exitCode = 0;
+    } catch (err) {
+      fail(err);
+    }
+  });
+  return program;
+}
+
+// src/cli.ts
+function buildProgram6() {
+  const meta = buildProgram().name("meta").description(
+    "Validate, read, query and fill document metadata against JSON Schema"
+  );
+  const metaCommands = new Set(meta.commands.map((c) => c.name()));
+  const program = new Command5();
+  program.name("manni").description("Tools for documentation that is meant to be checked.").version(package_default.version, "-V, --version").showHelpAfterError("(add --help for usage)").exitOverride().configureOutput({
+    outputError: (str, write) => {
+      write(str);
+      const m = /unknown command '([^']+)'/.exec(str);
+      const name = m?.[1];
+      if (name !== void 0 && metaCommands.has(name)) {
+        write(
+          `(\`${name}\` is a metadata command: try \`manni meta ${name}\`)
+`
+        );
+      }
+    }
+  });
+  program.addCommand(meta);
+  program.addCommand(
+    buildProgram2().name("a11y").description(
+      "Crawl a site and check every page for accessibility violations with axe-core"
+    )
+  );
+  program.addCommand(
+    buildProgram3().name("cite").description(
+      "Track citations from doc claims to source lines and check them for drift"
+    )
+  );
+  program.addCommand(
+    buildProgram5().name("term").description("Check, lint and render a docset's terms and the references into them")
   );
   program.addCommand(
     buildProgram4().name("key").description("Set and rotate the family key that encrypted values are encrypted with.")
   );
   return program;
 }
-runIfMain(import.meta.url, buildProgram5);
+runIfMain(import.meta.url, buildProgram6);
 export {
-  buildProgram5 as buildProgram
+  buildProgram6 as buildProgram
 };
 //# sourceMappingURL=cli.js.map