@hawkeyexl/manni 3.0.0 → 4.0.1

package/dist/index.js

@@ -1,11 +1,57 @@
 #!/usr/bin/env node
 import {
+  BLOCK_KINDS,
+  BUILTIN_SOURCE,
+  BUILT_IN_DEFAULTS,
   KeyError,
+  LINT_JOBS,
+  LINT_TOOLS,
+  LintError,
+  RULE_ID_PREFIX2 as RULE_ID_PREFIX,
+  STDIN_LABEL,
+  TOOLS_BY_JOB,
+  TOOL_NAME,
   cite_exports,
+  classifyRef as classifyRef2,
+  clearMatcherCache,
+  clearPatternCache,
+  clearTemplateCaches,
+  headingMatches,
+  isLintTool,
+  isWildcard,
+  listBuiltins as listBuiltins2,
+  listFormats,
+  loadConfig as loadConfig2,
+  loadTemplate,
+  loadTemplateFile,
+  matchSections,
+  occurrenceRange,
+  parseConfig as parseConfig2,
+  parserByName,
+  parserForExtension,
+  rebaseConfig,
   reencryptMetadata,
+  render as render2,
+  renderGithub,
+  renderJson,
+  renderJunit as renderJunit2,
+  renderPretty,
+  renderSarif as renderSarif2,
+  renderTemplates,
+  renderTools,
+  resolveExtends,
+  resolveLintRun,
+  ruleId,
+  ruleName,
   runKeyRotate,
-  runKeySet
-} from "./chunk-W75SLU7Z.js";
+  runKeySet,
+  runLint,
+  runTemplates,
+  runTools,
+  supportedExtensions as supportedExtensions2,
+  validateDocument,
+  validateSections
+} from "./chunk-Z2RBN4N4.js";
 import {
   BinMissing,
   COMMON_FORMATS,
@@ -40,6 +86,7 @@ import {
   ReviewCache,
   SCHEMA_CACHE_DIR,
   SCHEMA_CACHE_VERSION,
+  STDIN_TOKEN,
   SchemaCache,
   Validator,
   __export,
@@ -92,6 +139,7 @@ import {
   orphanEntries,
   orphanError,
   orphanJoins,
+  palette,
   parseCollections,
   parseConfig,
   parseOriginUrl,
@@ -121,6 +169,7 @@ import {
   schemaEntryRef,
   schemaLoadOptions,
   selectCollections,
+  shouldColor,
   sourcesFor,
   staleFindings,
   stringifyValue,
@@ -128,7 +177,64 @@ import {
   valueOf,
   vendorFileName,
   writeFileAtomic
-} from "./chunk-I6PYC7EP.js";
+} from "./chunk-DJ2WOJIG.js";
+
+// src/lint/index.ts
+var lint_exports = {};
+__export(lint_exports, {
+  BLOCK_KINDS: () => BLOCK_KINDS,
+  BUILTIN_SOURCE: () => BUILTIN_SOURCE,
+  BUILT_IN_DEFAULTS: () => BUILT_IN_DEFAULTS,
+  LINT_JOBS: () => LINT_JOBS,
+  LINT_TOOLS: () => LINT_TOOLS,
+  LintError: () => LintError,
+  RULE_ID_PREFIX: () => RULE_ID_PREFIX,
+  STDIN_LABEL: () => STDIN_LABEL,
+  STDIN_TOKEN: () => STDIN_TOKEN,
+  TOOLS_BY_JOB: () => TOOLS_BY_JOB,
+  TOOL_NAME: () => TOOL_NAME,
+  classifyRef: () => classifyRef2,
+  clearCaches: () => clearCaches,
+  headingMatches: () => headingMatches,
+  isLintTool: () => isLintTool,
+  isWildcard: () => isWildcard,
+  listBuiltins: () => listBuiltins2,
+  listFormats: () => listFormats,
+  loadConfig: () => loadConfig2,
+  loadTemplate: () => loadTemplate,
+  loadTemplateFile: () => loadTemplateFile,
+  matchSections: () => matchSections,
+  occurrenceRange: () => occurrenceRange,
+  palette: () => palette,
+  parseConfig: () => parseConfig2,
+  parserByName: () => parserByName,
+  parserForExtension: () => parserForExtension,
+  rebaseConfig: () => rebaseConfig,
+  render: () => render2,
+  renderGithub: () => renderGithub,
+  renderJson: () => renderJson,
+  renderJunit: () => renderJunit2,
+  renderPretty: () => renderPretty,
+  renderSarif: () => renderSarif2,
+  renderTemplates: () => renderTemplates,
+  renderTools: () => renderTools,
+  resolveExtends: () => resolveExtends,
+  resolveLintRun: () => resolveLintRun,
+  ruleId: () => ruleId,
+  ruleName: () => ruleName,
+  runLint: () => runLint,
+  runTemplates: () => runTemplates,
+  runTools: () => runTools,
+  shouldColor: () => shouldColor,
+  supportedExtensions: () => supportedExtensions2,
+  validateDocument: () => validateDocument,
+  validateSections: () => validateSections
+});
+function clearCaches() {
+  clearTemplateCaches();
+  clearMatcherCache();
+  clearPatternCache();
+}
 
 // src/key/index.ts
 var key_exports = {};
@@ -214,6 +320,7 @@ export {
   isQueryFormat,
   isReportFormat,
   key_exports as key,
+  lint_exports as lint,
   listBuiltins,
   loadConfig,
   loadExternalMetadata,

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/key/index.ts"],"sourcesContent":["/**\n * The key domain's programmatic API, exported from the package as the `key`\n * namespace: `import { key } from \"@hawkeyexl/manni\"`. The command cores, and\n * the family's encryption primitives a caller needs beside them.\n */\nexport * from \"./types.js\";\nexport { KeyError } from \"./errors.js\";\nexport { runKeySet } from \"./commands/set.js\";\nexport { runKeyRotate } from \"./commands/rotate.js\";\nexport { decryptValue, encryptValue, isEncryptedValue } from \"../shared/encryption.js\";\nexport type { EncryptionContext } from \"../shared/encryption.js\";\nexport { resolveEncryptionKey } from \"../shared/encryption-key.js\";\nexport type { KeySource, ResolvedKey } from \"../shared/encryption-key.js\";\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;","names":[]}
+{"version":3,"sources":["../src/lint/index.ts","../src/key/index.ts"],"sourcesContent":["/** Programmatic API for manni lint. */\nimport { clearTemplateCaches } from \"./core/template-registry.js\";\nimport { clearMatcherCache } from \"./core/resolve-template.js\";\nimport { clearPatternCache } from \"./rules/index.js\";\n\n/**\n * Drop every process-lifetime cache: parsed built-ins, fetched template files,\n * compiled override globs, and compiled heading patterns.\n *\n * A CLI run never needs this - it lints one docset and exits, and the caches\n * are what stop a tree of one doctype from re-reading the same template per\n * page. A long-lived host is the different case: the maps grow with the number\n * of distinct refs and patterns seen, and a cached remote template is served\n * for the life of the process, so one republished upstream is never picked up.\n * Call this between runs, or when a template may have changed underneath.\n */\nexport function clearCaches(): void {\n  clearTemplateCaches();\n  clearMatcherCache();\n  clearPatternCache();\n}\n\nexport { runLint, STDIN_LABEL } from \"./commands/lint.js\";\nexport type {\n  LintOptions,\n  LintRun,\n  LintSummary,\n  LintFileResult,\n} from \"./commands/lint.js\";\nexport { runTemplates, BUILTIN_SOURCE } from \"./commands/templates.js\";\nexport type {\n  TemplateInfo,\n  TemplatesInfo,\n  TemplatesOptions,\n} from \"./commands/templates.js\";\nexport { runTools, BUILT_IN_DEFAULTS } from \"./commands/tools.js\";\nexport type { FormatInfo, ToolInfo, ToolsOptions } from \"./commands/tools.js\";\nexport {\n  LINT_JOBS,\n  LINT_TOOLS,\n  TOOLS_BY_JOB,\n  isLintTool,\n  loadConfig,\n  parseConfig,\n  rebaseConfig,\n  resolveLintRun,\n} from \"./core/config.js\";\nexport type {\n  LintConfig,\n  LintJob,\n  LintJobConfig,\n  LintRunOptions,\n  LintTool,\n  ResolvedLintRun,\n} from \"./core/config.js\";\nexport { validateDocument, validateSections } from \"./core/validator.js\";\nexport { matchSections } from \"./core/match.js\";\nexport type { Match, MatchResult } from \"./core/match.js\";\nexport {\n  BLOCK_KINDS,\n  headingMatches,\n  isWildcard,\n  occurrenceRange,\n} from \"./core/template.js\";\nexport type {\n  AdmonitionsRule,\n  AttributesRule,\n  BlockKind,\n  BlockRule,\n  CodeBlocksRule,\n  ElementsRule,\n  HeadingRule,\n  ImagesRule,\n  ListItemsRule,\n  ListsRule,\n  Occurrences,\n  ParagraphsRule,\n  Rule,\n  TablesRule,\n  Template,\n  TemplateFile,\n} from \"./core/template.js\";\nexport {\n  listBuiltins,\n  loadTemplate,\n  loadTemplateFile,\n  resolveExtends,\n  classifyRef,\n} from \"./core/template-registry.js\";\nexport type {\n  BuiltinInfo,\n  LoadTemplateOptions,\n  RefKind,\n  TemplateResolver,\n} from \"./core/template-registry.js\";\n// Targets resolve through the family's walker (`src/meta/internal.ts`), which\n// is what makes `--ext`, `--exclude`, `.gitignore` handling and `--allow-empty`\n// mean the same thing here as they do for `meta` and `cite`.\nexport { STDIN_TOKEN } from \"../meta/internal.js\";\nexport {\n  listFormats,\n  parserByName,\n  parserForExtension,\n  supportedExtensions,\n} from \"./parsers/index.js\";\nexport {\n  render,\n  renderPretty,\n  renderJson,\n  renderGithub,\n  renderJunit,\n  renderTemplates,\n  renderTools,\n} from \"./reporters/index.js\";\nexport type {\n  ReportFormat,\n  ReportOptions,\n  ListFormat,\n} from \"./reporters/index.js\";\nexport { renderSarif } from \"./reporters/sarif.js\";\nexport type { SarifOptions } from \"./reporters/sarif.js\";\n// A finding's durable identity, so a caller filing or correlating findings\n// spells the id the same way every reporter does.\nexport { RULE_ID_PREFIX, TOOL_NAME, ruleId, ruleName } from \"./core/rule-id.js\";\n// Colour is the family's decision, made once in `src/shared/color.js`. These\n// are re-exported here so a library caller building lint's reports does not\n// have to reach for another tool's entry point to turn ANSI on or off.\nexport { palette, shouldColor } from \"../shared/color.js\";\nexport * from \"./types.js\";\n","/**\n * The key domain's programmatic API, exported from the package as the `key`\n * namespace: `import { key } from \"@hawkeyexl/manni\"`. The command cores, and\n * the family's encryption primitives a caller needs beside them.\n */\nexport * from \"./types.js\";\nexport { KeyError } from \"./errors.js\";\nexport { runKeySet } from \"./commands/set.js\";\nexport { runKeyRotate } from \"./commands/rotate.js\";\nexport { decryptValue, encryptValue, isEncryptedValue } from \"../shared/encryption.js\";\nexport type { EncryptionContext } from \"../shared/encryption.js\";\nexport { resolveEncryptionKey } from \"../shared/encryption-key.js\";\nexport type { KeySource, ResolvedKey } from \"../shared/encryption-key.js\";\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,qBAAAA;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA,sBAAAC;AAAA,EAAA;AAAA,oBAAAC;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA,qBAAAC;AAAA,EAAA;AAAA;AAAA;AAAA,gBAAAC;AAAA,EAAA;AAAA;AAAA,qBAAAC;AAAA,EAAA;AAAA,qBAAAC;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,6BAAAC;AAAA,EAAA;AAAA;AAAA;AAgBO,SAAS,cAAoB;AAClC,sBAAoB;AACpB,oBAAkB;AAClB,oBAAkB;AACpB;;;ACpBA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;","names":["classifyRef","listBuiltins","loadConfig","parseConfig","render","renderJunit","renderSarif","supportedExtensions"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hawkeyexl/manni",
-  "version": "3.0.0",
+  "version": "4.0.1",
   "description": "One command line for documentation that is meant to be checked. `manni meta` validates the presence and format of document metadata (Markdown frontmatter and more) against JSON Schema, built for CI. Formerly docmeta.",
   "type": "module",
   "bin": {
@@ -18,7 +18,9 @@
     "./package.json": "./package.json"
   },
   "files": [
-    "dist"
+    "dist",
+    "schemas",
+    "templates"
   ],
   "repository": {
     "type": "git",
@@ -47,6 +49,8 @@
     "lint": "eslint .",
     "check:deps": "node scripts/check-deps.mjs",
     "query:ui": "npm run build && node dist/cli.js meta query --db .manni/meta/query.db && node scripts/query-ui.mjs .manni/meta/query.db",
+    "check:tgdp-pin": "node scripts/lint-check-tgdp-pin.mjs",
+    "smoke:lint": "npm run build && node scripts/lint-smoke.mjs",
     "docs:check-cli": "node scripts/check-cli-reference.mjs",
     "docs:check-action": "node scripts/check-action-reference.mjs",
     "docs:check-api": "node scripts/check-api-reference.mjs",
@@ -77,6 +81,8 @@
     "esbuild": "^0.28.2"
   },
   "dependencies": {
+    "@apidevtools/json-schema-ref-parser": "^11.9.3",
+    "@asciidoctor/core": "^3.0.4",
     "@axe-core/playwright": "^4.13.0",
     "@hawkeyexl/inference": "^0.3.2",
     "@xmldom/xmldom": "^0.9.12",
@@ -86,11 +92,18 @@
     "commander": "^15.0.0",
     "fast-glob": "^3.3.2",
     "github-slugger": "^2.0.0",
+    "mdast-util-to-string": "^4.0.0",
     "parse5": "^8.0.1",
     "picocolors": "^1.1.1",
     "picomatch": "^4.0.7",
     "playwright-core": "^1.63.0",
+    "remark-frontmatter": "^5.0.0",
+    "remark-gfm": "^4.0.1",
+    "remark-mdx": "^3.1.1",
+    "remark-parse": "^11.0.0",
     "smol-toml": "^1.8.0",
+    "unified": "^11.0.5",
+    "unist-util-visit": "^5.1.0",
     "yaml": "^2.6.1"
   },
   "devDependencies": {
@@ -103,8 +116,10 @@
     "@semantic-release/github": "^12.0.8",
     "@semantic-release/npm": "^13.1.5",
     "@semantic-release/release-notes-generator": "^14.1.1",
+    "@types/mdast": "^4.0.4",
     "@types/node": "^26.3.0",
     "@types/picomatch": "^4.0.3",
+    "@types/unist": "^3.0.3",
     "@vitest/coverage-v8": "^4.1.11",
     "eslint": "^10.9.1",
     "globals": "^17.11.0",

package/schemas/lint/config.json

@@ -0,0 +1,73 @@
+{
+  "$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
+        }
+      }
+    }
+  }
+}

package/schemas/lint/template.json

@@ -0,0 +1,346 @@
+{
+  "$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" }
+      }
+    }
+  }
+}