@hawkeyexl/manni 4.4.1 → 4.6.0

package/dist/chunk-SWSTHZBI.js

@@ -0,0 +1,2464 @@
+#!/usr/bin/env node
+import {
+  listFormats,
+  parserByName,
+  parserForExtension,
+  supportedExtensions,
+  unsupportedFormatMessage
+} from "./chunk-73TC4DYH.js";
+import {
+  packageRoot
+} from "./chunk-TIUTIOFB.js";
+import {
+  BLOCK_KINDS,
+  BLOCK_KIND_NODE,
+  checkContains,
+  checkContainsIn,
+  checkHeading,
+  checkSequence,
+  checkSequenceIn,
+  isWildcard,
+  matchSections,
+  occurrenceRange
+} from "./chunk-TBAMBLF3.js";
+import {
+  LintError
+} from "./chunk-YGFIQ6Y5.js";
+import {
+  STDIN_TOKEN,
+  assertNonEmpty,
+  gitignoreOptions,
+  isErrorSeverity,
+  resolveTargetSet
+} from "./chunk-KCOFEWV5.js";
+import {
+  ditaOtHome,
+  findConfigFile,
+  readConfigFile,
+  selectCollections
+} from "./chunk-XKBEHKWO.js";
+import {
+  warn
+} from "./chunk-HX44GB4Z.js";
+import {
+  package_default
+} from "./chunk-PCFG7E6B.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/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 lower = ref.toLowerCase();
+  if (!ref.includes("/") && !ref.includes("\\") && !FILE_EXTENSIONS.some((ext) => lower.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 lower = extensionSource(source, kind).toLowerCase();
+  if (lower.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, load = 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 load(parentRef), load, [...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 origin() {
+  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 origin();
+  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: origin(),
+    // 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 lower = launcher.toLowerCase();
+  return lower.endsWith(".bat") || lower.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 origin2() {
+  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: origin2(),
+    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 ?? origin2();
+  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, unsupportedFormatMessage(ext || file)));
+      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 ? origin2() : { 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 {
+  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
+};
+//# sourceMappingURL=chunk-SWSTHZBI.js.map