@hawkeyexl/manni 4.4.1 → 4.5.0

package/dist/{chunk-WB3QM6PP.js → chunk-ELZ2IIOF.js}

@@ -1,49 +1,16 @@
 #!/usr/bin/env node
 import {
-  packageRoot
-} from "./chunk-TIUTIOFB.js";
+  LintError
+} from "./chunk-YGFIQ6Y5.js";
 import {
-  BLOCK_KINDS,
-  BLOCK_KIND_NODE,
-  LintError,
-  checkContains,
-  checkContainsIn,
-  checkHeading,
-  checkSequence,
-  checkSequenceIn,
-  isWildcard,
-  matchSections,
-  occurrenceRange
-} from "./chunk-CK7SKVHR.js";
-import {
-  STDIN_TOKEN,
-  assertNonEmpty,
   extractFrontmatter,
   extractorForExtension,
-  gitignoreOptions,
-  isErrorSeverity,
-  locateFrontmatter,
-  resolveTargetSet
-} from "./chunk-57NEQRVO.js";
-import {
-  ditaOtHome,
-  findConfigFile,
-  readConfigFile,
-  selectCollections,
-  warn
-} from "./chunk-Q35YIDBV.js";
+  locateFrontmatter
+} from "./chunk-527HHQPS.js";
 import {
-  package_default
-} from "./chunk-UJCVAWP7.js";
-import {
-  ToolError,
   errorMessage
 } from "./chunk-G3T47CFV.js";
 
-// src/lint/commands/lint.ts
-import { readFile as readFile3 } from "node:fs/promises";
-import { extname, relative, resolve as resolve2 } from "node:path";
-
 // src/lint/parsers/markdown.ts
 import { unified } from "unified";
 import remarkParse from "remark-parse";
@@ -309,6 +276,8 @@ function sectionize(fragments, docEnd) {
         order: 0,
         parentSlug: null,
         titlePosition: { ...fragment.position },
+        ...fragment.id !== void 0 ? { id: fragment.id } : {},
+        ...fragment.synthetic ? { synthetic: true } : {},
         position: { start: { ...fragment.position.start }, end: { ...fragment.position.end } },
         children: [],
         sections: []
@@ -354,7 +323,7 @@ function withMetadataTitle(fragments, metadata2, position) {
   if (title === null || title.length === 0) return fragments;
   if (position === null) return fragments;
   if (fragments.some((b) => b.type === "heading" && b.level === 1)) return fragments;
-  return [{ type: "heading", level: 1, title, position }, ...fragments];
+  return [{ type: "heading", level: 1, title, position, synthetic: true }, ...fragments];
 }
 function withoutFence(content) {
   const loc = locateFrontmatter(content);
@@ -385,7 +354,9 @@ function parseWith(processor2, format, content, filePath) {
     sections: sectionize(
       withMetadataTitle(toFragments(tree), frontmatter, metaPosition),
       documentEnd(tree)
-    )
+    ),
+    // Markdown's links are read from mdast by `manni graph` itself.
+    links: []
   };
 }
 var SHARED_KINDS = [
@@ -473,16 +444,18 @@ function positionOf2(node) {
     end: { line: loc.endLine, column: loc.endCol, offset: loc.endOffset }
   };
 }
-function rawText(node) {
+function rawText(node, skipHref) {
   if (defaultTreeAdapter.isTextNode(node)) return node.value;
   if (!defaultTreeAdapter.isElementNode(node)) return "";
-  if (NON_TEXT_TAGS.has(tagOf(node))) return "";
+  const tag = tagOf(node);
+  if (NON_TEXT_TAGS.has(tag)) return "";
+  if (skipHref !== void 0 && tag === "a" && attrOf(node, "href") === skipHref) return "";
   let out = "";
-  for (const child of node.childNodes) out += rawText(child);
+  for (const child of node.childNodes) out += rawText(child, skipHref);
   return out;
 }
-function flatText(node) {
-  return rawText(node).replace(/\s+/g, " ").trim();
+function flatText(node, skipHref) {
+  return rawText(node, skipHref).replace(/\s+/g, " ").trim();
 }
 function langOf(el) {
   const className = attrOf(el, "class");
@@ -672,16 +645,16 @@ function listItems(list) {
 function childContent2(parent) {
   const out = [];
   let text = "";
-  let span2 = null;
+  let span = null;
   const extend = (node) => {
     const at = positionOf2(node);
-    span2 = span2 === null ? at : { start: span2.start, end: at.end };
+    span = span === null ? at : { start: span.start, end: at.end };
   };
   const flush = () => {
     const value = text.trim();
-    const at = span2;
+    const at = span;
     text = "";
-    span2 = null;
+    span = null;
     if (value.length === 0) return;
     out.push({ kind: "paragraph", position: at ?? positionOf2(parent), text: value });
   };
@@ -707,9 +680,9 @@ function childContent2(parent) {
       out.push(...nested);
       continue;
     }
-    const inline = flatText(child);
-    text += inline;
-    if (inline.trim().length > 0) extend(child);
+    const inline2 = flatText(child);
+    text += inline2;
+    if (inline2.trim().length > 0) extend(child);
   }
   flush();
   return out;
@@ -760,17 +733,21 @@ function contentIn(parent) {
   }
   return out;
 }
-function walk(parent, out) {
+function walk(parent, out, ids) {
   for (const child of parent.childNodes) {
     if (!defaultTreeAdapter.isElementNode(child)) continue;
     const tag = tagOf(child);
     const role = roleOf(child, tag);
     if (role === "heading") {
+      const id = ids.claim(child);
       out.push({
         type: "heading",
         level: HEADING_LEVELS.get(tag) ?? 1,
-        title: flatText(child),
-        position: positionOf2(child)
+        // The self-permalink is dropped from the title as it is from the links:
+        // Sphinx's `¶` is a widget, and "Install the SDK¶" is no reader's title.
+        title: flatText(child, id !== void 0 ? `#${id}` : void 0),
+        position: positionOf2(child),
+        ...id !== void 0 ? { id } : {}
       });
       continue;
     }
@@ -780,7 +757,44 @@ function walk(parent, out) {
       continue;
     }
     if (role === "opaque") continue;
-    walk(child, out);
+    if (ID_CARRIERS.has(tag)) {
+      ids.enter(child);
+      walk(child, out, ids);
+      ids.leave();
+      continue;
+    }
+    walk(child, out, ids);
+  }
+}
+var ID_CARRIERS = /* @__PURE__ */ new Set(["section", "article"]);
+var HeadingIds = class {
+  open = [];
+  byHeading = /* @__PURE__ */ new Map();
+  enter(el) {
+    this.open.push({ id: attrOf(el, "id"), spent: false });
+  }
+  leave() {
+    this.open.pop();
+  }
+  claim(heading) {
+    const nearest = this.open.at(-1);
+    const inherited = nearest && !nearest.spent ? nearest.id : void 0;
+    for (const carrier of this.open) carrier.spent = true;
+    const id = attrOf(heading, "id") ?? inherited;
+    if (id !== void 0) this.byHeading.set(heading, id);
+    return id;
+  }
+};
+function collectLinks(parent, ids, heading, out) {
+  for (const child of parent.childNodes) {
+    if (!defaultTreeAdapter.isElementNode(child)) continue;
+    const tag = tagOf(child);
+    if (tag === "a" || tag === "area") {
+      const href = attrOf(child, "href");
+      const permalink = heading !== void 0 && href === `#${heading}`;
+      if (href !== void 0 && !permalink) out.push({ target: href, position: positionOf2(child) });
+    }
+    collectLinks(child, ids, HEADING_LEVELS.has(tag) ? ids.get(child) : heading, out);
   }
 }
 function documentEnd2(content) {
@@ -817,7 +831,10 @@ function findHead(doc) {
 function parseHtml(content, filePath) {
   const doc = parse(content, { sourceCodeLocationInfo: true });
   const fragments = [];
-  walk(doc, fragments);
+  const ids = new HeadingIds();
+  walk(doc, fragments, ids);
+  const links = [];
+  collectLinks(doc, ids.byHeading, void 0, links);
   const { frontmatter, position } = metadataOf(content, filePath, doc);
   return {
     format: "html",
@@ -827,7 +844,8 @@ function parseHtml(content, filePath) {
     sections: sectionize(
       withMetadataTitle(fragments, frontmatter, position),
       documentEnd2(content)
-    )
+    ),
+    links
   };
 }
 var htmlParser = {
@@ -1235,11 +1253,13 @@ function scanRange(src, levels, from, to, base, headings) {
     if (headings) {
       const hit = titleAt(src, i, to);
       if (hit) {
+        const id = labelAbove(src, hit.first);
         fragments.push({
           type: "heading",
           level: levelFor(levels, hit.style),
           title: hit.title,
-          position: spanOf(src, hit.first, hit.last)
+          position: spanOf(src, hit.first, hit.last),
+          ...id !== void 0 ? { id } : {}
         });
         i = hit.last + 1;
         continue;
@@ -1568,6 +1588,106 @@ function readParagraph(src, levels, fragments, from, to, base, headings) {
   });
   return Math.max(blockEnd, end);
 }
+var TARGET = /^[ \t]*\.\.[ \t]+_(?:`([^`]+)`|([^:`]+)):(?:[ \t]+(.*?))?[ \t]*$/;
+function targetAt(src, line) {
+  const match = TARGET.exec(src.text[line] ?? "");
+  const name = (match?.[1] ?? match?.[2] ?? "").trim();
+  if (!match || name === "" || name === "_") return null;
+  let uri = match[3] ?? "";
+  const base = indentOf(src.text[line] ?? "");
+  for (let next = line + 1; next < src.text.length; next++) {
+    const text = src.text[next] ?? "";
+    if (isBlank(text) || indentOf(text) <= base) break;
+    uri += text;
+  }
+  return { name, uri: uri.replace(/\s+/g, "") };
+}
+var refName = (name) => name.replace(/\s+/g, " ").trim().toLowerCase();
+function labelAbove(src, first) {
+  let line = first - 1;
+  while (line >= 0 && isBlank(src.text[line])) line--;
+  const target = line >= 0 ? targetAt(src, line) : null;
+  return target && target.uri === "" ? target.name : void 0;
+}
+function codeLines(nodes, out) {
+  for (const node of nodes) {
+    if (node.kind === "codeBlock") {
+      for (let l = node.position.start.line; l <= node.position.end.line; l++) out.add(l);
+    } else if (node.kind === "list") {
+      codeLines(node.items, out);
+    } else if (node.kind === "definitionItem") {
+      codeLines(node.definition, out);
+    } else if ("children" in node) {
+      codeLines(node.children, out);
+    }
+  }
+  return out;
+}
+var blank = (text, index, length) => text.slice(0, index) + " ".repeat(length) + text.slice(index + length);
+var INLINE_LITERAL = /``.+?``/g;
+var DOC_ROLE = /:doc:`([^`]*)`/g;
+var ROLE = /:[\w.+:-]+:`[^`]*`/g;
+var EMBEDDED = /`([^`<]*?)\s*<([^<>`]+)>`(__?)/g;
+var PHRASE_REF = /`([^`]+)`_(?!_)/g;
+var SIMPLE_REF = /(?<![\w\\])([A-Za-z0-9]+(?:[-_.:+][A-Za-z0-9]+)*)_(?!\w)/g;
+function collectLinks2(src, from, code) {
+  const targets = /* @__PURE__ */ new Map();
+  for (let line = from; line < src.text.length; line++) {
+    const target = targetAt(src, line);
+    if (target && target.uri !== "") targets.set(refName(target.name), target.uri);
+  }
+  for (let line = from; line < src.text.length; line++) {
+    for (const m of (src.text[line] ?? "").matchAll(EMBEDDED)) {
+      const name = refName(m[1] ?? "");
+      if (m[3] === "_" && name !== "" && !targets.has(name)) {
+        targets.set(name, (m[2] ?? "").replace(/\s+/g, ""));
+      }
+    }
+  }
+  const resolve = (name) => {
+    let uri = targets.get(refName(name));
+    for (let hops = 0; uri?.endsWith("_") && hops < targets.size; hops++) {
+      uri = targets.get(refName(uri.slice(0, -1)));
+    }
+    return uri?.endsWith("_") ? void 0 : uri;
+  };
+  const links = [];
+  for (let line = from; line < src.text.length; line++) {
+    let text = src.text[line] ?? "";
+    if (code.has(line + 1) || TARGET.test(text)) continue;
+    const hits = [];
+    const take = (pattern, toTarget) => {
+      for (const m of text.matchAll(pattern)) {
+        const target = toTarget(m);
+        if (target) hits.push({ column: m.index + 1, length: m[0].length, target });
+        text = blank(text, m.index, m[0].length);
+      }
+    };
+    take(INLINE_LITERAL, () => void 0);
+    take(DOC_ROLE, (m) => {
+      const inner = (m[1] ?? "").trim();
+      return /<([^<>]+)>$/.exec(inner)?.[1]?.trim() ?? inner;
+    });
+    take(ROLE, () => void 0);
+    take(EMBEDDED, (m) => {
+      const uri = (m[2] ?? "").replace(/\s+/g, "");
+      return uri.endsWith("_") ? resolve(uri.slice(0, -1)) : uri;
+    });
+    take(PHRASE_REF, (m) => resolve(m[1] ?? ""));
+    take(SIMPLE_REF, (m) => resolve(m[1] ?? ""));
+    hits.sort((a, b) => a.column - b.column);
+    for (const hit of hits) {
+      links.push({
+        target: hit.target,
+        position: {
+          start: pointAt(src, line, hit.column),
+          end: pointAt(src, line, hit.column + hit.length)
+        }
+      });
+    }
+  }
+  return links;
+}
 function docinfoPosition(src) {
   const limit = src.text.length;
   let i = 0;
@@ -1647,6 +1767,14 @@ var rstParser = {
       sections: sectionize(
         withMetadataTitle(fragments, frontmatter, position),
         src.end
+      ),
+      links: collectLinks2(
+        src,
+        Math.max(bodyStart, 0),
+        codeLines(
+          fragments.flatMap((f) => f.type === "content" ? [f.node] : []),
+          /* @__PURE__ */ new Set()
+        )
       )
     };
   }
@@ -1719,7 +1847,12 @@ var DITA = {
   definitionLists: ["dl"],
   definitionItems: ["dlentry"],
   definitionTerms: ["dt"],
-  definitionBodies: ["dd"]
+  definitionBodies: ["dd"],
+  // `keyref`, `conkeyref` and `conref` are not here: a key resolves only
+  // against a map at build time, and a conref pulls content in rather than
+  // pointing a reader anywhere.
+  links: [{ elements: ["xref", "link"], attribute: "href" }],
+  ditaHrefs: true
 };
 var DOCBOOK = {
   name: "docbook",
@@ -1784,34 +1917,40 @@ var DOCBOOK = {
   definitionTerms: ["term"],
   // DocBook reuses `<listitem>` for a variable list's own body, distinct from
   // the `listItems` bucket above which reads it inside `<itemizedlist>`.
-  definitionBodies: ["listitem"]
+  definitionBodies: ["listitem"],
+  links: [
+    { elements: ["link"], attribute: "href" },
+    { elements: ["ulink"], attribute: "url" },
+    { elements: ["xref", "link"], attribute: "linkend", idref: true }
+  ]
 };
+var MAP_ENTRIES = [
+  "map",
+  "bookmap",
+  "topicref",
+  "topichead",
+  "mapref",
+  "glossref",
+  "anchorref",
+  "navref",
+  "topicset",
+  "topicsetref",
+  "chapter",
+  "part",
+  "appendix",
+  "appendices",
+  "preface",
+  "notices",
+  "dedication",
+  "colophon",
+  "amendments"
+];
 var DITAMAP = {
   name: "ditamap",
   label: "DITA map",
   namespaces: [],
   roots: ["map", "bookmap"],
-  sections: [
-    "map",
-    "bookmap",
-    "topicref",
-    "topichead",
-    "mapref",
-    "glossref",
-    "anchorref",
-    "navref",
-    "topicset",
-    "topicsetref",
-    "chapter",
-    "part",
-    "appendix",
-    "appendices",
-    "preface",
-    "notices",
-    "dedication",
-    "colophon",
-    "amendments"
-  ],
+  sections: MAP_ENTRIES,
   // `navtitle` sits in both buckets on purpose, because DITA spells it either
   // way. The element form wins: `headingOf` asks `titleOf` first, so
   // `@navtitle` is read only when the entry has no `<topicmeta><navtitle>`.
@@ -1831,7 +1970,12 @@ var DITAMAP = {
   codeLangAttributes: [],
   unorderedLists: [],
   orderedLists: [],
-  listItems: []
+  listItems: [],
+  // Every navigation entry's `href`. `<keydef>` is not an entry - it binds a
+  // key to a resource and never appears in a table of contents - so its
+  // `href` is not a link, for the reason it is not a section.
+  links: [{ elements: MAP_ENTRIES, attribute: "href" }],
+  ditaHrefs: true
 };
 var XML_VOCABULARIES = [
   DITA,
@@ -1865,6 +2009,11 @@ function compile(vocab) {
     definitionItems: lower(vocab.definitionItems),
     definitionTerms: lower(vocab.definitionTerms),
     definitionBodies: lower(vocab.definitionBodies),
+    links: (vocab.links ?? []).map((l) => ({
+      elements: lower(l.elements),
+      attribute: l.attribute.toLowerCase(),
+      idref: l.idref ?? false
+    })),
     known: /* @__PURE__ */ new Set()
   };
   for (const set of [
@@ -1907,6 +2056,19 @@ function* elementChildren2(el) {
     if (child.nodeType === ELEMENT_NODE) yield child;
   }
 }
+function attributeByLocalName(el, name) {
+  for (let i = 0; i < el.attributes.length; i++) {
+    const attr = el.attributes.item(i);
+    if (attr && localName(attr) === name) return attr.value;
+  }
+  return null;
+}
+function ditaTarget(href) {
+  if (/^[a-z][a-z0-9+.-]*:/i.test(href)) return href;
+  const hash = href.indexOf("#");
+  const slash = href.lastIndexOf("/");
+  return hash === -1 || slash < hash ? href : href.slice(0, hash + 1) + href.slice(slash + 1);
+}
 function findDirectChild(el, names) {
   for (const child of elementChildren2(el)) {
     if (names.has(localName(child))) return child;
@@ -1942,7 +2104,7 @@ var NAMESPACE_MATCH = 1e3;
 var EXCLUSIVE_ELEMENT = 10;
 var ROOT_NAME = 5;
 var SHARED_ELEMENT = 1;
-function chooseVocabulary(root, compiled3) {
+function chooseVocabulary(root, compiled) {
   const counts = /* @__PURE__ */ new Map();
   const tally = (node) => {
     for (const child of elementChildren2(node)) {
@@ -1954,14 +2116,14 @@ function chooseVocabulary(root, compiled3) {
   counts.set(localName(root), 1);
   tally(root);
   const claims = /* @__PURE__ */ new Map();
-  for (const c of compiled3) {
+  for (const c of compiled) {
     for (const name of c.known) claims.set(name, (claims.get(name) ?? 0) + 1);
   }
   const ns = (root.namespaceURI ?? "").toLowerCase();
   const rootName = localName(root);
   let best;
   let bestScore = -1;
-  for (const c of compiled3) {
+  for (const c of compiled) {
     let score = 0;
     if (ns && c.vocab.namespaces.some((u) => u.toLowerCase() === ns)) {
       score += NAMESPACE_MATCH;
@@ -2104,10 +2266,12 @@ var Flattener = class {
         return;
       }
       const next = Math.min(level + 1, 6);
+      const id = attributeByLocalName(el, "id");
       this.fragments.push({
         type: "heading",
         level: next,
         title: heading.title,
+        ...id ? { id } : {},
         // From the container's start tag through the end of its title: the
         // container is the section, so a section that began at its `<title>`
         // would leave its own opening tag outside itself and stop adjacent
@@ -2124,6 +2288,23 @@ var Flattener = class {
     const node = this.content(el);
     if (node) this.fragments.push({ type: "content", node });
   }
+  /**
+   * Every link target under `el`, in document order. A walk of its own rather
+   * than part of `visit`, because `visit` skips unmapped subtrees and
+   * `<related-links>` is one of them.
+   */
+  links(el, out = []) {
+    const name = localName(el);
+    for (const source of this.c.links) {
+      if (!source.elements.has(name)) continue;
+      const value = attributeByLocalName(el, source.attribute);
+      if (!value) continue;
+      const target = source.idref ? `#${value}` : this.c.vocab.ditaHrefs ? ditaTarget(value) : value;
+      out.push({ target, position: this.span(el) });
+    }
+    for (const child of elementChildren2(el)) this.links(child, out);
+    return out;
+  }
   walkChildren(el, level) {
     for (const child of elementChildren2(el)) this.visit(child, level);
   }
@@ -2423,12 +2604,12 @@ function readMetadata2(content, filePath) {
 function parseXml(content, filePath, vocabularies = XML_VOCABULARIES) {
   const map = new SourceMap(content);
   const root = parseDocument(map.text, filePath);
-  const compiled3 = vocabularies.map(compile);
-  if (compiled3.length === 0) {
+  const compiled = vocabularies.map(compile);
+  if (compiled.length === 0) {
     throw new LintError(`${filePath}: no XML vocabularies are configured.`);
   }
-  const { best, score } = chooseVocabulary(root, compiled3);
-  const names = compiled3.map((c) => c.vocab.label).join(", ");
+  const { best, score } = chooseVocabulary(root, compiled);
+  const names = compiled.map((c) => c.vocab.label).join(", ");
   if (score <= 0) {
     throw new LintError(
       `${filePath}: no known XML vocabulary matched <${localName(root)}>. manni lint understands ${names}; add an entry to XML_VOCABULARIES in src/parsers/xml.ts to describe another schema.`
@@ -2453,7 +2634,8 @@ function parseXml(content, filePath, vocabularies = XML_VOCABULARIES) {
       start: map.point(root) ?? { ...map.docEnd },
       end: map.point(root.firstChild) ?? map.endOfLine(map.point(root)?.line ?? 1)
     } : null,
-    sections: sectionize(fragments, map.docEnd)
+    sections: sectionize(fragments, map.docEnd),
+    links: flattener.links(root)
   };
 }
 var xmlParser = {
@@ -2560,7 +2742,10 @@ var NAMED_ENTITIES = {
 };
 function flattenInline2(html) {
   if (!html) return "";
-  return html.replace(/<[^>]*>/g, "").replace(/&#(\d+);/g, (_, dec) => String.fromCodePoint(Number(dec))).replace(
+  return decodeEntities(html.replace(/<[^>]*>/g, ""));
+}
+function decodeEntities(text) {
+  return text.replace(/&#(\d+);/g, (_, dec) => String.fromCodePoint(Number(dec))).replace(
     /&#x([0-9a-f]+);/gi,
     (_, hex) => String.fromCodePoint(Number.parseInt(hex, 16))
   ).replace(
@@ -2568,6 +2753,21 @@ function flattenInline2(html) {
     (whole, name) => NAMED_ENTITIES[name.toLowerCase()] ?? whole
   );
 }
+var harvested = [];
+var ANCHOR = /<a\s([^>]*)>/gi;
+var HREF = /(?:^|\s)href="([^"]*)"/;
+var CLASS = /(?:^|\s)class="([^"]*)"/;
+function inline(html, line) {
+  for (const match of (html ?? "").matchAll(ANCHOR)) {
+    const attrs = match[1] ?? "";
+    const href = HREF.exec(attrs)?.[1];
+    if (href === void 0) continue;
+    const classes = (CLASS.exec(attrs)?.[1] ?? "").split(/\s+/);
+    if (classes.includes("include") || classes.includes("footnote")) continue;
+    harvested.push({ target: decodeEntities(href), line });
+  }
+  return flattenInline2(html);
+}
 function stringAttribute(node, name) {
   const value = node.getAttribute?.(name);
   return typeof value === "string" && value.length > 0 ? value : void 0;
@@ -2578,7 +2778,7 @@ function draftList(node, ordered) {
     const item = asItem(raw);
     if (!item) continue;
     const line = lineOf(item);
-    const text = flattenInline2(item.getText());
+    const text = inline(item.getText(), line);
     const children = [];
     if (text.length > 0) children.push({ kind: "paragraph", line, text });
     collect(
@@ -2608,7 +2808,7 @@ function admonitionVariant(node) {
 function draftAdmonition(node, variant) {
   const children = draftChildren(node);
   if (children.length === 0) {
-    const text = flattenInline2(node.getContent?.());
+    const text = inline(node.getContent?.(), lineOf(node));
     if (text.length > 0) children.push({ kind: "paragraph", line: lineOf(node), text });
   }
   return { kind: "admonition", line: lineOf(node), variant, children };
@@ -2616,7 +2816,7 @@ function draftAdmonition(node, variant) {
 function draftBlockquote(node) {
   const children = draftChildren(node);
   if (children.length === 0) {
-    const text = flattenInline2(node.getContent?.());
+    const text = inline(node.getContent?.(), lineOf(node));
     if (text.length > 0) children.push({ kind: "paragraph", line: lineOf(node), text });
   }
   return { kind: "blockquote", line: lineOf(node), children };
@@ -2626,10 +2826,10 @@ function draftTable(node) {
   const toRow = (header) => (cells) => ({
     line: cells[0]?.getLineNumber?.() ?? lineOf(node),
     header,
-    cells: cells.map((cell) => ({
-      line: cell.getLineNumber?.() ?? lineOf(node),
-      text: flattenInline2(cell.getText())
-    }))
+    cells: cells.map((cell) => {
+      const line = cell.getLineNumber?.() ?? lineOf(node);
+      return { line, text: inline(cell.getText(), line) };
+    })
   });
   return {
     kind: "table",
@@ -2652,7 +2852,7 @@ function draftDefinitionList(node) {
     const children = [];
     const desc = asItem(rawDesc);
     if (desc) {
-      const text = flattenInline2(desc.getText());
+      const text = inline(desc.getText(), lineOf(desc));
       if (text.length > 0) children.push({ kind: "paragraph", line: lineOf(desc), text });
       collect(
         desc.getBlocks().map(asNode).filter((n) => n !== null),
@@ -2661,7 +2861,7 @@ function draftDefinitionList(node) {
     }
     items.push({
       line: lineOf(first),
-      term: terms.map((t) => flattenInline2(t.getText())).join(", "),
+      term: terms.map((t) => inline(t.getText(), lineOf(t))).join(", "),
       children
     });
   }
@@ -2673,7 +2873,7 @@ function draftOf(node) {
       return {
         kind: "paragraph",
         line: lineOf(node),
-        text: flattenInline2(node.getContent?.())
+        text: inline(node.getContent?.(), lineOf(node))
       };
     case "listing":
     case "literal": {
@@ -2700,7 +2900,7 @@ function draftOf(node) {
     case "image": {
       const url = stringAttribute(node, "target");
       if (!url) return null;
-      const title = flattenInline2(node.getTitle?.());
+      const title = inline(node.getTitle?.(), lineOf(node));
       return {
         kind: "image",
         line: lineOf(node),
@@ -2721,13 +2921,15 @@ function collect(nodes, out) {
   for (const node of nodes) {
     const context = node.getContext();
     if (context === "section") {
+      const id = node.getId?.();
       out.push({
         kind: "heading",
         line: lineOf(node),
         // Asciidoctor's `=` title is level 0, so every level is one shallower
         // than the heading level the rest of the tool speaks in.
         level: (node.getLevel?.() ?? 0) + 1,
-        title: flattenInline2(node.getTitle?.())
+        title: inline(node.getTitle?.(), lineOf(node)),
+        ...id ? { id } : {}
       });
       collect(childrenOf(node), out);
       continue;
@@ -2749,6 +2951,7 @@ function place(drafts, end, index) {
         type: "heading",
         level: draft.level,
         title: draft.title,
+        ...draft.id !== void 0 ? { id: draft.id } : {},
         position: {
           start: index.start(draft.line),
           end: index.endOfLine(draft.line)
@@ -2922,9 +3125,18 @@ function load(content, filePath) {
       // Without this every block's `getLineNumber()` is undefined and there are
       // no positions to derive at all.
       sourcemap: true,
-      // A leading `---` fence is a thematic break in AsciiDoc; this consumes it
-      // as metadata instead, without disturbing line numbering.
-      attributes: { "skip-front-matter": true }
+      // Asciidoctor.js's default already, pinned because it is what keeps
+      // `include::` from reading the disk: a refused include renders as a link
+      // to its target, which `inline` then drops.
+      safe: "secure",
+      attributes: {
+        // A leading `---` fence is a thematic break in AsciiDoc; this consumes
+        // it as metadata instead, without disturbing line numbering.
+        "skip-front-matter": true,
+        // `xref:other.adoc[]` keeps its source suffix rather than becoming
+        // `other.html`, so a harvested link names the file that exists.
+        relfilesuffix: ".adoc"
+      }
     });
   } catch (err) {
     throw new LintError(
@@ -2936,7 +3148,7 @@ function headerDraft(doc) {
   if (!doc.hasHeader()) return null;
   const header = asNode(doc.getHeader());
   if (!header) return null;
-  const title = flattenInline2(header.getTitle?.());
+  const title = inline(header.getTitle?.(), lineOf(header));
   if (title.length === 0) return null;
   return {
     kind: "heading",
@@ -2948,10 +3160,15 @@ function headerDraft(doc) {
 function parse2(content, filePath) {
   const doc = load(content, filePath);
   const index = lineIndex(content);
+  harvested = [];
   const drafts = [];
   const header = headerDraft(doc);
   if (header) drafts.push(header);
   collect(childrenOf(doc), drafts);
+  const links = harvested.sort((a, b) => a.line - b.line).map(({ target, line }) => ({
+    target,
+    position: { start: index.start(line), end: index.endOfLine(line) }
+  }));
   const meta = metadata(content, filePath, index);
   const end = index.documentEnd();
   return {
@@ -2962,7 +3179,8 @@ function parse2(content, filePath) {
     sections: sectionize(
       withMetadataTitle(place(drafts, end, index), meta.data, meta.position),
       end
-    )
+    ),
+    links
   };
 }
 var asciidocParser = {
@@ -3010,6 +3228,9 @@ function parserByName(name) {
 function supportedExtensions() {
   return PARSERS.flatMap((p) => p.walkExtensions ?? p.extensions);
 }
+function unsupportedFormatMessage(name) {
+  return `no parser is registered for "${name}". Supported extensions: ${supportedExtensions().join(", ")}. Use --as to override.`;
+}
 function listFormats() {
   return PARSERS.map((p) => ({
     name: p.name,
@@ -3019,2422 +3240,11 @@ function listFormats() {
   }));
 }
 
-// src/lint/core/template-registry.ts
-import { readFile } from "node:fs/promises";
-import { dirname, isAbsolute, join, resolve as resolvePath } from "node:path";
-import { parse as parseYaml } from "yaml";
-import { dereference } from "@apidevtools/json-schema-ref-parser";
-import * as AjvNs from "ajv";
-
-// schemas/lint/template.json
-var template_default = {
-  $schema: "http://json-schema.org/draft-07/schema#",
-  $id: "manni-lint:template:2",
-  title: "manni lint template file",
-  description: "A template file: named doctype templates, plus the reusable fragments they point at with `$ref`. Validated after dereferencing, so no `$ref` survives to be seen here. A template is itself a rule: it describes the page, and it takes every rule key plus `title`, `types` and `extends`.",
-  type: "object",
-  additionalProperties: false,
-  required: ["templates"],
-  properties: {
-    $schema: {
-      description: "URL of this schema, so an editor can offer completion. Read by editors, never by the linter.",
-      type: "string"
-    },
-    info: {
-      description: "Free-form metadata about the file (title, version, author). Never read by the linter; declared so a file that carries it is not rejected.",
-      type: "object"
-    },
-    templates: {
-      description: "The doctype templates this file defines, keyed by name.",
-      type: "object",
-      additionalProperties: false,
-      patternProperties: {
-        "^[A-Za-z][A-Za-z0-9-_]*$": { $ref: "#/definitions/template" }
-      }
-    },
-    components: {
-      description: "Reusable fragments, targeted by `$ref` from elsewhere in the file. Left unconstrained: a fragment is validated where it is inlined, not where it is declared.",
-      type: "object"
-    }
-  },
-  definitions: {
-    min: {
-      description: "Fewest occurrences. Absent means one. Deliberately carries no JSON Schema `default`, and neither does any other key in this file: Ajv's `useDefaults` would write one in at load time, and a written-in value is indistinguishable from a value the author typed, so it wins the `extends` merge against the parent's real value. The code reads `undefined` instead.",
-      type: "integer",
-      minimum: 0
-    },
-    max: {
-      description: "Most occurrences. Absent is unbounded, so write `max: 1` for exactly once and `max: 0` to forbid. Must be at least `min` where both are written; the loader checks that, because JSON Schema cannot compare two siblings.",
-      type: "integer",
-      minimum: 0
-    },
-    id: {
-      description: "Handle for this rule, unique among its siblings. It appears in messages, and `extends` targets it to replace one inherited rule in place.",
-      type: "string",
-      pattern: "^[A-Za-z][A-Za-z0-9-_]*$"
-    },
-    description: {
-      description: "Prose description of what the rule is for. Never checked.",
-      type: "string"
-    },
-    heading: {
-      description: "The heading of the section this rule describes. Absent means any heading, or none. A string is exact text, a list is one-of, `{ pattern }` is an unanchored regular expression, and `false` means the section has no heading of its own.",
-      oneOf: [
-        { type: "string", minLength: 1 },
-        {
-          type: "array",
-          minItems: 1,
-          items: { type: "string", minLength: 1 }
-        },
-        {
-          type: "object",
-          additionalProperties: false,
-          required: ["pattern"],
-          properties: {
-            pattern: { type: "string", minLength: 1 }
-          }
-        },
-        { const: false }
-      ]
-    },
-    attributes: {
-      description: "Literal attributes the node must carry. A string is the required value; `true` requires the attribute to be present, and `false` requires it to be absent.",
-      type: "object",
-      additionalProperties: {
-        oneOf: [{ type: "string" }, { type: "boolean" }]
-      }
-    },
-    oneOfSequenceOrContains: {
-      description: "A rule says what it holds in order (`sequence`) or in any order (`contains`), never both.",
-      type: "object",
-      not: { required: ["sequence", "contains"] }
-    },
-    noHeadingOnRepeat: {
-      description: "`repeat` groups sibling rules into one repeated unit, so the group has no heading of its own. Put the heading on the first rule inside it.",
-      type: "object",
-      not: { required: ["heading", "repeat"] }
-    },
-    noInstructions: {
-      description: "`instructions` was the language-model hook of doc-structure-lint. manni lint is deterministic and has no model, so a template carrying it is rejected outright rather than silently ignored; the loader turns this into a migration message pointing at manni docevals.",
-      type: "object",
-      not: { required: ["instructions"] }
-    },
-    template: {
-      description: "One doctype template. A template is a rule describing the page itself, so it takes every rule key, plus `title`, `types` and `extends`.",
-      type: "object",
-      additionalProperties: false,
-      allOf: [
-        { $ref: "#/definitions/noInstructions" },
-        { $ref: "#/definitions/oneOfSequenceOrContains" },
-        { $ref: "#/definitions/noHeadingOnRepeat" }
-      ],
-      properties: {
-        title: {
-          description: "Human-readable name for the template, shown by `manni lint templates`.",
-          type: "string"
-        },
-        types: {
-          description: "Doctypes this template serves, matched against a page's `type` frontmatter.",
-          type: "array",
-          items: { type: "string", minLength: 1 }
-        },
-        extends: {
-          description: "Template reference (built-in id, path, or URL, optionally with a `#name` fragment) whose rules this template inherits.",
-          type: "string",
-          minLength: 1
-        },
-        id: { $ref: "#/definitions/id" },
-        description: { $ref: "#/definitions/description" },
-        heading: { $ref: "#/definitions/heading" },
-        repeat: { $ref: "#/definitions/repeat" },
-        min: {
-          description: "Refused on a template: a page is one page. Declared here only so the loader can say that in a sentence, rather than leaving Ajv to report an unexpected key.",
-          type: "integer",
-          minimum: 0
-        },
-        max: {
-          description: "Refused on a template, for the same reason as `min`.",
-          type: "integer",
-          minimum: 0
-        },
-        sequence: { $ref: "#/definitions/sequence" },
-        contains: { $ref: "#/definitions/blockRules" },
-        sections: { $ref: "#/definitions/rules" }
-      }
-    },
-    rule: {
-      description: "One rule. It describes a section of the page, or, with `repeat`, a run of sections matched as one unit.",
-      type: "object",
-      additionalProperties: false,
-      allOf: [
-        { $ref: "#/definitions/noInstructions" },
-        { $ref: "#/definitions/oneOfSequenceOrContains" },
-        { $ref: "#/definitions/noHeadingOnRepeat" }
-      ],
-      properties: {
-        id: { $ref: "#/definitions/id" },
-        description: { $ref: "#/definitions/description" },
-        heading: { $ref: "#/definitions/heading" },
-        repeat: { $ref: "#/definitions/repeat" },
-        min: { $ref: "#/definitions/min" },
-        max: { $ref: "#/definitions/max" },
-        sequence: { $ref: "#/definitions/sequence" },
-        contains: { $ref: "#/definitions/blockRules" },
-        sections: { $ref: "#/definitions/rules" }
-      }
-    },
-    rules: {
-      description: "Rules for the subsections, in document order.",
-      type: "array",
-      items: { $ref: "#/definitions/rule" }
-    },
-    repeat: {
-      description: "Rules matched in order as one unit, repeated by this rule's `min` and `max`.",
-      type: "array",
-      minItems: 1,
-      items: { $ref: "#/definitions/rule" }
-    },
-    sequence: {
-      description: "What the section holds, in order. Each entry is one run of one content kind.",
-      type: "array",
-      minItems: 1,
-      items: {
-        allOf: [
-          { $ref: "#/definitions/blockRules" },
-          { type: "object", maxProperties: 1 }
-        ]
-      }
-    },
-    blockRules: {
-      description: "Block rules, keyed by content kind. The key is plural because it carries a count: the node model says `codeBlock`, a template says `codeBlocks: { min: 1 }`.",
-      type: "object",
-      additionalProperties: false,
-      minProperties: 1,
-      properties: {
-        paragraphs: { $ref: "#/definitions/paragraphs" },
-        codeBlocks: { $ref: "#/definitions/codeBlocks" },
-        lists: { $ref: "#/definitions/lists" },
-        tables: { $ref: "#/definitions/tables" },
-        admonitions: { $ref: "#/definitions/admonitions" },
-        images: { $ref: "#/definitions/images" },
-        blockquotes: { $ref: "#/definitions/counted" },
-        definitionLists: { $ref: "#/definitions/counted" },
-        elements: { $ref: "#/definitions/elements" }
-      }
-    },
-    counted: {
-      description: "A block rule that only counts.",
-      type: "object",
-      additionalProperties: false,
-      properties: {
-        min: { $ref: "#/definitions/min" },
-        max: { $ref: "#/definitions/max" }
-      }
-    },
-    paragraphs: {
-      description: "Paragraph requirements.",
-      type: "object",
-      additionalProperties: false,
-      properties: {
-        min: { $ref: "#/definitions/min" },
-        max: { $ref: "#/definitions/max" },
-        pattern: {
-          description: "Unanchored regular expression every paragraph in the run must match.",
-          type: "string",
-          minLength: 1
-        }
-      }
-    },
-    codeBlocks: {
-      description: "Code block requirements.",
-      type: "object",
-      additionalProperties: false,
-      properties: {
-        min: { $ref: "#/definitions/min" },
-        max: { $ref: "#/definitions/max" },
-        language: {
-          description: "Language every code block must be tagged with, as the node model spells it. A list is one-of: the block must declare one of them.",
-          oneOf: [
-            { type: "string", minLength: 1 },
-            {
-              type: "array",
-              minItems: 1,
-              items: { type: "string", minLength: 1 }
-            }
-          ]
-        },
-        fenceInfo: {
-          description: "Info-string tail after the language, where the format carries one.",
-          type: "string"
-        }
-      }
-    },
-    lists: {
-      description: "List requirements.",
-      type: "object",
-      additionalProperties: false,
-      properties: {
-        min: { $ref: "#/definitions/min" },
-        max: { $ref: "#/definitions/max" },
-        ordered: {
-          description: "Whether the list must be ordered. Absent accepts either.",
-          type: "boolean"
-        },
-        items: { $ref: "#/definitions/listItems" }
-      }
-    },
-    listItems: {
-      description: "Requirements applied to every item of every list in the run. Recurses arbitrarily deep.",
-      type: "object",
-      additionalProperties: false,
-      allOf: [{ $ref: "#/definitions/oneOfSequenceOrContains" }],
-      properties: {
-        min: { $ref: "#/definitions/min" },
-        max: { $ref: "#/definitions/max" },
-        sequence: { $ref: "#/definitions/sequence" },
-        contains: { $ref: "#/definitions/blockRules" }
-      }
-    },
-    tables: {
-      description: "Table requirements.",
-      type: "object",
-      additionalProperties: false,
-      properties: {
-        min: { $ref: "#/definitions/min" },
-        max: { $ref: "#/definitions/max" },
-        columns: {
-          description: "The header cells, in order.",
-          type: "array",
-          items: { type: "string" }
-        }
-      }
-    },
-    admonitions: {
-      description: "Admonition requirements.",
-      type: "object",
-      additionalProperties: false,
-      properties: {
-        min: { $ref: "#/definitions/min" },
-        max: { $ref: "#/definitions/max" },
-        variant: {
-          description: "Which flavor of admonition. The node model's `variant`, not any one format's spelling.",
-          enum: [
-            "note",
-            "tip",
-            "important",
-            "caution",
-            "warning",
-            "danger"
-          ]
-        }
-      }
-    },
-    images: {
-      description: "Image requirements.",
-      type: "object",
-      additionalProperties: false,
-      properties: {
-        min: { $ref: "#/definitions/min" },
-        max: { $ref: "#/definitions/max" },
-        url: {
-          description: "Where the image must point.",
-          type: "string"
-        },
-        alt: {
-          description: "Alternative text the image must carry.",
-          type: "string"
-        },
-        attributes: { $ref: "#/definitions/attributes" }
-      }
-    },
-    elements: {
-      description: "Named-wrapper requirements. `sequence` and `contains` here describe what the element holds, which is never the enclosing section's content.",
-      type: "object",
-      additionalProperties: false,
-      allOf: [{ $ref: "#/definitions/oneOfSequenceOrContains" }],
-      properties: {
-        min: { $ref: "#/definitions/min" },
-        max: { $ref: "#/definitions/max" },
-        tag: {
-          description: "The element's name, as an author of the format would write it. A list is one-of: an element counts when it carries any of them.",
-          oneOf: [
-            { type: "string", minLength: 1 },
-            {
-              type: "array",
-              minItems: 1,
-              items: { type: "string", minLength: 1 }
-            }
-          ]
-        },
-        attributes: { $ref: "#/definitions/attributes" },
-        sequence: { $ref: "#/definitions/sequence" },
-        contains: { $ref: "#/definitions/blockRules" }
-      }
-    }
-  }
-};
-
-// templates/lint/tgdp/manifest.json
-var manifest_default = {
-  $comment: 'Built-in doctype templates derived from The Good Docs Project templates, pinned to release v1.6.0 ("Iron"): https://gitlab.com/tgdp/templates/-/tree/v1.6.0. Each entry\'s `file` is a YAML template beside this manifest; `source` is the upstream Markdown it was derived from, vendored under test/lint/fixtures/tgdp/ and linted against the derived template so the two cannot drift. Run `npm run check:tgdp-pin` to see whether upstream has moved past the pin.',
-  vendor: "tgdp",
-  upstream: "https://gitlab.com/tgdp/templates",
-  pin: "v1.6.0",
-  templates: [
-    {
-      id: "tgdp:how-to:1.6",
-      file: "tgdp/how-to.yaml",
-      title: "How-to guide (The Good Docs Project)",
-      types: ["how-to"],
-      source: "how-to/template_how-to.md"
-    },
-    {
-      id: "tgdp:tutorial:1.6",
-      file: "tgdp/tutorial.yaml",
-      title: "Tutorial (The Good Docs Project)",
-      types: ["tutorial"],
-      source: "tutorial/template_tutorial.md"
-    },
-    {
-      id: "tgdp:reference:1.6",
-      file: "tgdp/reference.yaml",
-      title: "Reference (The Good Docs Project)",
-      types: ["reference"],
-      source: "reference/template_reference.md"
-    },
-    {
-      id: "tgdp:concept:1.6",
-      file: "tgdp/concept.yaml",
-      title: "Concept (The Good Docs Project)",
-      types: ["concept", "explanation"],
-      source: "concept/template_concept.md"
-    },
-    {
-      id: "tgdp:troubleshooting:1.6",
-      file: "tgdp/troubleshooting.yaml",
-      title: "Troubleshooting (The Good Docs Project)",
-      types: ["troubleshooting"],
-      source: "troubleshooting/template_troubleshooting.md"
-    },
-    {
-      id: "tgdp:release-notes:1.6",
-      file: "tgdp/release-notes.yaml",
-      title: "Release notes (The Good Docs Project)",
-      types: ["release-notes"],
-      source: "release-notes/template_release-notes.md"
-    },
-    {
-      id: "tgdp:readme:1.6",
-      file: "tgdp/readme.yaml",
-      title: "README (The Good Docs Project)",
-      types: ["readme"],
-      source: "readme/template_readme.md"
-    }
-  ]
-};
-
-// src/lint/core/template-registry.ts
-var Ajv = AjvNs.default;
-var DEREFERENCE_OPTIONS = { resolve: { external: false } };
-var MANIFESTS = [manifest_default];
-var BUILTINS = /* @__PURE__ */ new Map();
-for (const manifest of MANIFESTS) {
-  for (const entry of manifest.templates) BUILTINS.set(entry.id, entry);
-}
-var builtinCache = /* @__PURE__ */ new Map();
-function listBuiltins() {
-  return [...BUILTINS.values()].map((entry) => ({
-    id: entry.id,
-    title: entry.title,
-    types: entry.types
-  }));
-}
-async function readBuiltinFile(id, file) {
-  const path = join(packageRoot(import.meta.url), "templates", "lint", file);
-  try {
-    return await readFile(path, "utf8");
-  } catch (err) {
-    throw new LintError(
-      `Built-in template "${id}" is registered but its file could not be read (${path}): ${errorMessage(err)}`
-    );
-  }
-}
-async function loadBuiltin(id) {
-  const cached = builtinCache.get(id);
-  if (cached) return cached;
-  const entry = BUILTINS.get(id);
-  if (!entry) {
-    throw new LintError(`No built-in template is registered under "${id}".`);
-  }
-  const raw = await readBuiltinFile(id, entry.file);
-  const parsed = parseYaml(raw);
-  if (!isRecord(parsed)) {
-    throw new LintError(
-      `Built-in template "${id}" (${entry.file}) is not a template file: expected an object at the top level, got ${parsed === null ? "null" : Array.isArray(parsed) ? "an array" : typeof parsed}.`
-    );
-  }
-  const file = validateTemplateFile(
-    await dereference(parsed, DEREFERENCE_OPTIONS),
-    entry.file
-  );
-  const names = Object.keys(file.templates ?? {});
-  const template = file.templates?.[names[0] ?? ""];
-  if (!template || names.length !== 1) {
-    throw new LintError(
-      `Built-in template "${id}" must define exactly one template, found ${names.length}.`
-    );
-  }
-  const resolved = { types: entry.types, ...template };
-  builtinCache.set(id, resolved);
-  return resolved;
-}
-var BUILTIN_ID = /^[a-z0-9][a-z0-9._-]*(?::[a-z0-9][a-z0-9._-]*)+$/i;
-var FILE_EXTENSIONS = [".yaml", ".yml", ".json"];
-function classifyRef(ref) {
-  if (/^https?:\/\//i.test(ref)) return { kind: "url", ref };
-  const lower2 = ref.toLowerCase();
-  if (!ref.includes("/") && !ref.includes("\\") && !FILE_EXTENSIONS.some((ext) => lower2.endsWith(ext)) && BUILTIN_ID.test(ref)) {
-    return { kind: "builtin", ref };
-  }
-  return { kind: "file", ref };
-}
-var DEFAULT_TIMEOUT_MS = 1e4;
-var ajv = new Ajv();
-var compiled = null;
-function fileValidator() {
-  compiled ??= ajv.compile(template_default);
-  return compiled;
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function stringsOf(value) {
-  if (typeof value === "string") return [value];
-  if (Array.isArray(value)) return value.filter((v) => typeof v === "string");
-  return [];
-}
-function suggestEvalName(segments) {
-  const name = segments.filter((segment) => segment !== "templates" && segment !== "sections").join("-").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
-  return name || "section-instructions";
-}
-function findInstructions(node, segments = [], seen = /* @__PURE__ */ new WeakSet()) {
-  if (typeof node !== "object" || node === null) return null;
-  if (seen.has(node)) return null;
-  seen.add(node);
-  if (Array.isArray(node)) {
-    for (const [index, item] of node.entries()) {
-      const hit = findInstructions(item, [...segments, String(index)], seen);
-      if (hit) return hit;
-    }
-    return null;
-  }
-  const record = node;
-  const insideSectionsMap = segments.at(-1) === "sections";
-  if (!insideSectionsMap && "instructions" in record) {
-    return {
-      path: segments.join("."),
-      name: suggestEvalName(segments),
-      values: stringsOf(record.instructions)
-    };
-  }
-  for (const [key, value] of Object.entries(record)) {
-    const hit = findInstructions(value, [...segments, key], seen);
-    if (hit) return hit;
-  }
-  return null;
-}
-function instructionsMessage(source, hit) {
-  const assertion = hit.values[0] ?? "";
-  return [
-    `${source}: "${hit.path}" uses \`instructions\`, which manni lint no longer evaluates \u2014 structure checking is deterministic. Move it to a manni docevals assertion eval in manni.config.yaml:`,
-    "",
-    "  docevals:",
-    "    evals:",
-    `      ${hit.name}:`,
-    `        assertion: ${assertion}`,
-    "        grader: ai"
-  ].join("\n");
-}
-var V1_KEYS = {
-  required: '"required" is not a template key. A rule is optional with "min: 0".',
-  additionalSections: '"additionalSections" is not a template key. v2 has no equivalent, so drop it.',
-  code_blocks: '"code_blocks" is not a template key. The v2 spelling is "codeBlocks".'
-};
-var V1_SECTIONS_MAP = '"sections" is a list of rules, not a map. Name each rule with "id" and list them in order.';
-var V1_REPEAT_BOOLEAN = '"repeat" is a list of rules, not a boolean. A rule repeats through "min" and "max".';
-var V1_PARAGRAPH_PATTERNS = '"patterns" is not a paragraphs key. The v2 spelling is "pattern", one regular expression.';
-function findV1Key(node, seen = /* @__PURE__ */ new WeakSet()) {
-  if (typeof node !== "object" || node === null) return null;
-  if (seen.has(node)) return null;
-  seen.add(node);
-  if (Array.isArray(node)) {
-    for (const item of node) {
-      const hit = findV1Key(item, seen);
-      if (hit) return hit;
-    }
-    return null;
-  }
-  const record = node;
-  for (const [key, message] of Object.entries(V1_KEYS)) {
-    if (key in record) return message;
-  }
-  if (isRecord(record.sections)) return V1_SECTIONS_MAP;
-  if (typeof record.repeat === "boolean") return V1_REPEAT_BOOLEAN;
-  if (isRecord(record.paragraphs) && "patterns" in record.paragraphs) {
-    return V1_PARAGRAPH_PATTERNS;
-  }
-  for (const value of Object.values(record)) {
-    const hit = findV1Key(value, seen);
-    if (hit) return hit;
-  }
-  return null;
-}
-function findV1File(data) {
-  if (!isRecord(data)) return null;
-  return findV1Key(data.templates) ?? findV1Key(data.components);
-}
-function ruleLabel(rule, path) {
-  return rule.id === void 0 ? path : `"${rule.id}"`;
-}
-function checkRange(range, source, label) {
-  const { min, max } = range;
-  if (min !== void 0 && max !== void 0 && max < min) {
-    throw new LintError(`${source}: rule ${label} sets max ${max} below min ${min}.`);
-  }
-}
-function sameOccurrenceRange(a, b) {
-  const rangeA = occurrenceRange(a);
-  const rangeB = occurrenceRange(b);
-  return rangeA.min === rangeB.min && rangeA.max === rangeB.max;
-}
-function checkPattern(pattern, source) {
-  if (pattern === void 0) return;
-  try {
-    new RegExp(pattern);
-  } catch (err) {
-    throw new LintError(
-      `Invalid pattern "${pattern}" in ${source}: ${errorMessage(err)}.`
-    );
-  }
-}
-function checkListItems(items, source, path) {
-  checkRange(items, source, path);
-  if (items.contains) checkBlockRule(items.contains, source, `${path}.contains`);
-  items.sequence?.forEach((entry, index) => {
-    checkBlockRule(entry, source, `${path}.sequence[${index}]`);
-  });
-}
-function checkBlockRule(block, source, path) {
-  for (const kind of BLOCK_KINDS) {
-    const counted = block[kind];
-    if (counted) checkRange(counted, source, `${path}.${kind}`);
-  }
-  checkPattern(block.paragraphs?.pattern, source);
-  if (block.lists?.items) {
-    checkListItems(block.lists.items, source, `${path}.lists.items`);
-  }
-  const element = block.elements;
-  if (element?.contains) {
-    checkBlockRule(element.contains, source, `${path}.elements.contains`);
-  }
-  element?.sequence?.forEach((entry, index) => {
-    checkBlockRule(entry, source, `${path}.elements.sequence[${index}]`);
-  });
-}
-function checkRuleBody(rule, source, path) {
-  const heading = rule.heading;
-  if (typeof heading === "object" && !Array.isArray(heading)) {
-    checkPattern(heading.pattern, source);
-  }
-  if (rule.contains) checkBlockRule(rule.contains, source, `${path}.contains`);
-  rule.sequence?.forEach((entry, index) => {
-    checkBlockRule(entry, source, `${path}.sequence[${index}]`);
-  });
-  checkRuleList(rule.repeat, source, `${path}.repeat`);
-  checkRuleList(rule.sections, source, `${path}.sections`);
-}
-function checkRuleList(rules, source, path) {
-  if (!rules) return;
-  const ids = /* @__PURE__ */ new Set();
-  for (const [index, rule] of rules.entries()) {
-    const here = `${path}[${index}]`;
-    if (rule.id !== void 0) {
-      if (ids.has(rule.id)) {
-        throw new LintError(`${source}: two sibling rules share the id "${rule.id}".`);
-      }
-      ids.add(rule.id);
-    }
-    checkRange(rule, source, ruleLabel(rule, here));
-    checkRuleBody(rule, source, here);
-  }
-  for (const [index, rule] of rules.entries()) {
-    const next = rules[index + 1];
-    if (!next) break;
-    if (isWildcard(rule) && rule.repeat === void 0 && isWildcard(next) && next.repeat === void 0 && sameOccurrenceRange(rule, next)) {
-      warn(
-        `${source}: two adjacent rules have no heading and no repeat; only rule order tells them apart.`
-      );
-      break;
-    }
-  }
-}
-function checkTemplateFile(file, source) {
-  for (const [name, template] of Object.entries(file.templates ?? {})) {
-    if (template.min !== void 0 || template.max !== void 0) {
-      throw new LintError(
-        `${source}: a template may not set min or max; a page is one page.`
-      );
-    }
-    checkRuleBody(template, source, `templates.${name}`);
-  }
-}
-var NOT_CONSTRAINTS = {
-  oneOfSequenceOrContains: "sets both sequence and contains; a rule says what it holds in order, or in any order, never both",
-  noHeadingOnRepeat: "sets both heading and repeat; a repeat group has no heading of its own, so put the heading on the first rule inside it",
-  noInstructions: "carries an instructions key, which this tool does not read"
-};
-function describeError(error) {
-  const where = error.instancePath || "/";
-  if (error.keyword === "not") {
-    for (const [name, why] of Object.entries(NOT_CONSTRAINTS)) {
-      if (error.schemaPath.includes(name)) return `${where} ${why}`;
-    }
-  }
-  const params = error.params;
-  const extra = typeof params.additionalProperty === "string" ? ` ("${params.additionalProperty}")` : "";
-  return `${where} ${error.message ?? "is invalid"}${extra}`;
-}
-function validateTemplateFile(data, source) {
-  const instructions = findInstructions(data);
-  if (instructions) throw new LintError(instructionsMessage(source, instructions));
-  const v1 = findV1File(data);
-  if (v1) throw new LintError(`${source}: ${v1}`);
-  const validate = fileValidator();
-  if (!validate(data)) {
-    const errors = validate.errors ?? [];
-    const detail = errors.map(describeError).join("; ") || "does not match the template schema";
-    throw new LintError(`${source} is not a valid template file: ${detail}.`);
-  }
-  const file = data;
-  checkTemplateFile(file, source);
-  return file;
-}
-function splitFragment(ref) {
-  const hash = ref.lastIndexOf("#");
-  if (hash === -1) return { base: ref, fragment: null };
-  return { base: ref.slice(0, hash), fragment: ref.slice(hash + 1) || null };
-}
-function extensionSource(ref, kind) {
-  if (kind !== "url") return ref;
-  try {
-    return new URL(ref).pathname;
-  } catch {
-    return ref;
-  }
-}
-function parseTemplateFile(raw, source, kind) {
-  const lower2 = extensionSource(source, kind).toLowerCase();
-  if (lower2.endsWith(".json")) {
-    try {
-      return JSON.parse(raw);
-    } catch (err) {
-      throw new LintError(`${source} is not valid JSON: ${errorMessage(err)}`);
-    }
-  }
-  try {
-    return parseYaml(raw);
-  } catch (err) {
-    throw new LintError(`${source} is not valid YAML: ${errorMessage(err)}`);
-  }
-}
-async function readText(ref) {
-  try {
-    return await readFile(ref, "utf8");
-  } catch (err) {
-    const code = err?.code;
-    if (code === "ENOENT") {
-      throw new LintError(`Template file not found: "${ref}".`);
-    }
-    throw new LintError(
-      `Template file "${ref}" could not be read: ${errorMessage(err)}`
-    );
-  }
-}
-var urlCache = /* @__PURE__ */ new Map();
-function clearTemplateCaches() {
-  builtinCache.clear();
-  urlCache.clear();
-}
-async function fetchText(ref, timeoutMs) {
-  let res;
-  try {
-    res = await fetch(ref, { signal: AbortSignal.timeout(timeoutMs) });
-  } catch (err) {
-    const e = err;
-    if (e.name === "TimeoutError" || e.name === "AbortError") {
-      throw new LintError(
-        `Failed to fetch template file "${ref}": timed out after ${timeoutMs}ms.`
-      );
-    }
-    throw new LintError(`Failed to fetch template file "${ref}": ${e.message}`);
-  }
-  if (!res.ok) {
-    throw new LintError(`Failed to fetch template file "${ref}": HTTP ${res.status}.`);
-  }
-  return await res.text();
-}
-async function dereferenceTemplates(data, source) {
-  try {
-    return await dereference(data, DEREFERENCE_OPTIONS);
-  } catch (err) {
-    throw new LintError(`${source}: could not resolve a "$ref": ${errorMessage(err)}`);
-  }
-}
-async function loadTemplateFile(ref, options = {}) {
-  const { kind } = classifyRef(ref);
-  if (kind === "builtin") {
-    throw new LintError(
-      `"${ref}" is a built-in template id, not a template file. Load it with loadTemplate().`
-    );
-  }
-  const cached = kind === "url" ? urlCache.get(ref) : void 0;
-  if (cached) return cached;
-  const raw = kind === "url" ? await fetchText(ref, options.timeoutMs ?? DEFAULT_TIMEOUT_MS) : await readText(ref);
-  const parsed = parseTemplateFile(raw, ref, kind);
-  if (!isRecord(parsed)) {
-    throw new LintError(
-      `${ref} is not a template file: expected an object at the top level, got ${parsed === null ? "null" : Array.isArray(parsed) ? "an array" : typeof parsed}.`
-    );
-  }
-  const file = validateTemplateFile(await dereferenceTemplates(parsed, ref), ref);
-  if (kind === "url") urlCache.set(ref, file);
-  return file;
-}
-async function loadTemplate(ref, options = {}) {
-  const { base, fragment } = splitFragment(ref);
-  const { kind } = classifyRef(base);
-  if (kind === "builtin") {
-    if (fragment !== null) {
-      throw new LintError(
-        `"${ref}" adds a "#${fragment}" fragment to a built-in template id. A built-in id names one template on its own - drop the fragment and use "${base}". Fragments name a template inside a file, as in "./templates.yaml#how-to".`
-      );
-    }
-    if (!BUILTINS.has(base)) {
-      const available = [...BUILTINS.keys()].join(", ");
-      throw new LintError(
-        `Unknown built-in template "${base}". Available: ${available || "(none)"}.`
-      );
-    }
-    return loadBuiltin(base);
-  }
-  const file = await loadTemplateFile(base, options);
-  const templates = file.templates ?? {};
-  const names = Object.keys(templates);
-  if (fragment !== null) {
-    const named = Object.hasOwn(templates, fragment) ? templates[fragment] : void 0;
-    if (named === void 0) {
-      throw new LintError(
-        `${base} has no template named "${fragment}". Available: ${names.join(", ") || "(none)"}.`
-      );
-    }
-    return named;
-  }
-  const [only] = Object.values(templates);
-  if (names.length === 1 && only !== void 0) return only;
-  if (names.length === 0) throw new LintError(`${base} defines no templates.`);
-  throw new LintError(
-    `${base} defines ${names.length} templates; name one with a "#" fragment (e.g. "${base}#${names[0] ?? ""}"). Available: ${names.join(", ")}.`
-  );
-}
-function mergeRuleLists(parent, child) {
-  if (!parent) return child;
-  if (!child) return parent;
-  const merged = [...parent];
-  for (const childRule of child) {
-    const id = childRule.id;
-    const index = id === void 0 ? -1 : merged.findIndex((rule) => rule.id === id);
-    const target = index === -1 ? void 0 : merged[index];
-    if (target === void 0) merged.push(childRule);
-    else merged[index] = mergeRules(target, childRule);
-  }
-  return merged;
-}
-function mergeRules(parent, child) {
-  const sections = mergeRuleLists(parent.sections, child.sections);
-  const { sections: _parentSections, ...parentRest } = parent;
-  const { sections: _childSections, ...childRest } = child;
-  const merged = { ...parentRest, ...childRest };
-  if (sections !== void 0) merged.sections = sections;
-  return merged;
-}
-function mergeTemplates(parent, child) {
-  const sections = mergeRuleLists(parent.sections, child.sections);
-  const { sections: _parentSections, ...parentRest } = parent;
-  const { sections: _childSections, ...childRest } = child;
-  const merged = { ...parentRest, ...childRest };
-  if (sections !== void 0) merged.sections = sections;
-  delete merged.extends;
-  return merged;
-}
-async function resolveExtends(template, load2 = loadTemplate, chain = []) {
-  const parentRef = template.extends;
-  if (parentRef === void 0) return template;
-  if (chain.includes(parentRef)) {
-    throw new LintError(
-      `Template "extends" cycle: ${[...chain, parentRef].join(" -> ")}.`
-    );
-  }
-  const parent = await resolveExtends(await load2(parentRef), load2, [...chain, parentRef]);
-  return mergeTemplates(parent, template);
-}
-function refRelativeTo(baseRef, ref) {
-  const { base, fragment } = splitFragment(ref);
-  if (classifyRef(base).kind !== "file" || isAbsolute(base)) return ref;
-  const { base: fromBase } = splitFragment(baseRef);
-  const from = classifyRef(fromBase).kind;
-  if (from === "url") {
-    const rebased2 = new URL(base, fromBase).href;
-    return fragment === null ? rebased2 : `${rebased2}#${fragment}`;
-  }
-  if (from !== "file") return ref;
-  const rebased = resolvePath(dirname(fromBase), base);
-  return fragment === null ? rebased : `${rebased}#${fragment}`;
-}
-async function loadResolvedTemplate(ref, options = {}, chain = []) {
-  const seen = chain.length === 0 ? [ref] : chain;
-  const template = await loadTemplate(ref, options);
-  const parentRef = template.extends;
-  if (parentRef === void 0) return template;
-  const absolute = refRelativeTo(ref, parentRef);
-  if (seen.includes(absolute)) {
-    throw new LintError(
-      `Template "extends" cycle: ${[...seen, absolute].join(" -> ")}.`
-    );
-  }
-  const parent = await loadResolvedTemplate(absolute, options, [
-    ...seen,
-    absolute
-  ]);
-  return mergeTemplates(parent, template);
-}
-
-// src/lint/core/resolve-template.ts
-import picomatch from "picomatch";
-var FILE_TEMPLATE_KEY = "$template";
-var TYPE_KEY = "type";
-function buildTypeIndex(params) {
-  const index = /* @__PURE__ */ new Map();
-  for (const builtin of params.builtins ?? []) {
-    for (const type of builtin.types) {
-      index.set(type, { ref: builtin.id, source: "builtin" });
-    }
-  }
-  for (const { ref, file } of params.userFiles ?? []) {
-    for (const [name, template] of Object.entries(file.templates ?? {})) {
-      for (const type of template.types ?? []) {
-        index.set(type, { ref: `${ref}#${name}`, source: "user" });
-      }
-    }
-  }
-  for (const [type, ref] of Object.entries(params.explicitTypes ?? {})) {
-    index.set(type, { ref, source: "config" });
-  }
-  return index;
-}
-var matcherCache = /* @__PURE__ */ new Map();
-function clearMatcherCache() {
-  matcherCache.clear();
-}
-function matchesGlob(glob, filePath) {
-  let m = matcherCache.get(glob);
-  if (!m) {
-    m = picomatch(glob, { dot: true });
-    matcherCache.set(glob, m);
-  }
-  return m(filePath.replace(/\\/g, "/"));
-}
-function suggestTypes(unknown, known) {
-  const target = unknown.toLowerCase();
-  const scored = [];
-  for (const type of known) {
-    const distance = editDistance(target, type.toLowerCase());
-    const threshold = target.length <= 4 ? 1 : 3;
-    if (distance <= threshold) scored.push({ type, distance });
-  }
-  return scored.sort((a, b) => a.distance - b.distance || a.type.localeCompare(b.type)).slice(0, 3).map((s) => s.type);
-}
-function editDistance(a, b) {
-  if (a === b) return 0;
-  let prev = Array.from({ length: b.length + 1 }, (_, i) => i);
-  let last = b.length;
-  for (let i = 0; i < a.length; i++) {
-    const row = [i + 1];
-    let left = i + 1;
-    let diagonal = i;
-    for (const [j, above] of prev.slice(1).entries()) {
-      const cost = a.charCodeAt(i) === b.charCodeAt(j) ? 0 : 1;
-      const cell = Math.min(left + 1, above + 1, diagonal + cost);
-      row.push(cell);
-      diagonal = above;
-      left = cell;
-    }
-    prev = row;
-    last = left;
-  }
-  return last;
-}
-function refFromFrontmatter(frontmatter, key) {
-  const value = frontmatter?.[key];
-  return typeof value === "string" && value.length > 0 ? value : null;
-}
-function resolveTemplateRef(params) {
-  const steps = [];
-  const typeIndex = params.typeIndex ?? /* @__PURE__ */ new Map();
-  const decide = (stage, ref) => ({
-    ref,
-    stage,
-    steps
-  });
-  if (params.cliTemplate) {
-    steps.push({ stage: "cli", ref: params.cliTemplate, detail: "--template" });
-    return decide("cli", params.cliTemplate);
-  }
-  steps.push({ stage: "cli", ref: null, detail: "--template not given" });
-  const fileTemplate = refFromFrontmatter(params.frontmatter, FILE_TEMPLATE_KEY);
-  if (fileTemplate) {
-    steps.push({
-      stage: "frontmatter-template",
-      ref: fileTemplate,
-      detail: `${FILE_TEMPLATE_KEY} in frontmatter`
-    });
-    return decide("frontmatter-template", fileTemplate);
-  }
-  steps.push({
-    stage: "frontmatter-template",
-    ref: null,
-    detail: `no ${FILE_TEMPLATE_KEY} in frontmatter`
-  });
-  for (const override of params.overrides ?? []) {
-    if (matchesGlob(override.files, params.filePath) || params.absolutePath !== void 0 && matchesGlob(override.files, params.absolutePath)) {
-      steps.push({
-        stage: "config-override",
-        ref: override.template,
-        detail: `matched override "${override.files}"`
-      });
-      return decide("config-override", override.template);
-    }
-  }
-  steps.push({
-    stage: "config-override",
-    ref: null,
-    detail: (params.overrides ?? []).length ? "no override glob matched" : "no overrides configured"
-  });
-  const type = refFromFrontmatter(params.frontmatter, TYPE_KEY);
-  if (type) {
-    const entry = typeIndex.get(type);
-    if (entry) {
-      steps.push({
-        stage: "type",
-        ref: entry.ref,
-        detail: `type: ${type} -> ${entry.source} template`
-      });
-      return decide("type", entry.ref);
-    }
-    steps.push({
-      stage: "type",
-      ref: null,
-      detail: `type: ${type} matches no template`
-    });
-    return {
-      ref: null,
-      stage: null,
-      cause: "unknown-type",
-      unknownType: type,
-      suggestions: suggestTypes(type, typeIndex.keys()),
-      knownTypes: knownTypes(typeIndex),
-      steps
-    };
-  }
-  steps.push({ stage: "type", ref: null, detail: "no type in frontmatter" });
-  if (params.defaultTemplate) {
-    steps.push({
-      stage: "config-default",
-      ref: params.defaultTemplate,
-      detail: "config default"
-    });
-    return decide("config-default", params.defaultTemplate);
-  }
-  steps.push({ stage: "config-default", ref: null, detail: "no default configured" });
-  return { ref: null, stage: null, cause: "no-type", steps };
-}
-function knownTypes(index) {
-  return [...index.keys()].sort();
-}
-
-// src/lint/core/validator.ts
-function origin2() {
-  return {
-    start: { line: 1, column: 1, offset: 0 },
-    end: { line: 1, column: 1, offset: 0 }
-  };
-}
-function span(sections) {
-  const first = sections[0];
-  const last = sections[sections.length - 1];
-  if (!first || !last) return origin2();
-  return { start: { ...first.position.start }, end: { ...last.position.end } };
-}
-function pageSection(tree) {
-  const [only] = tree.sections;
-  if (tree.sections.length === 1 && only && only.level <= 1) return only;
-  return {
-    slug: "",
-    title: "",
-    level: 0,
-    order: 0,
-    parentSlug: null,
-    titlePosition: null,
-    position: span(tree.sections),
-    children: [],
-    sections: tree.sections
-  };
-}
-var BLOCK_NOUNS = {
-  paragraphs: "paragraphs",
-  codeBlocks: "code blocks",
-  lists: "lists",
-  tables: "tables",
-  admonitions: "admonitions",
-  images: "images",
-  blockquotes: "blockquotes",
-  definitionLists: "definition lists",
-  elements: "elements"
-};
-var Pruner = class {
-  emitted;
-  /** Keyed by message, so one rule asked twice is reported once. */
-  missing = /* @__PURE__ */ new Map();
-  constructor(kinds) {
-    this.emitted = new Set(kinds);
-  }
-  get gaps() {
-    return [...this.missing.values()];
-  }
-  emits(kind) {
-    return this.emitted.has(kind);
-  }
-  drop(rule, noun) {
-    this.missing.set(`${rule}: ${noun}`, { rule, noun });
-  }
-  /** A table rule without its `columns`, when the parser reports no cells. */
-  tables(rule) {
-    if (rule.columns === void 0 || this.emits("tableCell")) return rule;
-    this.drop("columns", "table columns");
-    const { columns: _columns, ...kept } = rule;
-    return kept;
-  }
-  /**
-   * A list rule with its `items` pruned.
-   *
-   * `items` has no capability of its own to check. A parser that reports a
-   * list reports its items, since `ListNode.items` is not optional, and
-   * `listItem` is not one of the `BLOCK_KINDS` a block rule can target. So
-   * the `lists` gap covers the whole rule, and only what the items *hold* can
-   * go unchecked.
-   *
-   * `listItem` is a `ContentKind` and parsers do declare it. That is a fact
-   * about the node model rather than about this pruner: a template names
-   * `lists`, and reaches an item only through `items`, so there is no rule
-   * whose capability would be `listItem` on its own.
-   */
-  lists(rule) {
-    const items = rule.items;
-    if (items === void 0) return rule;
-    const pruned = this.listItems(items);
-    return pruned === items ? rule : { ...rule, items: pruned };
-  }
-  listItems(rule) {
-    return this.holder(rule);
-  }
-  elements(rule) {
-    return this.holder(rule);
-  }
-  /** The `sequence`/`contains` pair every content holder carries. */
-  holder(rule) {
-    const kept = { ...rule };
-    let changed = false;
-    if (rule.sequence) {
-      const sequence = this.sequence(rule.sequence);
-      if (sequence === void 0) {
-        delete kept.sequence;
-        changed = true;
-      } else if (sequence !== rule.sequence) {
-        kept.sequence = sequence;
-        changed = true;
-      }
-    }
-    if (rule.contains) {
-      const contains = this.block(rule.contains);
-      if (contains === void 0) {
-        delete kept.contains;
-        changed = true;
-      } else if (contains !== rule.contains) {
-        kept.contains = contains;
-        changed = true;
-      }
-    }
-    return changed ? kept : rule;
-  }
-  /**
-   * One `sequence`, with the runs this format cannot see taken out.
-   *
-   * Taking the entry out rather than leaving it empty is what keeps the rest of
-   * the sequence meaningful: a run of a kind the parser never emits can never
-   * appear among the actual runs, so an entry left standing would report an
-   * order error on every file of that format. `undefined` means the key goes.
-   */
-  sequence(entries) {
-    const kept = [];
-    let changed = false;
-    for (const entry of entries) {
-      const pruned = this.block(entry);
-      if (pruned === void 0) {
-        changed = true;
-        continue;
-      }
-      if (pruned !== entry) changed = true;
-      kept.push(pruned);
-    }
-    if (!changed) return entries;
-    return kept.length > 0 ? kept : void 0;
-  }
-  /** One block rule, or `undefined` when nothing in it can be checked. */
-  block(block) {
-    const kept = { ...block };
-    let changed = false;
-    for (const key of BLOCK_KINDS) {
-      if (kept[key] === void 0) continue;
-      if (this.emits(BLOCK_KIND_NODE[key])) continue;
-      this.drop(key, BLOCK_NOUNS[key]);
-      Object.assign(kept, { [key]: void 0 });
-      changed = true;
-    }
-    const tables = kept.tables;
-    if (tables) {
-      const pruned = this.tables(tables);
-      if (pruned !== tables) {
-        kept.tables = pruned;
-        changed = true;
-      }
-    }
-    const lists = kept.lists;
-    if (lists) {
-      const pruned = this.lists(lists);
-      if (pruned !== lists) {
-        kept.lists = pruned;
-        changed = true;
-      }
-    }
-    const elements = kept.elements;
-    if (elements) {
-      const pruned = this.elements(elements);
-      if (pruned !== elements) {
-        kept.elements = pruned;
-        changed = true;
-      }
-    }
-    if (!changed) return block;
-    return BLOCK_KINDS.some((key) => kept[key] !== void 0) ? kept : void 0;
-  }
-  rules(rules) {
-    const kept = [];
-    let changed = false;
-    for (const rule of rules) {
-      const pruned = this.rule(rule);
-      if (pruned !== rule) changed = true;
-      kept.push(pruned);
-    }
-    return changed ? kept : rules;
-  }
-  rule(rule) {
-    const kept = this.holder(rule);
-    let changed = kept !== rule;
-    const out = changed ? kept : { ...rule };
-    if (rule.repeat) {
-      const repeat = this.rules(rule.repeat);
-      if (repeat !== rule.repeat) {
-        out.repeat = repeat;
-        changed = true;
-      }
-    }
-    if (rule.sections) {
-      const sections = this.rules(rule.sections);
-      if (sections !== rule.sections) {
-        out.sections = sections;
-        changed = true;
-      }
-    }
-    return changed ? out : rule;
-  }
-};
-var pruneCache = /* @__PURE__ */ new WeakMap();
-function prune(template, kinds) {
-  const key = [...kinds].sort().join(",");
-  let byKinds = pruneCache.get(template);
-  if (!byKinds) {
-    byKinds = /* @__PURE__ */ new Map();
-    pruneCache.set(template, byKinds);
-  }
-  const hit = byKinds.get(key);
-  if (hit) return hit;
-  const pruner = new Pruner(kinds);
-  const pruned = { template: pruner.rule(template), gaps: pruner.gaps };
-  byKinds.set(key, pruned);
-  return pruned;
-}
-function uncheckedFinding(format, name, gap) {
-  return {
-    type: "unsupported_content_kind",
-    heading: null,
-    message: `The ${format} parser does not report ${gap.noun}, so the "${gap.rule}" rule in template "${name}" is not checked for this file.`,
-    position: origin2(),
-    // A warning, because nothing about the document is wrong: the rule asks
-    // about something this format cannot express. It never changes the exit
-    // code - `runLint` counts a file as failed only on an error-severity
-    // finding - so a docset of mixed formats stays green while still saying
-    // which rules went unchecked, and where.
-    severity: "warning"
-  };
-}
-function checkSection(section, rule) {
-  return [
-    ...checkHeading(section, rule.heading),
-    ...checkSequence(section, rule.sequence),
-    ...checkContains(section, rule.contains)
-  ];
-}
-function validateSections(sections, rules, options = {}) {
-  const { matches, findings } = matchSections(sections, rules, options);
-  const all = [...findings];
-  for (const match of matches) {
-    all.push(...checkSection(match.section, match.rule));
-    all.push(
-      ...validateSections(match.section.sections, match.rule.sections, {
-        ...options,
-        parent: match.section
-      })
-    );
-  }
-  return all;
-}
-function validateDocument(tree, template, options = {}) {
-  const kinds = options.kinds ?? parserByName(tree.format)?.kinds ?? [];
-  const pruned = prune(template, kinds);
-  const rules = pruned.template;
-  const name = options.template ?? template.title ?? "unnamed";
-  const findings = pruned.gaps.map(
-    (gap) => uncheckedFinding(tree.format, name, gap)
-  );
-  const page = pageSection(tree);
-  const ctx = {
-    heading: page.title || null,
-    position: page.position
-  };
-  findings.push(...checkHeading(page, rules.heading));
-  findings.push(...checkSequenceIn(page.children, rules.sequence, ctx));
-  findings.push(...checkContainsIn(page.children, rules.contains, ctx));
-  findings.push(
-    ...validateSections(page.sections, rules.sections, {
-      parent: page,
-      source: options.source,
-      template: options.template
-    })
-  );
-  return findings.sort(
-    (a, b) => a.position.start.offset - b.position.start.offset
-  );
-}
-
-// src/lint/core/config.ts
-import { dirname as dirname2, isAbsolute as isAbsolute2, resolve } from "node:path";
-import { parse as parseYaml2 } from "yaml";
-import * as AjvNs2 from "ajv";
-
-// schemas/lint/config.json
-var config_default = {
-  $schema: "http://json-schema.org/draft-07/schema#",
-  $id: "manni-lint:config:1",
-  title: "manni lint config section",
-  description: "The `lint:` section of a shared `manni.config.yaml`. The file's root is a mapping of tool name to that tool's settings, so this schema describes the section only - never the file. The document set is not here: proposal 0041 declares it once for every tool, under the family-level `collections:` key, and `paths`/`exclude` under `lint:` are refused by name. Every key is optional: a repo that configures no manni lint at all is a legitimate config, and so is one that carries only a sibling tool's section. `additionalProperties: false` applies at every level below `lint:`, which is what turns a typo'd key into a loud failure instead of a silent default.",
-  type: "object",
-  additionalProperties: false,
-  properties: {
-    allowEmpty: {
-      description: "Treat a run that matched zero files as a success rather than an operational error. The same key, with the same meaning, as `cite.allowEmpty`: for a shared CI template or a pre-commit hook whose file list may legitimately be empty. `--allow-empty` on the command line sets it for one run.",
-      type: "boolean"
-    },
-    overrides: {
-      description: "Repo policy: everything under a glob is linted with one template, whatever the pages say they are. First matching entry wins, and an override outranks a page's own `type`.",
-      type: "array",
-      items: {
-        description: "One policy entry. Both keys are required: an entry naming no template, or no files, is a line that silently does nothing.",
-        type: "object",
-        additionalProperties: false,
-        required: ["files", "template"],
-        properties: {
-          files: {
-            description: "Glob matched against each file's path, written with forward slashes whatever the platform uses.",
-            type: "string",
-            minLength: 1
-          },
-          template: {
-            description: "Template ref applied to the files this entry matches.",
-            type: "string",
-            minLength: 1
-          }
-        }
-      }
-    },
-    structure: {
-      description: "The structure job, which `manni lint structure` and `manni lint check` both run. Declaring it with no keys is how a repo says the job applies. Its one setting is the tool that performs it.",
-      type: "object",
-      additionalProperties: false,
-      properties: {
-        tool: {
-          description: "Which tool performs the job. `manni` is manni's own template-structure engine; `dita-ot` is DITA Open Toolkit, which validates a DITA map and the topics it reaches and is located through the top-level `tools.dita-ot.home`. `--tool <name>` on the command line names the same thing.",
-          type: "string",
-          enum: ["manni", "dita-ot"]
-        }
-      }
-    },
-    template: {
-      description: "Template ref applied to a page that declares no doctype and matches no override. The last stage of the resolution chain, not an override: `--template`, a page's `$template`, an `overrides` entry, and the page's own `type` all outrank it.",
-      type: "string",
-      minLength: 1
-    },
-    templates: {
-      description: "Template files to load. Their templates' `types:` join the doctype routing table, outranking the built-ins, so adopting a repo's own how-to shape is one entry here and no flag.",
-      type: "array",
-      items: {
-        type: "string",
-        minLength: 1
-      }
-    },
-    types: {
-      description: "Explicit doctype -> template ref map, for a doctype no template file claims with its own `types:`. Keys are the vocabulary a page's `type` frontmatter is written in, so they are the author's names rather than this schema's - constrained only to the shape a doctype slug takes, not to a fixed set.",
-      type: "object",
-      additionalProperties: false,
-      patternProperties: {
-        "^[A-Za-z0-9._:-]+$": {
-          description: "A template ref: a built-in id, a path, or a URL, optionally with a `#name` fragment.",
-          type: "string",
-          minLength: 1
-        }
-      }
-    }
-  }
-};
-
-// src/lint/core/config.ts
-var Ajv2 = AjvNs2.default;
-var LINT_TOOLS = ["manni", "dita-ot"];
-var LINT_JOBS = ["structure"];
-var TOOLS_BY_JOB = {
-  structure: ["manni", "dita-ot"]
-};
-function isLintTool(value) {
-  return LINT_TOOLS.includes(value);
-}
-var SECTION_KEY = "lint";
-var CONFIG_FILE = {
-  section: SECTION_KEY,
-  legacyNames: [],
-  toError: (message) => new LintError(message)
-};
-var SECTION_KEYS = Object.keys(config_default.properties);
-var STRUCTURE_KEYS = Object.keys(
-  config_default.properties.structure.properties
-);
-var CONFIG_REF = "https://hawkeyexl.github.io/manni/meta/reference/configuration/";
-var MOVED_KEYS = ["paths", "exclude"];
-function assertNoMovedKeys(raw, source) {
-  for (const key of MOVED_KEYS) {
-    if (Object.hasOwn(raw, key)) {
-      throw new LintError(
-        `${source}: "${key}" is no longer a ${SECTION_KEY} key. Document sets are declared once for every tool, under a top-level collections: list. See ${CONFIG_REF}#collections`
-      );
-    }
-  }
-}
-function rejectUnknownKeys(obj, allowed, where, source) {
-  for (const key of Object.keys(obj)) {
-    if (!allowed.includes(key)) {
-      throw new LintError(
-        `Unknown key "${key}" under ${where}: in ${source}. Supported keys: ${allowed.join(", ")}.`
-      );
-    }
-  }
-}
-function checkJobs(section, source) {
-  for (const job of LINT_JOBS) {
-    const value = section[job];
-    if (value == null || !isRecord2(value)) continue;
-    rejectUnknownKeys(value, STRUCTURE_KEYS, `${SECTION_KEY}.${job}`, source);
-    const tool = value.tool;
-    if (tool === void 0) continue;
-    if (typeof tool !== "string" || !TOOLS_BY_JOB[job].includes(tool)) {
-      throw new LintError(
-        `${source}: ${SECTION_KEY}.${job}.tool must be one of: ${TOOLS_BY_JOB[job].join(", ")}.`
-      );
-    }
-  }
-}
-var ajv2 = new Ajv2({ allErrors: true });
-var compiled2 = null;
-function sectionValidator() {
-  compiled2 ??= ajv2.compile(config_default);
-  return compiled2;
-}
-function isRecord2(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function describeError2(error) {
-  const params = error.params;
-  const extra = typeof params.additionalProperty === "string" ? ` ("${params.additionalProperty}")` : "";
-  return `${SECTION_KEY}${error.instancePath} ${error.message ?? "is invalid"}${extra}`;
-}
-function rejectUnNested(root, source) {
-  const stray = SECTION_KEYS.filter((key) => key in root);
-  if (stray.length === 0) return;
-  throw new LintError(
-    `${source}: found ${stray.map((key) => `"${key}:"`).join(", ")} at the top level, but no "${SECTION_KEY}:" key. This file is shared across the manni family, so every manni lint setting belongs under a top-level "${SECTION_KEY}:" key. Indent the file's contents one level and add that key.`
-  );
-}
-function rejectMiscasedWrapper(root, source) {
-  const miscased = Object.keys(root).find(
-    (key) => key !== SECTION_KEY && key.toLowerCase() === SECTION_KEY
-  );
-  if (miscased === void 0) return;
-  throw new LintError(
-    `${source}: found "${miscased}:" at the top level, but the key is case-sensitive and manni lint reads "${SECTION_KEY}:" exactly. Rename "${miscased}:" to "${SECTION_KEY}:".`
-  );
-}
-function parseConfigSection(section, source) {
-  if (section == null) return {};
-  if (isRecord2(section)) {
-    assertNoMovedKeys(section, source);
-    rejectUnknownKeys(section, SECTION_KEYS, SECTION_KEY, source);
-    checkJobs(section, source);
-  }
-  const validate = sectionValidator();
-  if (!validate(section)) {
-    const detail = (validate.errors ?? []).map(describeError2).join("; ") || `does not match the ${SECTION_KEY} config schema`;
-    throw new LintError(
-      `${source}: invalid "${SECTION_KEY}" section: ${detail}.`
-    );
-  }
-  return section;
-}
-function parseConfig(text, source) {
-  let raw;
-  try {
-    raw = parseYaml2(text);
-  } catch (err) {
-    throw new LintError(
-      `${source}: invalid YAML: ${errorMessage(err)}`
-    );
-  }
-  if (raw == null) return {};
-  if (!isRecord2(raw)) {
-    throw new LintError(
-      `${source}: top level must be a mapping of tool name to that tool's settings, with manni lint's under "${SECTION_KEY}:".`
-    );
-  }
-  if (!(SECTION_KEY in raw)) {
-    rejectUnNested(raw, source);
-    rejectMiscasedWrapper(raw, source);
-    return {};
-  }
-  return parseConfigSection(raw[SECTION_KEY], source);
-}
-async function loadConfig(explicitPath, cwd = process.cwd()) {
-  const file = await readLintConfigFile(explicitPath, cwd);
-  if (file === null) return null;
-  return { config: sectionOf(file), path: file.path };
-}
-function readLintConfigFile(explicitPath, cwd) {
-  return explicitPath ? readConfigFile(explicitPath, cwd, CONFIG_FILE) : findConfigFile(cwd, CONFIG_FILE);
-}
-function sectionOf(file) {
-  if (!file.wrapped && isRecord2(file.value)) {
-    rejectMiscasedWrapper(file.value, file.source);
-  }
-  return parseConfigSection(file.value, file.source);
-}
-function rebaseConfig(found) {
-  if (!found) return {};
-  const dir = dirname2(resolve(found.path));
-  const config = found.config;
-  const ref = (value) => refRelativeTo(found.path, value);
-  const glob = (value) => isAbsolute2(value) ? value : resolve(dir, value).replace(/\\/g, "/");
-  return {
-    ...config,
-    ...config.templates ? { templates: config.templates.map(ref) } : {},
-    ...config.template ? { template: ref(config.template) } : {},
-    ...config.types ? {
-      types: Object.fromEntries(
-        Object.entries(config.types).map(([type, value]) => [type, ref(value)])
-      )
-    } : {},
-    ...config.overrides ? {
-      overrides: config.overrides.map((o) => ({
-        files: glob(o.files),
-        template: ref(o.template)
-      }))
-    } : {}
-  };
-}
-var STDIN = "-";
-async function resolveLintRun(opts) {
-  const cwd = resolve(opts.cwd);
-  const wanted = opts.collection ?? [];
-  if (wanted.length > 0 && opts.inputs.some((input) => input !== STDIN)) {
-    throw new LintError(
-      "--collection selects a configured collection; it cannot be combined with paths."
-    );
-  }
-  const file = opts.noConfig ? null : await readLintConfigFile(opts.configPath, cwd);
-  if (wanted.length > 0 && file === null) {
-    throw new LintError("--collection needs a config file to select from.");
-  }
-  if (file !== null) opts.onConfigLoaded?.({ path: file.path, dir: file.dir });
-  const config = rebaseConfig(
-    file === null ? null : { config: sectionOf(file), path: file.path }
-  );
-  const collections = file === null ? [] : selectCollections(
-    file.collections,
-    wanted,
-    file.source,
-    (message) => new LintError(message)
-  );
-  const fromCollections = wanted.length > 0 || opts.inputs.length === 0;
-  const collectionPaths = fromCollections ? collections.flatMap((c) => c.paths) : [];
-  const inputs = fromCollections ? [...opts.inputs, ...collectionPaths] : opts.inputs;
-  const base = collectionPaths.length > 0 && file ? file.dir : cwd;
-  return {
-    config,
-    inputs,
-    base,
-    collections,
-    fromCollections,
-    tools: file?.tools ?? {},
-    ...file === null ? {} : { configDir: file.dir, configPath: file.path, configSource: file.source }
-  };
-}
-
-// src/lint/tools/dita-ot.ts
-import { execFile } from "node:child_process";
-import { mkdtemp, readFile as readFile2, rm, stat } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { delimiter, join as join2 } from "node:path";
-import { fileURLToPath } from "node:url";
-var MAX_BUFFER = 64 * 1024 * 1024;
-var NOT_ON_PATH = "dita is not on PATH. Install DITA Open Toolkit to lint structure, or set tools.dita-ot.home.";
-var noLauncher = (home) => `no DITA Open Toolkit at "${home}". tools.dita-ot.home must be a DITA-OT installation directory.`;
-function ditaOtLauncher(home, platform = process.platform) {
-  const name = platform === "win32" ? "dita.bat" : "dita";
-  return home === void 0 ? name : join2(home, "bin", name);
-}
-function isBatch(launcher) {
-  const lower2 = launcher.toLowerCase();
-  return lower2.endsWith(".bat") || lower2.endsWith(".cmd");
-}
-function quoteForCmd(value) {
-  if (value.includes('"')) {
-    throw new LintError(
-      `DITA Open Toolkit cannot be given an argument containing a quote: ${value}`
-    );
-  }
-  return `"${value}"`;
-}
-function ditaOtCommandLine(launcher, args) {
-  if (!isBatch(launcher)) {
-    return { command: launcher, argv: args, verbatim: false };
-  }
-  const line = [launcher, ...args].map(quoteForCmd).join(" ");
-  return {
-    command: process.env["COMSPEC"] ?? "cmd.exe",
-    argv: ["/d", "/s", "/c", `"${line}"`],
-    verbatim: true
-  };
-}
-var spawnDitaOt = (launcher, args, opts) => new Promise((settle, reject) => {
-  const line = ditaOtCommandLine(launcher, args);
-  execFile(
-    line.command,
-    line.argv,
-    {
-      cwd: opts.cwd,
-      windowsHide: true,
-      windowsVerbatimArguments: line.verbatim,
-      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 == null && typeof error.signal === "string") {
-        settle({ code: null, signal: error.signal, stdout, stderr });
-        return;
-      }
-      const failure = error;
-      reject(failure);
-    }
-  );
-});
-function isEnoent(err) {
-  return typeof err === "object" && err !== null && "code" in err && err.code === "ENOENT";
-}
-function isMapping(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-async function isFile(path) {
-  try {
-    return (await stat(path)).isFile();
-  } catch {
-    return false;
-  }
-}
-async function isOnPath(name) {
-  for (const dir of (process.env["PATH"] ?? "").split(delimiter)) {
-    if (dir === "") continue;
-    if (await isFile(join2(dir, name))) return true;
-  }
-  return false;
-}
-function foldDitaOtSeverity(level) {
-  switch (level.toUpperCase()) {
-    case "FATAL":
-    case "ERROR":
-      return "error";
-    case "WARN":
-      return "warning";
-    case "INFO":
-      return "notice";
-    default:
-      return null;
-  }
-}
-function pathFromFileUri(location) {
-  let url;
-  try {
-    url = new URL(location);
-  } catch {
-    return location;
-  }
-  if (url.protocol !== "file:") return location;
-  try {
-    return fileURLToPath(url);
-  } catch {
-    return decodeURIComponent(url.pathname);
-  }
-}
-function readMessage(raw) {
-  if (!isMapping(raw)) return null;
-  const code = raw["code"];
-  if (typeof code !== "string" || code === "") return null;
-  const level = raw["level"];
-  const severity = typeof level === "string" ? foldDitaOtSeverity(level) : null;
-  if (severity === null) return null;
-  const msg = raw["msg"];
-  const location = raw["location"];
-  const line = raw["line"];
-  const row = raw["row"];
-  return {
-    code,
-    severity,
-    // A coded message with no text is still a finding; the code says what it is.
-    message: typeof msg === "string" && msg !== "" ? msg : code,
-    ...typeof location === "string" && location !== "" ? { file: pathFromFileUri(location) } : {},
-    ...typeof line === "number" ? { line } : {},
-    ...typeof row === "number" ? { column: row } : {}
-  };
-}
-function parseDitaOtLog(text) {
-  let parsed;
-  try {
-    parsed = JSON.parse(text);
-  } catch {
-    return null;
-  }
-  if (!Array.isArray(parsed)) return null;
-  const messages = [];
-  for (const raw of parsed) {
-    const message = readMessage(raw);
-    if (message !== null) messages.push(message);
-  }
-  return messages;
-}
-function parseDitaOtVersion(output) {
-  const match = /\b(\d+(?:\.\d+)+(?:[-.][0-9A-Za-z]+)*)/.exec(output);
-  return match?.[1] ?? null;
-}
-function failureText(result) {
-  const stderr = result.stderr.trim();
-  if (stderr !== "") return stderr;
-  if (result.signal != null) return `killed by ${result.signal}`;
-  return `exit code ${String(result.code)}`;
-}
-async function readLog(path) {
-  let text;
-  try {
-    text = await readFile2(path, "utf8");
-  } catch {
-    return null;
-  }
-  return parseDitaOtLog(text);
-}
-async function runDitaOtValidate(opts) {
-  const spawn = opts.spawn ?? spawnDitaOt;
-  const launcher = ditaOtLauncher(opts.home);
-  if (opts.home !== void 0 && !await isFile(launcher)) {
-    throw new LintError(noLauncher(opts.home));
-  }
-  const scratch = await mkdtemp(join2(tmpdir(), "manni-dita-ot-"));
-  try {
-    const results = [];
-    for (const [index, target] of opts.targets.entries()) {
-      const logfile = join2(scratch, `${String(index)}.json`);
-      const args = [
-        `--input=${target}`,
-        "--format=dita",
-        `--output=${join2(scratch, `out-${String(index)}`)}`,
-        `--temp=${join2(scratch, `temp-${String(index)}`)}`,
-        "--logger=json",
-        `--logfile=${logfile}`,
-        "--verbose"
-      ];
-      let result;
-      try {
-        result = await spawn(launcher, args, { cwd: opts.cwd });
-      } catch (err) {
-        if (isEnoent(err)) {
-          throw new LintError(
-            opts.home === void 0 ? NOT_ON_PATH : noLauncher(opts.home)
-          );
-        }
-        throw err;
-      }
-      const messages = await readLog(logfile);
-      const explained = messages !== null && messages.some((m) => m.severity === "error");
-      if (result.code !== 0 && !explained) {
-        if (opts.home === void 0 && !await isOnPath(launcher)) {
-          throw new LintError(NOT_ON_PATH);
-        }
-        throw new LintError(
-          `DITA Open Toolkit failed on ${target}: ${failureText(result)}. Run it directly on that file to see why.`
-        );
-      }
-      results.push({ target, messages: messages ?? [] });
-    }
-    return results;
-  } finally {
-    await rm(scratch, { recursive: true, force: true });
-  }
-}
-async function probeDitaOt(ctx, spawn = spawnDitaOt) {
-  const home = ctx.tools === void 0 ? void 0 : ditaOtHome(ctx.tools, ctx.configDir ?? ctx.cwd);
-  const launcher = ditaOtLauncher(home);
-  if (home !== void 0 && !await isFile(launcher)) {
-    return { available: false, version: null };
-  }
-  let result;
-  try {
-    result = await spawn(launcher, ["--version"], { cwd: ctx.cwd });
-  } catch {
-    return { available: false, version: null };
-  }
-  if (result.code !== 0) return { available: false, version: null };
-  return {
-    available: true,
-    // Both channels, because which one carries the banner is not fixed: the
-    // shell launcher prints it on stdout, and the Windows `.bat` run through
-    // `cmd.exe` has been seen to put it on stderr. Reading one would report a
-    // toolkit that is plainly there as versionless on the other platform.
-    version: parseDitaOtVersion(`${result.stdout}
-${result.stderr}`)
-  };
-}
-var DITA_FORMAT = {
-  name: "dita",
-  label: "DITA",
-  extensions: [".ditamap", ".dita", ".xml"],
-  kinds: []
-};
-var ditaOt = {
-  name: "dita-ot",
-  label: "DITA Open Toolkit",
-  formats: () => [{ ...DITA_FORMAT }],
-  // Maps only. DITA-OT takes one `--input` per invocation, so walking
-  // every topic in a docset would pay a JVM start per topic. Naming a `.dita`
-  // explicitly still works: a named file bypasses the extension filter.
-  walkExtensions: () => [".ditamap"],
-  probe: (ctx) => probeDitaOt(ctx),
-  // None. Every option manni owns is refused under this tool, stdin included.
-  ownedOptions: []
-};
-
-// src/lint/tools/index.ts
-var manni = {
-  name: "manni",
-  label: "manni's own structure engine",
-  formats: () => listFormats(),
-  walkExtensions: () => supportedExtensions(),
-  // Nothing to look for: the engine is this package, so it is available
-  // wherever the CLI is. A tool that shells out answers this by looking.
-  probe: () => Promise.resolve({ available: true, version: package_default.version }),
-  // `-` is stdin, and it is in this list so the derivation in `lint.ts` has
-  // one place to learn that manni owns it. The refusal itself is not shaped
-  // like the others, because "option" is the wrong word for a positional:
-  // `assertOptionsOwned` special-cases it to say "cannot read stdin" instead.
-  // A tool that copies this list without reading that guard gets the right
-  // ownership and the wrong sentence.
-  ownedOptions: ["--template", "--templates", "--explain", "--as", "-"]
-};
-var descriptors = /* @__PURE__ */ new Map([
-  [manni.name, manni],
-  [ditaOt.name, ditaOt]
-]);
-function structureTools() {
-  return [...descriptors.values()];
-}
-function resolveStructureTool(name) {
-  const descriptor = descriptors.get(name);
-  if (descriptor) return descriptor;
-  throw new LintError(
-    `Unknown --tool "${name}" for structure. Use ${TOOLS_BY_JOB.structure.join(", ")}.`
-  );
-}
-
-// src/lint/commands/lint.ts
-var STDIN_LABEL = "<stdin>";
-var TEMPLATE_FILE_EXTENSIONS = [".yaml", ".yml", ".json"];
-async function asLintError(run) {
-  try {
-    return await run();
-  } catch (err) {
-    if (err instanceof LintError) throw err;
-    if (err instanceof ToolError) throw new LintError(err.message);
-    throw err;
-  }
-}
-function templateFiles(value) {
-  if (value == null) return [];
-  return Array.isArray(value) ? value : [value];
-}
-var TOOL_OPTIONS = [
-  { spelling: "--template", given: (o) => o.template !== void 0 },
-  {
-    spelling: "--templates",
-    given: (o) => templateFiles(o.templates).length > 0
-  },
-  { spelling: "--explain", given: (o) => o.explain === true },
-  { spelling: "--as", given: (o) => o.as !== void 0 }
-];
-function foreignOptions(tool) {
-  const foreign = /* @__PURE__ */ new Map();
-  for (const other of structureTools()) {
-    if (other === tool) continue;
-    for (const spelling of other.ownedOptions) {
-      if (tool.ownedOptions.includes(spelling)) continue;
-      if (!foreign.has(spelling)) foreign.set(spelling, other);
-    }
-  }
-  return foreign;
-}
-function assertOptionsOwned(opts, tool, usingStdin) {
-  const foreign = foreignOptions(tool);
-  if (foreign.size === 0) return;
-  for (const { spelling, given } of TOOL_OPTIONS) {
-    const owner = foreign.get(spelling);
-    if (owner === void 0 || !given(opts)) continue;
-    throw new LintError(
-      `${spelling} is an option of the ${owner.name} tool; the structure job's tool is ${tool.name}.`
-    );
-  }
-  if (usingStdin && foreign.has(STDIN_TOKEN)) {
-    throw new LintError(`${tool.name} cannot read stdin. Name files or a map.`);
-  }
-}
-function origin3() {
-  return {
-    start: { line: 1, column: 1, offset: 0 },
-    end: { line: 1, column: 1, offset: 0 }
-  };
-}
-function skip(file, reason, cause = "unsupported-format") {
-  return {
-    file,
-    // `success` means "linted and produced no findings". A file that was never
-    // linted is neither passing nor failing, and calling it a pass would hide
-    // the gap from anyone reading CI output.
-    success: false,
-    findings: [],
-    template: null,
-    skipped: cause,
-    reason
-  };
-}
-function parseFinding(message) {
-  return {
-    type: "parse_error",
-    heading: null,
-    message,
-    position: origin3(),
-    severity: "error"
-  };
-}
-function templateLoader() {
-  const cache = /* @__PURE__ */ new Map();
-  return (ref) => {
-    let pending = cache.get(ref);
-    if (!pending) {
-      pending = loadResolvedTemplate(ref);
-      cache.set(ref, pending);
-    }
-    return pending;
-  };
-}
-function cliTemplateRef(template, templatePaths) {
-  if (!template) return void 0;
-  if (template.includes("#")) return template;
-  if (classifyRef(template).kind !== "file") return template;
-  if (template.includes("/") || template.includes("\\")) return template;
-  if (TEMPLATE_FILE_EXTENSIONS.some((e) => template.toLowerCase().endsWith(e))) {
-    return template;
-  }
-  if (templatePaths.length === 0) return template;
-  return `${templatePaths[templatePaths.length - 1] ?? ""}#${template}`;
-}
-function templateIdentity(ref) {
-  const hash = ref.lastIndexOf("#");
-  if (hash === -1) return { source: ref, template: ref };
-  return { source: ref.slice(0, hash), template: ref.slice(hash + 1) };
-}
-function unknownTypeFinding(resolution, typeIndex, position) {
-  const suggestions = resolution.suggestions ?? [];
-  const known = resolution.knownTypes ?? knownTypes(typeIndex);
-  const hint = suggestions.length ? ` Did you mean ${suggestions.map((s) => `"${s}"`).join(", ")}?` : ` Known doctypes: ${known.join(", ") || "(none)"}.`;
-  const declared = resolution.unknownType ?? "(none recorded)";
-  return {
-    type: "unknown_type",
-    heading: null,
-    message: `No template serves type "${declared}".${hint} Declare it on a template with "types:", then pass that file with --templates.`,
-    position,
-    severity: "error"
-  };
-}
-async function lintOne(label, content, parser, ctx) {
-  let tree;
-  try {
-    tree = parser.parse(content, label);
-  } catch (err) {
-    return {
-      file: label,
-      success: false,
-      findings: [parseFinding(errorMessage(err))],
-      template: null
-    };
-  }
-  const resolution = resolveTemplateRef({
-    filePath: label,
-    absolutePath: ctx.absoluteOf?.(label),
-    frontmatter: tree.frontmatter,
-    cliTemplate: ctx.cliTemplate,
-    overrides: ctx.overrides,
-    typeIndex: ctx.typeIndex,
-    defaultTemplate: ctx.defaultTemplate
-  });
-  const withResolution = (result) => ctx.explain ? { ...result, resolution } : result;
-  const metaPosition = tree.frontmatterPosition ?? origin3();
-  if (resolution.ref === null) {
-    if (resolution.cause === "unknown-type") {
-      return withResolution({
-        file: label,
-        success: false,
-        findings: [unknownTypeFinding(resolution, ctx.typeIndex, metaPosition)],
-        template: null
-      });
-    }
-    return withResolution(
-      skip(
-        label,
-        "no type in frontmatter and no template resolved",
-        "no-template"
-      )
-    );
-  }
-  const brokenTemplate = (err) => withResolution({
-    file: label,
-    success: false,
-    findings: [
-      {
-        type: "template_error",
-        heading: null,
-        message: errorMessage(err),
-        position: metaPosition,
-        severity: "error"
-      }
-    ],
-    template: resolution.ref
-  });
-  if (resolution.stage === "frontmatter-template" && classifyRef(resolution.ref).kind === "url") {
-    return brokenTemplate(
-      new LintError(
-        `${FILE_TEMPLATE_KEY} may not name a URL ("${resolution.ref}"): a document must not choose what the linter fetches. Declare it in manni.config.yaml under "templates:" or "types:", or pass it with --template.`
-      )
-    );
-  }
-  const ref = resolution.stage === "frontmatter-template" ? refRelativeTo(ctx.absoluteOf?.(label) ?? label, resolution.ref) : resolution.ref;
-  let template;
-  try {
-    template = await ctx.getTemplate(ref);
-  } catch (err) {
-    return brokenTemplate(err);
-  }
-  if (ctx.explain) {
-    return withResolution({
-      file: label,
-      success: true,
-      findings: [],
-      template: resolution.ref,
-      // The tree and the loaded template, for the alignment block. Both are
-      // already in hand here, and neither survives this function otherwise.
-      alignment: { tree, template }
-    });
-  }
-  let findings;
-  try {
-    findings = validateDocument(tree, template, {
-      ...templateIdentity(ref),
-      kinds: parser.kinds
-    });
-  } catch (err) {
-    if (err instanceof LintError) return brokenTemplate(err);
-    throw err;
-  }
-  return withResolution({
-    file: label,
-    // "Linted and found nothing wrong", which is not the same as "produced no
-    // findings". A `warning` - today, a rule this file's format cannot answer -
-    // says something about the run rather than about the document, and the
-    // exit code follows `success`, so counting it as a failure would turn a
-    // docset of mixed formats permanently red. The family's rule, and the one
-    // meta and cite already apply: `ok` is "no error-severity finding".
-    success: !findings.some(isErrorSeverity),
-    findings,
-    template: resolution.ref
-  });
-}
-async function lintWithManni(run) {
-  const { opts, config, cwd, files, forcedParser, usingStdin } = run;
-  const templatePaths = templateFiles(opts.templates ?? config.templates);
-  const getTemplate = templateLoader();
-  const userFiles = [];
-  for (const ref of templatePaths) {
-    const file = await loadTemplateFile(ref);
-    const templates = {};
-    for (const name of Object.keys(file.templates ?? {})) {
-      templates[name] = await getTemplate(`${ref}#${name}`);
-    }
-    userFiles.push({ ref, file: { ...file, templates } });
-  }
-  const typeIndex = buildTypeIndex({
-    builtins: listBuiltins(),
-    userFiles,
-    explicitTypes: opts.types ?? config.types
-  });
-  const ctx = {
-    getTemplate,
-    absoluteOf: (file) => resolve2(cwd, file).replace(/\\/g, "/"),
-    typeIndex,
-    cliTemplate: cliTemplateRef(opts.template, templatePaths),
-    overrides: opts.overrides ?? config.overrides,
-    // `template:` in config is the default for a page that declares no type -
-    // the bottom of the chain, not the top. `--template` is the top.
-    defaultTemplate: opts.defaultTemplate ?? config.template,
-    explain: opts.explain === true
-  };
-  if (ctx.cliTemplate != null) await getTemplate(ctx.cliTemplate);
-  const results = [];
-  if (usingStdin && forcedParser) {
-    results.push(
-      await lintOne(STDIN_LABEL, opts.stdinContent ?? "", forcedParser, ctx)
-    );
-  }
-  for (const file of files) {
-    const ext = extname(file);
-    const parser = forcedParser ?? parserForExtension(ext);
-    if (!parser) {
-      results.push(
-        skip(
-          file,
-          `no parser is registered for "${ext || file}". Supported extensions: ${supportedExtensions().join(", ")}. Use --as to override.`
-        )
-      );
-      continue;
-    }
-    let content;
-    try {
-      content = await readFile3(resolve2(cwd, file), "utf8");
-    } catch (err) {
-      results.push(
-        skip(file, `could not be read: ${errorMessage(err)}`, "unreadable")
-      );
-      continue;
-    }
-    results.push(await lintOne(file, content, parser, ctx));
-  }
-  return results;
-}
-function ditaOtFinding(message) {
-  const point = message.line === void 0 ? null : {
-    line: message.line,
-    // The log calls the column `row`; see `readMessage` in the seam.
-    column: message.column ?? 1,
-    // DITA-OT reports no byte offset, and nothing downstream needs one.
-    offset: 0
-  };
-  return {
-    type: message.code,
-    heading: null,
-    message: message.message,
-    position: point === null ? origin3() : { start: point, end: point },
-    severity: message.severity
-  };
-}
-async function lintWithDitaOt(run) {
-  const { cwd, files, onNotice } = run;
-  const readable = ditaOt.formats().flatMap((format) => format.extensions);
-  const reads = new Set(readable.map((ext) => ext.toLowerCase()));
-  const targets = [];
-  const unsupported = [];
-  for (const file of files) {
-    if (reads.has(extname(file).toLowerCase())) targets.push(file);
-    else {
-      unsupported.push(
-        skip(
-          file,
-          `dita-ot does not read "${extname(file) || file}". It reads ${readable.join(", ")}.`
-        )
-      );
-    }
-  }
-  const labels = /* @__PURE__ */ new Map();
-  for (const file of targets) {
-    const absolute = resolve2(cwd, file);
-    if (!labels.has(absolute)) labels.set(absolute, file);
-  }
-  const unique = [...labels.values()];
-  const labelOf = (absolute) => {
-    const known = labels.get(absolute);
-    if (known !== void 0) return known;
-    const near = relative(cwd, absolute).replace(/\\/g, "/");
-    return near === "" ? absolute : near;
-  };
-  for (const file of unique) {
-    if (extname(file).toLowerCase() !== ".ditamap") {
-      onNotice?.(
-        `checked ${file} without a map; references outside it are not resolved.`
-      );
-    }
-  }
-  if (unique.length === 0) return unsupported;
-  const results = await run.validate({
-    targets: [...labels.keys()],
-    cwd,
-    ...run.home === void 0 ? {} : { home: run.home }
-  });
-  const byFile = new Map(unique.map((file) => [file, []]));
-  const findingsFor = (file) => {
-    let list = byFile.get(file);
-    if (list === void 0) {
-      list = [];
-      byFile.set(file, list);
-    }
-    return list;
-  };
-  for (const { target, messages } of results) {
-    const invoked = labelOf(target);
-    for (const message of messages) {
-      const file = message.file === void 0 ? invoked : labelOf(resolve2(cwd, message.file));
-      findingsFor(file).push(ditaOtFinding(message));
-    }
-  }
-  return [
-    ...unsupported,
-    ...[...byFile].map(([file, findings]) => ({
-      file,
-      // The family's rule, as manni's branch applies it: `ok` is "no
-      // error-severity finding", so a warning-only file stays green.
-      success: !findings.some(isErrorSeverity),
-      findings,
-      template: null
-    }))
-  ];
-}
-function assertSomethingWasChecked(results, explain, tool) {
-  const skipped = results.filter((r) => r.skipped != null).length;
-  const checked = results.length - skipped;
-  if (explain || checked > 0 || skipped === 0) return;
-  const unrouted = results.filter((r) => r.skipped === "no-template").length;
-  const unsupported = results.filter(
-    (r) => r.skipped === "unsupported-format"
-  ).length;
-  const unreadable = results.filter((r) => r.skipped === "unreadable").length;
-  const advice = [
-    unrouted > 0 ? `${unrouted} had no template: give a page a "type:" that a template serves, pass -t/--template <ref>, or set "lint.template" as a default.` : null,
-    unsupported > 0 ? (
-      // `--as` belongs to manni's engine, so offering it to someone running
-      // another tool is advice that answers with a usage error. The formats
-      // line is true for every tool, because every tool declares one.
-      `${unsupported} ${unsupported === 1 ? "is" : "are"} in a format ${tool.name} does not read: ` + (tool.ownedOptions.includes("--as") ? `pass --as <format> to force one, or target files in a format ` : `target files in a format `) + `"manni lint tools" lists.`
-    ) : null,
-    unreadable > 0 ? `${unreadable} could not be read: check the permissions on those paths, or drop them from the run with --exclude <glob>.` : null
-  ].filter((line) => line !== null).join(" ");
-  throw new LintError(
-    `Nothing was checked: all ${skipped} file(s) were skipped. ${advice} Run "manni lint structure <paths> --explain" to see how each file resolved.`
-  );
-}
-async function runLint(opts) {
-  const run = await resolveLintRun({
-    cwd: opts.cwd ?? process.cwd(),
-    configPath: opts.configPath,
-    noConfig: opts.noConfig,
-    inputs: opts.inputs,
-    collection: opts.collection,
-    onConfigLoaded: opts.onConfigLoaded
-  });
-  const config = run.config;
-  const cwd = run.base;
-  if (run.inputs.length === 0) {
-    throw new LintError(
-      "No files to check. Pass paths/globs, or declare a collection under `collections:` in manni.config.yaml."
-    );
-  }
-  const tool = resolveStructureTool(
-    opts.tool ?? config.structure?.tool ?? "manni"
-  );
-  const usingStdin = run.inputs.includes(STDIN_TOKEN);
-  assertOptionsOwned(opts, tool, usingStdin);
-  const forcedParser = opts.as != null ? parserByName(opts.as) : void 0;
-  if (opts.as != null && !forcedParser) {
-    throw new LintError(
-      `Unknown format "${opts.as}". Run "manni lint tools" to see the formats manni lint reads.`
-    );
-  }
-  if (usingStdin && !forcedParser) {
-    throw new LintError(
-      "Reading from stdin (-) requires --as <format> to choose a parser."
-    );
-  }
-  const fileInputs = run.inputs.filter((input) => input !== STDIN_TOKEN);
-  const exts = opts.exts ?? forcedParser?.extensions ?? tool.walkExtensions();
-  const allowEmpty = opts.allowEmpty ?? config.allowEmpty;
-  const exclude = [
-    .../* @__PURE__ */ new Set([
-      ...opts.exclude ?? [],
-      ...run.fromCollections ? run.collections.flatMap((c) => c.exclude) : []
-    ])
-  ];
-  const { files, gitignoreSkipped } = await asLintError(
-    () => resolveTargetSet({
-      inputs: fileInputs,
-      exts,
-      exclude,
-      cwd,
-      allowEmpty,
-      ...gitignoreOptions({
-        flag: opts.respectGitignore,
-        onNotice: opts.onNotice
-      })
-    })
-  );
-  await asLintError(() => {
-    assertNonEmpty({
-      files,
-      inputs: fileInputs,
-      usingStdin,
-      allowEmpty,
-      exclude,
-      exts,
-      gitignoreSkipped,
-      action: "linted"
-    });
-  });
-  const name = tool.name;
-  let results;
-  if (name === "manni") {
-    results = await lintWithManni({
-      opts,
-      config,
-      cwd,
-      files,
-      forcedParser,
-      usingStdin
-    });
-  } else if (name === "dita-ot") {
-    const home = ditaOtHome(run.tools, run.configDir ?? cwd);
-    results = await lintWithDitaOt({
-      cwd,
-      files,
-      ...home === void 0 ? {} : { home },
-      ...opts.onNotice === void 0 ? {} : { onNotice: opts.onNotice },
-      validate: opts.runDitaOt ?? runDitaOtValidate
-    });
-  } else {
-    throw new LintError(`No implementation is registered for the ${name} tool.`);
-  }
-  assertSomethingWasChecked(results, opts.explain === true, tool);
-  const skipped = results.filter((r) => r.skipped != null).length;
-  const failed = results.filter((r) => r.skipped == null && !r.success).length;
-  const checked = results.length - skipped;
-  return {
-    results,
-    summary: { checked, passed: checked - failed, failed, skipped }
-  };
-}
-
 export {
   parserForExtension,
   parserByName,
   supportedExtensions,
-  listFormats,
-  listBuiltins,
-  classifyRef,
-  clearTemplateCaches,
-  loadTemplateFile,
-  loadTemplate,
-  resolveExtends,
-  clearMatcherCache,
-  validateSections,
-  validateDocument,
-  LINT_TOOLS,
-  LINT_JOBS,
-  TOOLS_BY_JOB,
-  isLintTool,
-  parseConfig,
-  loadConfig,
-  rebaseConfig,
-  resolveLintRun,
-  resolveStructureTool,
-  STDIN_LABEL,
-  runLint
+  unsupportedFormatMessage,
+  listFormats
 };
-//# sourceMappingURL=chunk-WB3QM6PP.js.map
+//# sourceMappingURL=chunk-ELZ2IIOF.js.map