@hawkeyexl/manni 2.12.1 → 4.0.0

package/dist/index.d.ts

@@ -311,7 +311,12 @@ interface FingerprintContext {
 /** One external-metadata manifest (proposals 0037, 0038, 0039) joined to a collection. */
 interface ExternalMetadataConfig {
     file: string;
-    keys: string[];
+    /**
+     * The top-level keys the manifest owns. Absent (proposal 0068), it owns
+     * what each page's schemas mark `x-manni-location: external`, as `ownsKey`
+     * decides.
+     */
+    keys?: string[];
     tokenEnv?: string;
     join?: string;
 }
@@ -356,9 +361,22 @@ interface ValeToolConfig {
     /** Vale's config file, as written, relative to `manni.config.yaml`. */
     config?: string;
 }
+/** DITA Open Toolkit's settings under `tools.dita-ot`. */
+interface DitaOtToolConfig {
+    /**
+     * DITA-OT's installation directory, as written, relative to
+     * `manni.config.yaml`. Unset means the `dita` on PATH.
+     *
+     * A directory rather than a path to the launcher, because that is the unit
+     * DITA-OT is distributed and documented as: the download unpacks to one
+     * directory, and `bin/dita` inside it will not run from anywhere else.
+     */
+    home?: string;
+}
 /** The document's top-level `tools:`, one namespace per outside tool. */
 interface ToolsConfig {
     vale?: ValeToolConfig;
+    "dita-ot"?: DitaOtToolConfig;
 }
 
 interface ConfigFile {
@@ -411,6 +429,158 @@ interface ConfigFile {
     encryptionKeyPrevious?: string;
 }
 
+interface BuiltinInfo$1 {
+    id: string;
+    title: string;
+    description: string;
+}
+/**
+ * A schema `meta.register` loaded from a local file (proposal 0070), named
+ * everywhere by its own `$id`, as a built-in is named by its id.
+ */
+interface RegisteredSchema {
+    /** The schema's `$id`: `vendor:name:version`, or an `https://` URL. */
+    id: string;
+    /** The file, relative to the config file's directory, with forward slashes. */
+    file: string;
+    /** The file's absolute path. */
+    path: string;
+    /** The parsed schema: the object every lookup of `id` returns. */
+    schema: Record<string, unknown>;
+}
+/** The registered schemas of one config, keyed by `$id`. */
+type RegisteredSchemas = ReadonlyMap<string, RegisteredSchema>;
+declare function listBuiltins$1(): BuiltinInfo$1[];
+type RefKind$1 = "builtin" | "file" | "url";
+declare function classifyRef$1(ref: string): {
+    kind: RefKind$1;
+    ref: string;
+};
+/**
+ * What a config recorded about one reference beyond the reference itself.
+ *
+ * Kept out of the ref string deliberately: the ref appears in every report,
+ * every baseline fingerprint, and `Validator`'s compile cache key, so it has to
+ * stay exactly the string the user wrote.
+ */
+interface SchemaPin {
+    /** Where the reference was vendored from — a URL, or a local path. */
+    source?: string;
+    /** `sha256-<64 hex>` the file's bytes must hash to. */
+    integrity?: string;
+}
+interface LoadSchemaOptions {
+    /**
+     * Directory a **relative local-file** ref is resolved against.
+     *
+     * Omitted means `process.cwd()`, which is what the CLI wants and what this
+     * always did. A library caller passing `cwd` to a command core needs the
+     * ref measured from *that* directory instead: `rebaseConfigSchemaRefs`
+     * deliberately leaves refs untouched when the config already sits in the
+     * run's `cwd`, so `./schema/house.json` arrives here exactly as written and
+     * was then read against the wrong directory.
+     *
+     * Resolved at read time rather than by rewriting the ref, and that choice is
+     * load-bearing: the ref string is what reports name, what `Validator` keys
+     * its compile cache on, and what every baseline fingerprint is taken over.
+     * Rewriting it to an absolute path would silently move every recorded
+     * baseline. `canonicalSchemaRef` in `baseline.ts` already measures a relative
+     * ref from the run's `cwd`, so this makes loading agree with fingerprinting
+     * rather than introducing a new convention.
+     */
+    fileBase?: string;
+    /** Abort a remote fetch after this many ms (default 10_000). */
+    timeoutMs?: number;
+    /** Reject a remote schema whose body exceeds this many bytes (default 5 MB). */
+    maxBytes?: number;
+    /**
+     * Directory for the cross-run schema cache. Omitted means **no disk cache**:
+     * the registry never guesses a project root, so a library caller gets the
+     * in-process behavior until it opts in. The command cores pass
+     * `schemaCacheDir(configDir ?? cwd)`.
+     */
+    cacheDir?: string;
+    /** Hours a cached entry stays fresh; `0` disables the cache (default 24). */
+    ttlHours?: number;
+    /**
+     * Never touch the network. A URL ref resolves from the disk cache — ignoring
+     * the TTL, since there is no re-fetch to fall back on — and an uncached one
+     * fails naming the URL. Built-ins and local files are unaffected.
+     *
+     * This is a *durability* control, not a trust boundary, and it never was:
+     * whether a document may name a URL at all is decided upstream by
+     * `schemaTrust` in `resolveSchemaSet`, which is the last place that still
+     * knows a ref came from a document rather than from an operator (proposal
+     * 0015). `offline` used to block that case by accident and was the only thing
+     * standing there; it is now free to mean only what it says.
+     */
+    offline?: boolean;
+    /**
+     * Provenance and integrity pins, keyed on the reference exactly as it is
+     * passed to `loadSchema`. Built by `collectSchemaPins` from the **rebased**
+     * config, so both sides spell a local path the same way; a config with no
+     * mapping-form `schemas:` entries produces an empty map and none of this
+     * runs.
+     */
+    pins?: ReadonlyMap<string, SchemaPin>;
+    /**
+     * The schemas `meta.register` loaded (proposal 0070), keyed by `$id`. A ref
+     * naming one resolves to its file's schema before anything else is
+     * consulted, so a registered `https://` id is never fetched.
+     */
+    registered?: RegisteredSchemas;
+}
+/** A fetched schema, with the bytes it arrived as. */
+interface FetchedSchema {
+    /** Exactly what the server sent, undecoded. */
+    bytes: Buffer;
+    /** The same payload, parsed and guarded. */
+    schema: Record<string, unknown>;
+}
+/**
+ * Fetch, size-cap, parse, and guard a remote schema. At most two requests.
+ *
+ * Exported for `schemas vendor`, which needs the raw bytes to write and to
+ * hash. Sharing this path rather than fetching separately is what keeps
+ * vendoring subject to the same size cap, retry policy, and payload guard as
+ * validation — a vendored error envelope would otherwise be committed to the
+ * repository and pass every document from then on.
+ *
+ * Deliberately **not** routed through the disk cache or `offline`: vendoring is
+ * an explicit request to download, and the cache stores a parsed schema rather
+ * than the bytes a pin has to be taken over.
+ */
+declare function fetchSchemaBytes(ref: string, options?: LoadSchemaOptions): Promise<FetchedSchema>;
+/**
+ * Settle the remote-schema options for one run, from the config and the flag.
+ *
+ * Lives here rather than in a command core because all three commands need the
+ * same answer, and because "where does the cache live" is a property of schema
+ * loading, not of `validate`. `root` is the config's directory when a config
+ * governs the run, so a developer running from `docs/` shares the cache with
+ * CI running from the repo root instead of quietly keeping a second one.
+ */
+declare function schemaLoadOptions(args: {
+    root: string;
+    /**
+     * Where a relative local-file schema ref is measured from — the run's `cwd`,
+     * not `root`. The two differ when a config was discovered in an ancestor, and
+     * a `--schema ./x.json` typed on the command line belongs to the directory
+     * the user was standing in, not to the config's.
+     */
+    fileBase?: string;
+    /** Config `schemaCache.ttlHours`. */
+    ttlHours?: number;
+    /** `--offline`, else config `offline:`. */
+    offline?: boolean;
+    /** From `collectSchemaPins(config)`; omitted when the config pins nothing. */
+    pins?: ReadonlyMap<string, SchemaPin>;
+    /** The config's registered schemas (`config.registered`), when it has any. */
+    registered?: RegisteredSchemas;
+}): LoadSchemaOptions;
+/** Load and return the JSON Schema object for a reference. */
+declare function loadSchema(ref: string, options?: LoadSchemaOptions): Promise<Record<string, unknown>>;
+
 /** Lines as an entry writes them: an integer for one line, `"L1-L2"` for several. */
 type LineSpec = number | string;
 /** Page lines as an editor numbers them, 1-based and inclusive. */
@@ -557,6 +727,16 @@ interface RangeResult {
 /** The seven built-in fields, in the order messages list them. */
 declare const DERIVABLE_FIELDS: readonly ["created", "last-updated", "authors", "owner", "reviewed-by", "last-reviewed", "provenance"];
 type BuiltinDerivableField = (typeof DERIVABLE_FIELDS)[number];
+/**
+ * The merge-safe fields (proposal 0069), in the order messages list them:
+ * the ones whose stamp, written in a pull request, still reads current after
+ * a squash merge. `derive.fields` absent manages these, and on each page only
+ * the ones its schemas claim.
+ */
+declare const MERGE_SAFE_FIELDS: readonly ["owner", "created", "last-updated", "provenance"];
+/** The dated fields the git source reads from the stamp a fact commit carries. */
+declare const STAMPED_DATE_FIELDS: readonly ["created", "last-updated"];
+type StampedDateField = (typeof STAMPED_DATE_FIELDS)[number];
 /**
  * A managed field name: one of the seven built-ins, or a key with an entry in
  * `derive.commands`. The config parser guarantees one or the other.
@@ -644,7 +824,14 @@ interface DeriveInput {
      * (proposal 0046), so evidence rule 2 reads the manifest's blob at each
      * commit rather than the page's frontmatter. Absent: the page's own.
      */
-    provenanceManifest?: ProvenanceManifestRef;
+    provenanceManifest?: ManifestRef;
+    /**
+     * Where the page's `created` and `last-updated` live when a manifest owns
+     * them (proposal 0069, rule 1), so the git source reads the stamp a fact
+     * commit carries from the manifest's blob at that commit as well as from
+     * the page's. A field with no entry: the page's own.
+     */
+    stampManifests?: Partial<Readonly<Record<StampedDateField, ManifestRef>>>;
     /**
      * `manni meta derive <path>:L1-L2 --generated-by <name>`: the file lines
      * each target names go to `generatedBy`, committed or not, unless evidence
@@ -657,8 +844,8 @@ interface DeriveInput {
         generatedBy: string;
     };
 }
-/** A manifest that holds one page's `provenance`, as the git source reads it at a commit. */
-interface ProvenanceManifestRef {
+/** A manifest that holds one page's managed field, as the git source reads it at a commit. */
+interface ManifestRef {
     /** The manifest file, absolute. */
     absPath: string;
     /** The page's key there: its path relative to the config directory, or its join value. */
@@ -801,6 +988,17 @@ interface SchemaOverride {
      * trap.
      */
     elements?: string[];
+    /**
+     * Put the default set first, then this entry's `schemas` (proposal 0070).
+     * Absent or `false` means the entry's `schemas` replace the set, as an
+     * override always did. An override never inherits the top-level `schemas`.
+     */
+    defaults?: boolean;
+    /**
+     * Stack the strict version of each default or registered schema in the
+     * entry's set right after its base, where one exists.
+     */
+    strict?: boolean;
 }
 /**
  * A `schemas:` entry in its long form: a reference plus where it came from and
@@ -886,8 +1084,12 @@ interface DeriveConfig {
      * The managed fields. Each is one of `DERIVABLE_FIELDS` or a key of
      * `commands`, never `$schema`, and never a key a manifest owns: a value
      * with two authorities has none.
+     *
+     * Absent means the merge-safe fields (`MERGE_SAFE_FIELDS`, proposal 0069),
+     * each managed only on a page whose schemas claim it as a top-level
+     * property. `[]` manages nothing. Read it through `managedFields`.
      */
-    fields: DerivableField[];
+    fields?: DerivableField[];
     /** Which sources to consult; absent means all of `DERIVE_SOURCES`. */
     sources?: DeriveSource[];
     /**
@@ -909,6 +1111,12 @@ interface DeriveConfig {
      * through `machinesOf`.
      */
     machines?: string[];
+    /**
+     * The collections whose members derive manages (proposal 0070). A file in
+     * none of them is neither stamped nor compared. Absent means every
+     * validated file. Read it through `deriveCovers`.
+     */
+    collections?: string[];
 }
 /** Defaults for the `fill` command; every key is overridable by a CLI flag. */
 interface FillConfig {
@@ -932,10 +1140,33 @@ interface SchemaCacheConfig {
 }
 interface DocmetaConfig {
     /**
-     * The default schema set. Each entry is either a reference string or a
-     * `{ ref, source?, integrity? }` mapping — see `SchemaEntry`.
+     * The schemas every file no override matches is judged by. Each entry is
+     * either a reference string or a `{ ref, source?, integrity? }` mapping —
+     * see `SchemaEntry`. They join the default set unless `defaults` is false.
      */
     schemas?: SchemaEntry[];
+    /**
+     * Put the default set first, then `schemas`, for the files no override
+     * matches (proposal 0070). Absent means `true`; `false` makes `schemas`
+     * replace the default set.
+     */
+    defaults?: boolean;
+    /**
+     * For those files, stack the strict version of each default or registered
+     * schema in the set right after its base, where one exists. Absent means
+     * `false`.
+     */
+    strict?: boolean;
+    /**
+     * JSON Schema files, or directories of them (`*.json`, recursively),
+     * relative to the config file. Each is loaded once and named by its `$id`.
+     */
+    register?: string[];
+    /**
+     * The schemas `register` names, loaded by `loadConfig` and keyed by `$id`.
+     * Not a key of the file: it is what the file's `register` produced.
+     */
+    registered?: RegisteredSchemas;
     overrides?: SchemaOverride[];
     /**
      * Named corpus checks `validate` runs after the per-file schemas, when the
@@ -990,7 +1221,7 @@ interface DocmetaConfig {
  * tool's config — a pre-family `docmeta.config.yaml`, or a section already
  * cut out of the family file.
  */
-declare function parseConfig(text: string, source: string): DocmetaConfig;
+declare function parseConfig$1(text: string, source: string): DocmetaConfig;
 interface LoadedConfig {
     config: DocmetaConfig;
     /** Absolute path to the file the config was read from. */
@@ -1071,7 +1302,7 @@ interface SchemaTrustRoot {
  *
  * Returns null when no config is found via discovery.
  */
-declare function loadConfig(explicitPath?: string, cwd?: string): Promise<LoadedConfig | null>;
+declare function loadConfig$1(explicitPath?: string, cwd?: string): Promise<LoadedConfig | null>;
 /** Told to a caller once, when a run turns out to be governed by a config. */
 interface ConfigNotice {
     /** Absolute path to the config file. */
@@ -1192,7 +1423,7 @@ interface RunConfig {
  */
 declare function resolveRunConfig(opts: RunConfigOptions): Promise<RunConfig>;
 
-interface ValidateOptions {
+interface ValidateOptions$1 {
     inputs: string[];
     cliSchemas?: string[];
     exts?: string[];
@@ -1284,7 +1515,7 @@ interface ValidateRun {
      */
     frame: FingerprintContext;
 }
-declare function runValidate(opts: ValidateOptions): Promise<ValidateRun>;
+declare function runValidate(opts: ValidateOptions$1): Promise<ValidateRun>;
 
 interface GetOptions {
     fields: string[];
@@ -1592,7 +1823,21 @@ declare function loadExternalMetadata(collections: readonly CollectionConfig[],
  */
 declare function mergeExternalMetadata(label: string, extracted: ExtractedMetadata, index: ExternalMetadataIndex | null, memberOf: readonly string[], base: string, options?: {
     encryptionKey?: () => string | undefined;
+    /**
+     * The top-level keys the document's schemas mark `x-manni-location:
+     * external` (proposal 0068), which is what a manifest with no `keys`
+     * owns. Absent, such a manifest owns nothing for this document.
+     */
+    marked?: ReadonlySet<string>;
 }): MergedMetadata;
+/**
+ * The top-level keys one document's schemas mark `x-manni-location:
+ * external`, read over `probe`: the document's metadata with everything its
+ * keyless manifests supply for it (proposal 0068). `undefined` when the
+ * document's schemas cannot be resolved or loaded, so the caller reports that
+ * the way it always has and a keyless manifest owns nothing for it.
+ */
+type PageMarks = (label: string, probe: Readonly<Record<string, unknown>>, memberOf: readonly string[]) => Promise<ReadonlySet<string> | undefined>;
 /** The `/key` pointer for an external-metadata finding, RFC 6901 escaped. */
 declare function externalMetadataPointer(key: string): string;
 /**
@@ -1622,188 +1867,60 @@ declare function orphanJoins(index: ExternalMetadataIndex | null, matched: Reado
 /** The operational error an orphan check raises, naming the first entry. */
 declare function orphanError(orphans: readonly ExternalMetadataEntry[]): DocmetaError;
 
-interface BuiltinInfo {
-    id: string;
-    title: string;
-    description: string;
-}
-declare function listBuiltins(): BuiltinInfo[];
-type RefKind = "builtin" | "file" | "url";
-declare function classifyRef(ref: string): {
-    kind: RefKind;
-    ref: string;
-};
 /**
- * What a config recorded about one reference beyond the reference itself.
+ * `x-manni-location` (proposal 0047): where a schema would like a top-level
+ * key's value stored, on the page or in external metadata.
  *
- * Kept out of the ref string deliberately: the ref appears in every report,
- * every baseline fingerprint, and `Validator`'s compile cache key, so it has to
- * stay exactly the string the user wrote.
+ * The keyword is registered on every Ajv meta builds (validator.ts), next to
+ * `x-manni-encrypt`, and like it records where it was evaluated. Ajv's own
+ * resolution is the walker, so a mark counts through `$ref`, `allOf` and a
+ * referenced built-in, and inside the `anyOf`, `oneOf` and `if`/`then`
+ * branches Ajv takes. Only top-level properties carry a preference; a nested
+ * mark is accepted and ignored. `Validator.locationPreferences` is the one
+ * question commands ask of it.
+ *
+ * One schema marking one key both ways is judged twice. Through `properties`,
+ * `allOf` and local `$ref` alone, it is refused when the schema compiles.
+ * Across conditional branches it is not an error: Ajv evaluates failing
+ * branches too, so that schema gives the key no preference.
  */
-interface SchemaPin {
-    /** Where the reference was vendored from — a URL, or a local path. */
-    source?: string;
-    /** `sha256-<64 hex>` the file's bytes must hash to. */
-    integrity?: string;
+/** The schema keyword. */
+declare const LOCATION_KEYWORD = "x-manni-location";
+/** Where a top-level key prefers to live. */
+type FieldLocation = "page" | "external";
+/** A key's preferred location, and the schema ref whose mark decided it. */
+interface LocationPreference {
+    location: FieldLocation;
+    /** The ref, as given to `locationPreferences`, whose mark won. */
+    schema: string;
 }
-interface LoadSchemaOptions {
+
+declare class Validator {
+    private readonly schemaOptions;
     /**
-     * Directory a **relative local-file** ref is resolved against.
-     *
-     * Omitted means `process.cwd()`, which is what the CLI wants and what this
-     * always did. A library caller passing `cwd` to a command core needs the
-     * ref measured from *that* directory instead: `rebaseConfigSchemaRefs`
-     * deliberately leaves refs untouched when the config already sits in the
-     * run's `cwd`, so `./schema/house.json` arrives here exactly as written and
-     * was then read against the wrong directory.
+     * How this validator's schemas are loaded: the disk cache location, its TTL,
+     * and `--offline`. Held per instance rather than read from module state, so
+     * two differently-configured validations in one process each get their own
+     * settings.
      *
-     * Resolved at read time rather than by rewriting the ref, and that choice is
-     * load-bearing: the ref string is what reports name, what `Validator` keys
-     * its compile cache on, and what every baseline fingerprint is taken over.
-     * Rewriting it to an absolute path would silently move every recorded
-     * baseline. `canonicalSchemaRef` in `baseline.ts` already measures a relative
-     * ref from the run's `cwd`, so this makes loading agree with fingerprinting
-     * rather than introducing a new convention.
+     * That is not full isolation, and the difference matters to a library
+     * caller: `schema-registry` keeps a process-wide memo of fetched schemas, so
+     * one validator's successful fetch is visible to another. `offline` is
+     * excluded from that sharing on purpose — an offline validator will not be
+     * served something this process pulled over the network — but the memo is
+     * still shared, so a URL fetched once is not re-fetched per instance.
      */
-    fileBase?: string;
-    /** Abort a remote fetch after this many ms (default 10_000). */
-    timeoutMs?: number;
-    /** Reject a remote schema whose body exceeds this many bytes (default 5 MB). */
-    maxBytes?: number;
+    constructor(schemaOptions?: LoadSchemaOptions);
+    private ajvByDialect;
     /**
-     * Directory for the cross-run schema cache. Omitted means **no disk cache**:
-     * the registry never guesses a project root, so a library caller gets the
-     * in-process behavior until it opts in. The command cores pass
-     * `schemaCacheDir(configDir ?? cwd)`.
-     */
-    cacheDir?: string;
-    /** Hours a cached entry stays fresh; `0` disables the cache (default 24). */
-    ttlHours?: number;
-    /**
-     * Never touch the network. A URL ref resolves from the disk cache — ignoring
-     * the TTL, since there is no re-fetch to fall back on — and an uncached one
-     * fails naming the URL. Built-ins and local files are unaffected.
-     *
-     * This is a *durability* control, not a trust boundary, and it never was:
-     * whether a document may name a URL at all is decided upstream by
-     * `schemaTrust` in `resolveSchemaSet`, which is the last place that still
-     * knows a ref came from a document rather than from an operator (proposal
-     * 0015). `offline` used to block that case by accident and was the only thing
-     * standing there; it is now free to mean only what it says.
-     */
-    offline?: boolean;
-    /**
-     * Provenance and integrity pins, keyed on the reference exactly as it is
-     * passed to `loadSchema`. Built by `collectSchemaPins` from the **rebased**
-     * config, so both sides spell a local path the same way; a config with no
-     * mapping-form `schemas:` entries produces an empty map and none of this
-     * runs.
-     */
-    pins?: ReadonlyMap<string, SchemaPin>;
-}
-/** A fetched schema, with the bytes it arrived as. */
-interface FetchedSchema {
-    /** Exactly what the server sent, undecoded. */
-    bytes: Buffer;
-    /** The same payload, parsed and guarded. */
-    schema: Record<string, unknown>;
-}
-/**
- * Fetch, size-cap, parse, and guard a remote schema. At most two requests.
- *
- * Exported for `schemas vendor`, which needs the raw bytes to write and to
- * hash. Sharing this path rather than fetching separately is what keeps
- * vendoring subject to the same size cap, retry policy, and payload guard as
- * validation — a vendored error envelope would otherwise be committed to the
- * repository and pass every document from then on.
- *
- * Deliberately **not** routed through the disk cache or `offline`: vendoring is
- * an explicit request to download, and the cache stores a parsed schema rather
- * than the bytes a pin has to be taken over.
- */
-declare function fetchSchemaBytes(ref: string, options?: LoadSchemaOptions): Promise<FetchedSchema>;
-/**
- * Settle the remote-schema options for one run, from the config and the flag.
- *
- * Lives here rather than in a command core because all three commands need the
- * same answer, and because "where does the cache live" is a property of schema
- * loading, not of `validate`. `root` is the config's directory when a config
- * governs the run, so a developer running from `docs/` shares the cache with
- * CI running from the repo root instead of quietly keeping a second one.
- */
-declare function schemaLoadOptions(args: {
-    root: string;
-    /**
-     * Where a relative local-file schema ref is measured from — the run's `cwd`,
-     * not `root`. The two differ when a config was discovered in an ancestor, and
-     * a `--schema ./x.json` typed on the command line belongs to the directory
-     * the user was standing in, not to the config's.
-     */
-    fileBase?: string;
-    /** Config `schemaCache.ttlHours`. */
-    ttlHours?: number;
-    /** `--offline`, else config `offline:`. */
-    offline?: boolean;
-    /** From `collectSchemaPins(config)`; omitted when the config pins nothing. */
-    pins?: ReadonlyMap<string, SchemaPin>;
-}): LoadSchemaOptions;
-/** Load and return the JSON Schema object for a reference. */
-declare function loadSchema(ref: string, options?: LoadSchemaOptions): Promise<Record<string, unknown>>;
-
-/**
- * `x-manni-location` (proposal 0047): where a schema would like a top-level
- * key's value stored, on the page or in external metadata.
- *
- * The keyword is registered on every Ajv meta builds (validator.ts), next to
- * `x-manni-encrypt`, and like it records where it was evaluated. Ajv's own
- * resolution is the walker, so a mark counts through `$ref`, `allOf` and a
- * referenced built-in, and inside the `anyOf`, `oneOf` and `if`/`then`
- * branches Ajv takes. Only top-level properties carry a preference; a nested
- * mark is accepted and ignored. `Validator.locationPreferences` is the one
- * question commands ask of it.
- *
- * One schema marking one key both ways is judged twice. Through `properties`,
- * `allOf` and local `$ref` alone, it is refused when the schema compiles.
- * Across conditional branches it is not an error: Ajv evaluates failing
- * branches too, so that schema gives the key no preference.
- */
-/** The schema keyword. */
-declare const LOCATION_KEYWORD = "x-manni-location";
-/** Where a top-level key prefers to live. */
-type FieldLocation = "page" | "external";
-/** A key's preferred location, and the schema ref whose mark decided it. */
-interface LocationPreference {
-    location: FieldLocation;
-    /** The ref, as given to `locationPreferences`, whose mark won. */
-    schema: string;
-}
-
-declare class Validator {
-    private readonly schemaOptions;
-    /**
-     * How this validator's schemas are loaded: the disk cache location, its TTL,
-     * and `--offline`. Held per instance rather than read from module state, so
-     * two differently-configured validations in one process each get their own
-     * settings.
-     *
-     * That is not full isolation, and the difference matters to a library
-     * caller: `schema-registry` keeps a process-wide memo of fetched schemas, so
-     * one validator's successful fetch is visible to another. `offline` is
-     * excluded from that sharing on purpose — an offline validator will not be
-     * served something this process pulled over the network — but the memo is
-     * still shared, so a URL fetched once is not re-fetched per instance.
-     */
-    constructor(schemaOptions?: LoadSchemaOptions);
-    private ajvByDialect;
-    /**
-     * Keyed on the in-flight *promise*, not the resolved validator. Caching the
-     * result made this a check-then-act race: `fill` walks files through a worker
-     * pool, so every worker missed the cache while the first `loadSchema` was
-     * still pending and they all then compiled the same schema into the one
-     * shared per-dialect Ajv. Ajv registers a schema's `$id` on the first compile
-     * and rejects the second with "schema with key or id ... already exists",
-     * which took down any multi-file run against an $id-bearing schema. Storing
-     * the promise before the first await lets the losers await the one compile.
+     * Keyed on the in-flight *promise*, not the resolved validator. Caching the
+     * result made this a check-then-act race: `fill` walks files through a worker
+     * pool, so every worker missed the cache while the first `loadSchema` was
+     * still pending and they all then compiled the same schema into the one
+     * shared per-dialect Ajv. Ajv registers a schema's `$id` on the first compile
+     * and rejects the second with "schema with key or id ... already exists",
+     * which took down any multi-file run against an $id-bearing schema. Storing
+     * the promise before the first await lets the losers await the one compile.
      */
     private cache;
     private ajvFor;
@@ -1843,6 +1960,16 @@ declare class Validator {
      * whose evaluated branches say both gives that key no preference.
      */
     locationPreferences(data: Record<string, unknown>, refs: string[]): Promise<Map<string, LocationPreference>>;
+    /**
+     * The top-level property names the schemas in `refs` claim: the keys of
+     * each schema's own `properties`, each once. What a page's schema set
+     * claims decides which merge-safe fields a `derive:` block with no `fields`
+     * manages on it (proposal 0069). A property reached only through `allOf`,
+     * `$ref` or a conditional is not counted, so a schema that should manage a
+     * field names it in its root `properties`. A schema that fails to load or
+     * compile throws, as it would for `validate`.
+     */
+    claimedProperties(refs: readonly string[]): Promise<Set<string>>;
     /**
      * Validate `data` against every schema in `refs`. Returns all violations,
      * each tagged with the schema that produced it and a source line via
@@ -2129,8 +2256,16 @@ interface QueryRun {
 }
 declare function runQuery(opts: QueryOptions): Promise<QueryRun>;
 
+/** One schema `meta.register` loaded: its `$id` and its file. */
+interface RegisteredInfo {
+    id: string;
+    /** Relative to the config file, with forward slashes. */
+    file: string;
+}
 interface SchemasInfo {
-    builtins: BuiltinInfo[];
+    builtins: BuiltinInfo$1[];
+    /** The governing config's registered schemas (proposal 0070). */
+    registered: RegisteredInfo[];
     formats: {
         name: string;
         extensions: string[];
@@ -2138,7 +2273,7 @@ interface SchemasInfo {
         writable: boolean;
     }[];
 }
-declare function getSchemasInfo(): SchemasInfo;
+declare function getSchemasInfo(registered?: RegisteredSchemas): SchemasInfo;
 /**
  * Where a vendored schema lands by default.
  *
@@ -2202,7 +2337,7 @@ declare function runVendorSchema(opts: VendorOptions): Promise<VendorResult>;
 /** Shared shapes for the `fill` command, split out to keep imports acyclic. */
 
 /** Why a proposed value was not written. */
-type SkipReason = 
+type SkipReason$1 = 
 /** Self-reported confidence was below the threshold. */
 "low-confidence"
 /** Writing it would leave the document failing its own schema. */
@@ -2227,7 +2362,7 @@ interface FilledField {
      */
     value?: unknown;
     written: boolean;
-    skipReason?: SkipReason;
+    skipReason?: SkipReason$1;
     /**
      * The value was written encrypted, because the field's schema marks it
      * `x-manni-encrypt`. Absent otherwise.
@@ -2381,6 +2516,17 @@ interface FillOptions {
     concurrency?: number;
     /** Include the filled document on each result (used for stdin and tests). */
     includeContent?: boolean;
+    /**
+     * The glossary term labels offered for the fields that name a term. When
+     * given, they are used instead of the registered term label source (see
+     * `src/shared/term-labels.ts`). When absent, that source is used, if any.
+     *
+     * Labels only. The registered source also knows each term's id, which a
+     * term relation (`broader`, `narrower`, `related-terms`, `see`) accepts as
+     * `term check` does. With `termLabels`, no ids are known, so a relation
+     * value must be a label; an id is retried and then skipped.
+     */
+    termLabels?: readonly string[];
     /** Test seam: bypasses `makeProvider`, so no API key is needed. */
     inferenceProvider?: InferenceProvider;
     /**
@@ -2606,11 +2752,15 @@ declare function reencryptMetadata(page: {
 }): ReencryptMetadataResult;
 
 /**
- * Applied when nothing else resolves. Seven-Action is safe to include here
- * because it constrains `action` — a key documents don't otherwise carry — and
- * does not require it, so adding it fails nothing that passed before.
- * Diataxis is deliberately absent: it both requires and constrains `type`, so
- * defaulting it would fail every repo not already on Diataxis.
+ * The default set (proposal 0070): what a file is judged by when nothing
+ * replaces it, and what `schemas:` joins unless `defaults: false`.
+ *
+ * Seven-Action constrains `action`, a key documents don't otherwise carry,
+ * and requires nothing. Diataxis is deliberately absent: it both requires and
+ * constrains `type`, so defaulting it would fail every repo not already on
+ * Diataxis. The manni vocabularies follow; core requires `title` and
+ * `description`, and nothing else in the set requires anything.
+ * Terminology, artifact-evals and every `-strict` overlay stay opt-in.
  */
 declare const DEFAULT_SCHEMAS: readonly string[];
 /**
@@ -3177,13 +3327,13 @@ declare class SchemaCache {
     write(url: string, schema: Record<string, unknown>): Promise<boolean>;
 }
 
-interface SarifOptions {
+interface SarifOptions$1 {
     /** The run's path frame. Without one, `file` labels are emitted as they are. */
     frame?: FingerprintContext;
     /** Diagnostics for the user; the CLI writes these to stderr. */
     onNotice?: (message: string) => void;
 }
-declare function renderSarif(results: ValidationResult[], opts?: SarifOptions): string;
+declare function renderSarif$1(results: ValidationResult[], opts?: SarifOptions$1): string;
 
 /**
  * JUnit XML — what CI systems parse for the "Tests" tab.
@@ -3231,7 +3381,7 @@ interface JunitOptions {
      */
     frame?: FingerprintContext;
 }
-declare function renderJunit(results: ValidationResult[], opts?: JunitOptions): string;
+declare function renderJunit$1(results: ValidationResult[], opts?: JunitOptions): string;
 
 /**
  * Reporters render validation results to a string. The command layer writes
@@ -3249,8 +3399,8 @@ declare function renderJunit(results: ValidationResult[], opts?: JunitOptions):
  * runtime. Deriving the union from the array makes that drift impossible.
  */
 declare const REPORT_FORMATS: readonly ["pretty", "json", "github", "sarif", "junit"];
-type ReportFormat = (typeof REPORT_FORMATS)[number];
-declare function isReportFormat(value: string): value is ReportFormat;
+type ReportFormat$1 = (typeof REPORT_FORMATS)[number];
+declare function isReportFormat(value: string): value is ReportFormat$1;
 /**
  * The formats **every** command produces.
  *
@@ -3276,13 +3426,13 @@ declare function isCommonFormat(value: string): value is CommonFormat;
 declare const QUERY_FORMATS: readonly ["pretty", "json", "csv", "github", "sarif", "junit"];
 type QueryFormat = (typeof QUERY_FORMATS)[number];
 declare function isQueryFormat(value: string): value is QueryFormat;
-interface ReportOptions extends SarifOptions, JunitOptions {
+interface ReportOptions$1 extends SarifOptions$1, JunitOptions {
     color?: boolean;
     /** In pretty output, omit passing files. */
     quiet?: boolean;
 }
 
-declare function render(format: ReportFormat, results: ValidationResult[], summary: RunSummary, opts?: ReportOptions): string;
+declare function render$1(format: ReportFormat$1, results: ValidationResult[], summary: RunSummary, opts?: ReportOptions$1): string;
 
 /**
  * Every value `fill -f` accepts, in the order help and error messages list
@@ -3333,7 +3483,7 @@ declare function renderFill(format: FillReportFormat, run: FillRun, opts?: FillR
 declare const DERIVE_FORMATS: readonly ["pretty", "json", "github", "sarif", "junit"];
 type DeriveReportFormat = (typeof DERIVE_FORMATS)[number];
 declare function isDeriveFormat(value: string): value is DeriveReportFormat;
-type DeriveReportOptions = ReportOptions;
+type DeriveReportOptions = ReportOptions$1;
 declare function renderDerive(run: DeriveRun, format: DeriveReportFormat, opts?: DeriveReportOptions): string;
 
 /**
@@ -3491,7 +3641,7 @@ options?: {
 /** Resolve the extractor for a file extension (incl. dot). */
 declare function extractorForExtension(ext: string): MetadataExtractor | undefined;
 /** Extensions handled by registered extractors (used for directory walks). */
-declare function supportedExtensions(): string[];
+declare function supportedExtensions$1(): string[];
 
 type KeySource = "env" | "config" | "none";
 interface ResolvedKey {
@@ -3542,7 +3692,7 @@ interface CitationSource {
     /** The git commit hash the pin was taken at: 7 to 64 lowercase hex. */
     "commit-sha"?: string;
 }
-/** One entry of `citations`, as the schema (`manni:citations:1.0.0-proposal.4`) spells it. */
+/** One entry of `citations`, as the schema (`manni:citations:1.0.0`) spells it. */
 interface Citation {
     id?: string;
     claim?: CitationClaim;
@@ -4324,9 +4474,9 @@ declare class CiteError extends ToolError {
  */
 
 declare const DEFAULT_SEVERITY: Readonly<Record<CiteRule, CiteSeverity>>;
-declare const RULE_ID_PREFIX = "manni:cite";
+declare const RULE_ID_PREFIX$1 = "manni:cite";
 /** `manni:cite/<rule>`: the SARIF rule id and the JUnit failure type. */
-declare function ruleId(rule: CiteRule): string;
+declare function ruleId$1(rule: CiteRule): string;
 declare function isCiteRule(value: string): value is CiteRule;
 /** The effective severity table: defaults with the config's overrides. */
 declare function resolveSeverity(overrides?: Partial<Record<CiteRule, CiteSeverity>>): Record<CiteRule, CiteSeverity>;
@@ -4992,6 +5142,47 @@ declare function shiftedEntries(opts: ShiftOptions): Shifted;
 /** A copy of a manifest entry with its `claim.lines` replaced. */
 declare function withClaimLines(entry: unknown, lines: LineSpec): unknown;
 
+declare const STDIN_TOKEN = "-";
+
+interface SpliceManifestOptions {
+    /**
+     * The document entry: its path relative to the config's directory, or its
+     * value of the join field when `join` names one. A path entry matches
+     * however the manifest spells it (`./docs/a.md` is `docs/a.md`); a join
+     * value matches exactly.
+     */
+    entry: string;
+    /** The owned key to write. */
+    key: string;
+    /** The value to write. Mappings and lists are written in block style. */
+    value: unknown;
+    /** `path` (the default) or the frontmatter field the manifest joins on. */
+    join?: string;
+    /** The manifest as the run reports it, for error messages. */
+    file?: string;
+}
+interface SplicedManifest {
+    /** The whole manifest, with the one value rewritten. */
+    text: string;
+    /** 1-based line where the written value now starts. */
+    line: number;
+}
+/**
+ * Rewrite `options.key` of `options.entry` in the manifest `text` to
+ * `options.value`, and return the new text and the line the value starts on.
+ *
+ * Throws `DocmetaError`, and never returns a partial result, when:
+ *  - the text is not valid YAML, or its top level is not a mapping;
+ *  - the entry is named twice, or is not a mapping;
+ *  - the key is set twice in the entry, or is `$schema`;
+ *  - the value is `undefined`;
+ *  - the key or entry is absent and would go into a flow mapping that has
+ *    members (`{ jira: A }`), which this writer does not add to;
+ *  - the key is written as an explicit `? key`;
+ *  - the result does not read back as written.
+ */
+declare function spliceManifestValue(text: string, options: SpliceManifestOptions): SplicedManifest;
+
 /** The one key cite keeps in a manifest. */
 declare const CITATIONS_KEY = "citations";
 /** A manifest that owns `citations` for one collection. */
@@ -5011,6 +5202,15 @@ interface CitationManifest {
      * created by the first write.
      */
     pattern?: string;
+    /**
+     * The manifest names no `keys` (proposal 0068), so it keeps a page's
+     * citations only when the page's schemas mark `citations` external. The
+     * declaration, for `ownsKey`.
+     */
+    implied?: {
+        collection: CollectionConfig;
+        manifest: ExternalMetadataConfig;
+    };
 }
 /** Where one page's citations are kept, and what the manifest already holds. */
 interface PageSidecar {
@@ -5035,7 +5235,7 @@ interface CitationSidecars {
     configDir: string;
     /** Directory the run's file labels are relative to. */
     base: string;
-    forPage(label: string, content: string, format?: string): PageSidecar;
+    forPage(label: string, content: string, format?: string): Promise<PageSidecar>;
     /**
      * Manifest entries naming a page this run did not load, under meta's own
      * corpus invariant. `covered` names the collections a `--collection` run
@@ -5069,6 +5269,11 @@ interface LoadSidecarOptions {
     key?: string;
     /** The tool's error class; `CiteError` unless a sibling command says otherwise. */
     toError?: (message: string) => Error;
+    /**
+     * What a page's schemas mark external (proposal 0068), asked only for a
+     * page a manifest with no `keys` may keep citations for.
+     */
+    marks?: () => Promise<PageMarks | undefined>;
 }
 /** `collection <name>: citations cannot come from a URL manifest, because cite writes them.` */
 declare function urlManifestRefusal(source: string, collection: string): string;
@@ -5106,45 +5311,6 @@ declare function sidecarsFor(run: CiteRun, over?: {
     pages?: readonly string[];
 }): Promise<CitationSidecars | null>;
 
-interface SpliceManifestOptions {
-    /**
-     * The document entry: its path relative to the config's directory, or its
-     * value of the join field when `join` names one. A path entry matches
-     * however the manifest spells it (`./docs/a.md` is `docs/a.md`); a join
-     * value matches exactly.
-     */
-    entry: string;
-    /** The owned key to write. */
-    key: string;
-    /** The value to write. Mappings and lists are written in block style. */
-    value: unknown;
-    /** `path` (the default) or the frontmatter field the manifest joins on. */
-    join?: string;
-    /** The manifest as the run reports it, for error messages. */
-    file?: string;
-}
-interface SplicedManifest {
-    /** The whole manifest, with the one value rewritten. */
-    text: string;
-    /** 1-based line where the written value now starts. */
-    line: number;
-}
-/**
- * Rewrite `options.key` of `options.entry` in the manifest `text` to
- * `options.value`, and return the new text and the line the value starts on.
- *
- * Throws `DocmetaError`, and never returns a partial result, when:
- *  - the text is not valid YAML, or its top level is not a mapping;
- *  - the entry is named twice, or is not a mapping;
- *  - the key is set twice in the entry, or is `$schema`;
- *  - the value is `undefined`;
- *  - the key or entry is absent and would go into a flow mapping that has
- *    members (`{ jira: A }`), which this writer does not add to;
- *  - the key is written as an explicit `? key`;
- *  - the result does not read back as written.
- */
-declare function spliceManifestValue(text: string, options: SpliceManifestOptions): SplicedManifest;
-
 /** One entry's one key: what an edit rewrites, and what a conflict is about. */
 interface ManifestKey {
     /** The entry, as the manifest spells it. */
@@ -5517,6 +5683,15 @@ declare function reencryptCitationEntries(page: {
 type Colors = ReturnType<typeof pc.createColors>;
 /** Build a picocolors palette with color explicitly on or off. */
 declare function palette(enabled: boolean): Colors;
+/**
+ * Decide whether to emit ANSI color: off when `--no-color`/`NO_COLOR`, on only
+ * for a TTY otherwise. `forced` (from `--color`) overrides detection.
+ */
+declare function shouldColor(opts: {
+    noColor?: boolean;
+    isTTY?: boolean;
+    env?: NodeJS.ProcessEnv;
+}): boolean;
 
 /**
  * Pretty output for `check` and `update`.
@@ -5574,229 +5749,1530 @@ declare function renderCheckGithub(run: CheckRun): string;
  * `cite` namespace: `import { cite } from "@hawkeyexl/manni"`.
  */
 
-type index$1_AddOptions = AddOptions;
-type index$1_AddResult = AddResult;
-type index$1_BuildIndexOptions = BuildIndexOptions;
-declare const index$1_CITATIONS_KEY: typeof CITATIONS_KEY;
-declare const index$1_CITE_RULES: typeof CITE_RULES;
-declare const index$1_CITE_SECTION: typeof CITE_SECTION;
-type index$1_CheckOptions = CheckOptions;
-type index$1_CheckPageOptions = CheckPageOptions;
-type index$1_CheckRun = CheckRun;
-type index$1_Citation = Citation;
-type index$1_CitationAnchor = CitationAnchor;
-type index$1_CitationClaim = CitationClaim;
-type index$1_CitationFinding = CitationFinding;
-type index$1_CitationInput = CitationInput;
-type index$1_CitationManifest = CitationManifest;
-type index$1_CitationOrigin = CitationOrigin;
-type index$1_CitationResult = CitationResult;
-type index$1_CitationSidecars = CitationSidecars;
-type index$1_CitationSource = CitationSource;
-type index$1_CiteConfig = CiteConfig;
-type index$1_CiteError = CiteError;
-declare const index$1_CiteError: typeof CiteError;
-type index$1_CiteRule = CiteRule;
-type index$1_CiteRun = CiteRun;
-type index$1_CiteRunOptions = CiteRunOptions;
-type index$1_CiteSeverity = CiteSeverity;
-type index$1_ClaimEnd = ClaimEnd;
-type index$1_ClaimHistory = ClaimHistory;
-type index$1_ClaimHistoryInput = ClaimHistoryInput;
-type index$1_ClaimStatus = ClaimStatus;
-type index$1_ClaimUnit = ClaimUnit;
-type index$1_ClassifyOptions = ClassifyOptions;
-declare const index$1_DEFAULT_CITE_BASELINE_PATH: typeof DEFAULT_CITE_BASELINE_PATH;
-declare const index$1_DEFAULT_SEVERITY: typeof DEFAULT_SEVERITY;
-type index$1_EntryPath = EntryPath;
-declare const index$1_FILE_PATTERN: typeof FILE_PATTERN;
-type index$1_FindWindowsOptions = FindWindowsOptions;
-declare const index$1_GIT_UNAVAILABLE_COMMIT: typeof GIT_UNAVAILABLE_COMMIT;
-declare const index$1_GIT_UNAVAILABLE_HISTORY: typeof GIT_UNAVAILABLE_HISTORY;
-type index$1_GitClient = GitClient;
-type index$1_HeldManifest = HeldManifest;
-type index$1_History = History;
-type index$1_InlineStatement = InlineStatement;
-type index$1_LineSpec = LineSpec;
-type index$1_LoadSidecarOptions = LoadSidecarOptions;
-type index$1_LoadedCiteConfig = LoadedCiteConfig;
-declare const index$1_MARKER_JSON: typeof MARKER_JSON;
-declare const index$1_MAX_MARKERS_PER_PAGE: typeof MAX_MARKERS_PER_PAGE;
-declare const index$1_MAX_PAGE_COMMITS: typeof MAX_PAGE_COMMITS;
-declare const index$1_MAX_RANGE_LINES: typeof MAX_RANGE_LINES;
-declare const index$1_MOVE_BUDGET_BYTES: typeof MOVE_BUDGET_BYTES;
-declare const index$1_MOVE_WINDOW_LINES: typeof MOVE_WINDOW_LINES;
-type index$1_ManifestSet = ManifestSet;
-declare const index$1_ManifestSet: typeof ManifestSet;
-type index$1_ManifestWrite = ManifestWrite;
-type index$1_MarkerEnd = MarkerEnd;
-type index$1_MintOptions = MintOptions;
-type index$1_MisplacedMarker = MisplacedMarker;
-type index$1_MisplacedMarkerReport = MisplacedMarkerReport;
-type index$1_MissingReason = MissingReason;
-type index$1_NoUnit = NoUnit;
-type index$1_OriginKind = OriginKind;
-declare const index$1_PAGE_HISTORY_UNAVAILABLE: typeof PAGE_HISTORY_UNAVAILABLE;
-type index$1_PageCitation = PageCitation;
-type index$1_PageCitationReport = PageCitationReport;
-type index$1_PageCitations = PageCitations;
-type index$1_PageCommit = PageCommit;
-type index$1_PageHistory = PageHistory;
-type index$1_PageLines = PageLines;
-type index$1_PageSidecar = PageSidecar;
-type index$1_PrettyOptions = PrettyOptions;
+type index$2_AddOptions = AddOptions;
+type index$2_AddResult = AddResult;
+type index$2_BuildIndexOptions = BuildIndexOptions;
+declare const index$2_CITATIONS_KEY: typeof CITATIONS_KEY;
+declare const index$2_CITE_RULES: typeof CITE_RULES;
+declare const index$2_CITE_SECTION: typeof CITE_SECTION;
+type index$2_CheckOptions = CheckOptions;
+type index$2_CheckPageOptions = CheckPageOptions;
+type index$2_CheckRun = CheckRun;
+type index$2_Citation = Citation;
+type index$2_CitationAnchor = CitationAnchor;
+type index$2_CitationClaim = CitationClaim;
+type index$2_CitationFinding = CitationFinding;
+type index$2_CitationInput = CitationInput;
+type index$2_CitationManifest = CitationManifest;
+type index$2_CitationOrigin = CitationOrigin;
+type index$2_CitationResult = CitationResult;
+type index$2_CitationSidecars = CitationSidecars;
+type index$2_CitationSource = CitationSource;
+type index$2_CiteConfig = CiteConfig;
+type index$2_CiteError = CiteError;
+declare const index$2_CiteError: typeof CiteError;
+type index$2_CiteRule = CiteRule;
+type index$2_CiteRun = CiteRun;
+type index$2_CiteRunOptions = CiteRunOptions;
+type index$2_CiteSeverity = CiteSeverity;
+type index$2_ClaimEnd = ClaimEnd;
+type index$2_ClaimHistory = ClaimHistory;
+type index$2_ClaimHistoryInput = ClaimHistoryInput;
+type index$2_ClaimStatus = ClaimStatus;
+type index$2_ClaimUnit = ClaimUnit;
+type index$2_ClassifyOptions = ClassifyOptions;
+declare const index$2_DEFAULT_CITE_BASELINE_PATH: typeof DEFAULT_CITE_BASELINE_PATH;
+declare const index$2_DEFAULT_SEVERITY: typeof DEFAULT_SEVERITY;
+type index$2_EntryPath = EntryPath;
+declare const index$2_FILE_PATTERN: typeof FILE_PATTERN;
+type index$2_FindWindowsOptions = FindWindowsOptions;
+declare const index$2_GIT_UNAVAILABLE_COMMIT: typeof GIT_UNAVAILABLE_COMMIT;
+declare const index$2_GIT_UNAVAILABLE_HISTORY: typeof GIT_UNAVAILABLE_HISTORY;
+type index$2_GitClient = GitClient;
+type index$2_HeldManifest = HeldManifest;
+type index$2_History = History;
+type index$2_InlineStatement = InlineStatement;
+type index$2_LineSpec = LineSpec;
+type index$2_LoadSidecarOptions = LoadSidecarOptions;
+type index$2_LoadedCiteConfig = LoadedCiteConfig;
+declare const index$2_MARKER_JSON: typeof MARKER_JSON;
+declare const index$2_MAX_MARKERS_PER_PAGE: typeof MAX_MARKERS_PER_PAGE;
+declare const index$2_MAX_PAGE_COMMITS: typeof MAX_PAGE_COMMITS;
+declare const index$2_MAX_RANGE_LINES: typeof MAX_RANGE_LINES;
+declare const index$2_MOVE_BUDGET_BYTES: typeof MOVE_BUDGET_BYTES;
+declare const index$2_MOVE_WINDOW_LINES: typeof MOVE_WINDOW_LINES;
+type index$2_ManifestSet = ManifestSet;
+declare const index$2_ManifestSet: typeof ManifestSet;
+type index$2_ManifestWrite = ManifestWrite;
+type index$2_MarkerEnd = MarkerEnd;
+type index$2_MintOptions = MintOptions;
+type index$2_MisplacedMarker = MisplacedMarker;
+type index$2_MisplacedMarkerReport = MisplacedMarkerReport;
+type index$2_MissingReason = MissingReason;
+type index$2_NoUnit = NoUnit;
+type index$2_OriginKind = OriginKind;
+declare const index$2_PAGE_HISTORY_UNAVAILABLE: typeof PAGE_HISTORY_UNAVAILABLE;
+type index$2_PageCitation = PageCitation;
+type index$2_PageCitationReport = PageCitationReport;
+type index$2_PageCitations = PageCitations;
+type index$2_PageCommit = PageCommit;
+type index$2_PageHistory = PageHistory;
+type index$2_PageLines = PageLines;
+type index$2_PageSidecar = PageSidecar;
+type index$2_PrettyOptions = PrettyOptions;
+type index$2_ReadPageOptions = ReadPageOptions;
+type index$2_ReadSourceResult = ReadSourceResult;
+type index$2_RecommitReason = RecommitReason;
+type index$2_ReencryptCitationsResult = ReencryptCitationsResult;
+type index$2_ReencryptEntriesResult = ReencryptEntriesResult;
+type index$2_ReencryptOptions = ReencryptOptions;
+type index$2_ReencryptedCitation = ReencryptedCitation;
+type index$2_RefineClaimInput = RefineClaimInput;
+type index$2_Removal = Removal;
+type index$2_RemoveOptions = RemoveOptions;
+type index$2_RemovePage = RemovePage;
+type index$2_RemoveRun = RemoveRun;
+declare const index$2_SRC_PATTERN: typeof SRC_PATTERN;
+type index$2_ShiftOptions = ShiftOptions;
+type index$2_Shifted = Shifted;
+type index$2_ShownFile = ShownFile;
+type index$2_SourceEnd = SourceEnd;
+type index$2_SourceIndex = SourceIndex;
+type index$2_SourceRange = SourceRange;
+type index$2_SourceStatus = SourceStatus;
+type index$2_StatementForm = StatementForm;
+type index$2_TextEdit = TextEdit;
+type index$2_UpdateOptions = UpdateOptions;
+type index$2_UpdatePage = UpdatePage;
+type index$2_UpdateRewrite = UpdateRewrite;
+type index$2_UpdateRun = UpdateRun;
+declare const index$2_anchoredLines: typeof anchoredLines;
+declare const index$2_appendFrontmatterCitation: typeof appendFrontmatterCitation;
+declare const index$2_blockMatches: typeof blockMatches;
+declare const index$2_bodyLineOf: typeof bodyLineOf;
+declare const index$2_buildSourceIndex: typeof buildSourceIndex;
+declare const index$2_checkCitations: typeof checkCitations;
+declare const index$2_citationInputs: typeof citationInputs;
+declare const index$2_claimDiff: typeof claimDiff;
+declare const index$2_claimEnd: typeof claimEnd;
+declare const index$2_claimHistory: typeof claimHistory;
+declare const index$2_claimLine: typeof claimLine;
+declare const index$2_claimMessageFor: typeof claimMessageFor;
+declare const index$2_claimWords: typeof claimWords;
+declare const index$2_classifyCitation: typeof classifyCitation;
+declare const index$2_detectEol: typeof detectEol;
+declare const index$2_duplicateJoinRefusal: typeof duplicateJoinRefusal;
+declare const index$2_entryObject: typeof entryObject;
+declare const index$2_errorSite: typeof errorSite;
+declare const index$2_fenceSpanAt: typeof fenceSpanAt;
+declare const index$2_fencedBlockAfter: typeof fencedBlockAfter;
+declare const index$2_fencedBlockAt: typeof fencedBlockAt;
+declare const index$2_fencedBlocks: typeof fencedBlocks;
+declare const index$2_findWindows: typeof findWindows;
+declare const index$2_findingsFor: typeof findingsFor;
+declare const index$2_formatSrc: typeof formatSrc;
+declare const index$2_formatStatement: typeof formatStatement;
+declare const index$2_gitClient: typeof gitClient;
+declare const index$2_hashLines: typeof hashLines;
+declare const index$2_hashRange: typeof hashRange;
+declare const index$2_historyOf: typeof historyOf;
+declare const index$2_holdsWords: typeof holdsWords;
+declare const index$2_insertStatementBefore: typeof insertStatementBefore;
+declare const index$2_insideFence: typeof insideFence;
+declare const index$2_isBoundLine: typeof isBoundLine;
+declare const index$2_isCiteRule: typeof isCiteRule;
+declare const index$2_isKeyedPin: typeof isKeyedPin;
+declare const index$2_isTableRow: typeof isTableRow;
+declare const index$2_isUnitText: typeof isUnitText;
+declare const index$2_itemLine: typeof itemLine;
+declare const index$2_lineAt: typeof lineAt;
+declare const index$2_lineSpec: typeof lineSpec;
+declare const index$2_loadCitationSidecars: typeof loadCitationSidecars;
+declare const index$2_loadCiteConfig: typeof loadCiteConfig;
+declare const index$2_markerClaimEnd: typeof markerClaimEnd;
+declare const index$2_markerRunAt: typeof markerRunAt;
+declare const index$2_markerUnit: typeof markerUnit;
+declare const index$2_messageFor: typeof messageFor;
+declare const index$2_mintCitation: typeof mintCitation;
+declare const index$2_misplacedMarkerAt: typeof misplacedMarkerAt;
+declare const index$2_misplacedMarkers: typeof misplacedMarkers;
+declare const index$2_misplacedMessageFor: typeof misplacedMessageFor;
+declare const index$2_movedUnit: typeof movedUnit;
+declare const index$2_noGit: typeof noGit;
+declare const index$2_noUnitAt: typeof noUnitAt;
+declare const index$2_normalizeText: typeof normalizeText;
+declare const index$2_normalizeWhitespace: typeof normalizeWhitespace;
+declare const index$2_offsetOfLine: typeof offsetOfLine;
+declare const index$2_orphanRefusal: typeof orphanRefusal;
+declare const index$2_ownedMessage: typeof ownedMessage;
+declare const index$2_paragraphAfter: typeof paragraphAfter;
+declare const index$2_parseCiteConfig: typeof parseCiteConfig;
+declare const index$2_parseLines: typeof parseLines;
+declare const index$2_parseSrc: typeof parseSrc;
+declare const index$2_parseStatements: typeof parseStatements;
+declare const index$2_pickExtractor: typeof pickExtractor;
+declare const index$2_pinOfLines: typeof pinOfLines;
+declare const index$2_pre43Span: typeof pre43Span;
+declare const index$2_rangeLines: typeof rangeLines;
+declare const index$2_readCiteConfigFile: typeof readCiteConfigFile;
+declare const index$2_readPage: typeof readPage;
+declare const index$2_readSource: typeof readSource;
+declare const index$2_reencryptCitationEntries: typeof reencryptCitationEntries;
+declare const index$2_reencryptCitations: typeof reencryptCitations;
+declare const index$2_refineClaim: typeof refineClaim;
+declare const index$2_refusalLine: typeof refusalLine;
+declare const index$2_removalLine: typeof removalLine;
+declare const index$2_removeFrontmatterCitations: typeof removeFrontmatterCitations;
+declare const index$2_removeLine: typeof removeLine;
+declare const index$2_renderCheckGithub: typeof renderCheckGithub;
+declare const index$2_renderCheckJson: typeof renderCheckJson;
+declare const index$2_renderCheckPretty: typeof renderCheckPretty;
+declare const index$2_renderRemoveJson: typeof renderRemoveJson;
+declare const index$2_renderRemovePretty: typeof renderRemovePretty;
+declare const index$2_renderUpdateJson: typeof renderUpdateJson;
+declare const index$2_renderUpdatePretty: typeof renderUpdatePretty;
+declare const index$2_resolveCiteRun: typeof resolveCiteRun;
+declare const index$2_resolveSeverity: typeof resolveSeverity;
+declare const index$2_rewriteLine: typeof rewriteLine;
+declare const index$2_runAdd: typeof runAdd;
+declare const index$2_runCheck: typeof runCheck;
+declare const index$2_runRemove: typeof runRemove;
+declare const index$2_runUpdate: typeof runUpdate;
+declare const index$2_runsHolding: typeof runsHolding;
+declare const index$2_sentencesOf: typeof sentencesOf;
+declare const index$2_sharesSentence: typeof sharesSentence;
+declare const index$2_shiftedEntries: typeof shiftedEntries;
+declare const index$2_shortCommit: typeof shortCommit;
+declare const index$2_shortLine: typeof shortLine;
+declare const index$2_shortPin: typeof shortPin;
+declare const index$2_shortSrc: typeof shortSrc;
+declare const index$2_sidecarsFor: typeof sidecarsFor;
+declare const index$2_sliceLines: typeof sliceLines;
+declare const index$2_sourceRange: typeof sourceRange;
+declare const index$2_spellAt: typeof spellAt;
+declare const index$2_spellLines: typeof spellLines;
+declare const index$2_spellSource: typeof spellSource;
+declare const index$2_splice: typeof splice;
+declare const index$2_spliceEntryField: typeof spliceEntryField;
+declare const index$2_splitLines: typeof splitLines;
+declare const index$2_splitUnit: typeof splitUnit;
+declare const index$2_statementForms: typeof statementForms;
+declare const index$2_stripMarkers: typeof stripMarkers;
+declare const index$2_toBodyLines: typeof toBodyLines;
+declare const index$2_toFileLines: typeof toFileLines;
+declare const index$2_toValidationResult: typeof toValidationResult;
+declare const index$2_twoManifestsRefusal: typeof twoManifestsRefusal;
+declare const index$2_unifiedDiff: typeof unifiedDiff;
+declare const index$2_unitAt: typeof unitAt;
+declare const index$2_unitText: typeof unitText;
+declare const index$2_urlManifestRefusal: typeof urlManifestRefusal;
+declare const index$2_validateEntry: typeof validateEntry;
+declare const index$2_withClaimLines: typeof withClaimLines;
+declare namespace index$2 {
+  export { type index$2_AddOptions as AddOptions, type index$2_AddResult as AddResult, type index$2_BuildIndexOptions as BuildIndexOptions, index$2_CITATIONS_KEY as CITATIONS_KEY, index$2_CITE_RULES as CITE_RULES, index$2_CITE_SECTION as CITE_SECTION, type index$2_CheckOptions as CheckOptions, type index$2_CheckPageOptions as CheckPageOptions, type index$2_CheckRun as CheckRun, type index$2_Citation as Citation, type index$2_CitationAnchor as CitationAnchor, type index$2_CitationClaim as CitationClaim, type index$2_CitationFinding as CitationFinding, type index$2_CitationInput as CitationInput, type index$2_CitationManifest as CitationManifest, type index$2_CitationOrigin as CitationOrigin, type index$2_CitationResult as CitationResult, type index$2_CitationSidecars as CitationSidecars, type index$2_CitationSource as CitationSource, type index$2_CiteConfig as CiteConfig, index$2_CiteError as CiteError, type index$2_CiteRule as CiteRule, type index$2_CiteRun as CiteRun, type index$2_CiteRunOptions as CiteRunOptions, type index$2_CiteSeverity as CiteSeverity, type index$2_ClaimEnd as ClaimEnd, type index$2_ClaimHistory as ClaimHistory, type index$2_ClaimHistoryInput as ClaimHistoryInput, type index$2_ClaimStatus as ClaimStatus, type index$2_ClaimUnit as ClaimUnit, type index$2_ClassifyOptions as ClassifyOptions, index$2_DEFAULT_CITE_BASELINE_PATH as DEFAULT_CITE_BASELINE_PATH, index$2_DEFAULT_SEVERITY as DEFAULT_SEVERITY, type index$2_EntryPath as EntryPath, index$2_FILE_PATTERN as FILE_PATTERN, type index$2_FindWindowsOptions as FindWindowsOptions, index$2_GIT_UNAVAILABLE_COMMIT as GIT_UNAVAILABLE_COMMIT, index$2_GIT_UNAVAILABLE_HISTORY as GIT_UNAVAILABLE_HISTORY, type index$2_GitClient as GitClient, type index$2_HeldManifest as HeldManifest, type index$2_History as History, type index$2_InlineStatement as InlineStatement, type index$2_LineSpec as LineSpec, type index$2_LoadSidecarOptions as LoadSidecarOptions, type index$2_LoadedCiteConfig as LoadedCiteConfig, index$2_MARKER_JSON as MARKER_JSON, index$2_MAX_MARKERS_PER_PAGE as MAX_MARKERS_PER_PAGE, index$2_MAX_PAGE_COMMITS as MAX_PAGE_COMMITS, index$2_MAX_RANGE_LINES as MAX_RANGE_LINES, index$2_MOVE_BUDGET_BYTES as MOVE_BUDGET_BYTES, index$2_MOVE_WINDOW_LINES as MOVE_WINDOW_LINES, type ManifestChange$1 as ManifestChange, index$2_ManifestSet as ManifestSet, type index$2_ManifestWrite as ManifestWrite, type index$2_MarkerEnd as MarkerEnd, type index$2_MintOptions as MintOptions, type index$2_MisplacedMarker as MisplacedMarker, type index$2_MisplacedMarkerReport as MisplacedMarkerReport, type index$2_MissingReason as MissingReason, type index$2_NoUnit as NoUnit, type index$2_OriginKind as OriginKind, index$2_PAGE_HISTORY_UNAVAILABLE as PAGE_HISTORY_UNAVAILABLE, type index$2_PageCitation as PageCitation, type index$2_PageCitationReport as PageCitationReport, type index$2_PageCitations as PageCitations, type index$2_PageCommit as PageCommit, type index$2_PageHistory as PageHistory, type index$2_PageLines as PageLines, type index$2_PageSidecar as PageSidecar, type index$2_PrettyOptions as PrettyOptions, RULE_ID_PREFIX$1 as RULE_ID_PREFIX, type index$2_ReadPageOptions as ReadPageOptions, type index$2_ReadSourceResult as ReadSourceResult, type index$2_RecommitReason as RecommitReason, type index$2_ReencryptCitationsResult as ReencryptCitationsResult, type index$2_ReencryptEntriesResult as ReencryptEntriesResult, type index$2_ReencryptOptions as ReencryptOptions, type index$2_ReencryptedCitation as ReencryptedCitation, type index$2_RefineClaimInput as RefineClaimInput, type index$2_Removal as Removal, type index$2_RemoveOptions as RemoveOptions, type index$2_RemovePage as RemovePage, type index$2_RemoveRun as RemoveRun, index$2_SRC_PATTERN as SRC_PATTERN, type index$2_ShiftOptions as ShiftOptions, type index$2_Shifted as Shifted, type index$2_ShownFile as ShownFile, type index$2_SourceEnd as SourceEnd, type index$2_SourceIndex as SourceIndex, type index$2_SourceRange as SourceRange, type index$2_SourceStatus as SourceStatus, type index$2_StatementForm as StatementForm, type index$2_TextEdit as TextEdit, type index$2_UpdateOptions as UpdateOptions, type index$2_UpdatePage as UpdatePage, type index$2_UpdateRewrite as UpdateRewrite, type index$2_UpdateRun as UpdateRun, index$2_anchoredLines as anchoredLines, index$2_appendFrontmatterCitation as appendFrontmatterCitation, index$2_blockMatches as blockMatches, index$2_bodyLineOf as bodyLineOf, index$2_buildSourceIndex as buildSourceIndex, index$2_checkCitations as checkCitations, index$2_citationInputs as citationInputs, index$2_claimDiff as claimDiff, index$2_claimEnd as claimEnd, index$2_claimHistory as claimHistory, index$2_claimLine as claimLine, index$2_claimMessageFor as claimMessageFor, index$2_claimWords as claimWords, index$2_classifyCitation as classifyCitation, index$2_detectEol as detectEol, index$2_duplicateJoinRefusal as duplicateJoinRefusal, index$2_entryObject as entryObject, index$2_errorSite as errorSite, index$2_fenceSpanAt as fenceSpanAt, index$2_fencedBlockAfter as fencedBlockAfter, index$2_fencedBlockAt as fencedBlockAt, index$2_fencedBlocks as fencedBlocks, index$2_findWindows as findWindows, index$2_findingsFor as findingsFor, index$2_formatSrc as formatSrc, index$2_formatStatement as formatStatement, index$2_gitClient as gitClient, index$2_hashLines as hashLines, index$2_hashRange as hashRange, index$2_historyOf as historyOf, index$2_holdsWords as holdsWords, index$2_insertStatementBefore as insertStatementBefore, index$2_insideFence as insideFence, index$2_isBoundLine as isBoundLine, index$2_isCiteRule as isCiteRule, index$2_isKeyedPin as isKeyedPin, index$2_isTableRow as isTableRow, index$2_isUnitText as isUnitText, index$2_itemLine as itemLine, index$2_lineAt as lineAt, index$2_lineSpec as lineSpec, index$2_loadCitationSidecars as loadCitationSidecars, index$2_loadCiteConfig as loadCiteConfig, index$2_markerClaimEnd as markerClaimEnd, index$2_markerRunAt as markerRunAt, index$2_markerUnit as markerUnit, index$2_messageFor as messageFor, index$2_mintCitation as mintCitation, index$2_misplacedMarkerAt as misplacedMarkerAt, index$2_misplacedMarkers as misplacedMarkers, index$2_misplacedMessageFor as misplacedMessageFor, index$2_movedUnit as movedUnit, index$2_noGit as noGit, index$2_noUnitAt as noUnitAt, index$2_normalizeText as normalizeText, index$2_normalizeWhitespace as normalizeWhitespace, index$2_offsetOfLine as offsetOfLine, index$2_orphanRefusal as orphanRefusal, index$2_ownedMessage as ownedMessage, index$2_paragraphAfter as paragraphAfter, index$2_parseCiteConfig as parseCiteConfig, index$2_parseLines as parseLines, index$2_parseSrc as parseSrc, index$2_parseStatements as parseStatements, index$2_pickExtractor as pickExtractor, index$2_pinOfLines as pinOfLines, index$2_pre43Span as pre43Span, index$2_rangeLines as rangeLines, index$2_readCiteConfigFile as readCiteConfigFile, index$2_readPage as readPage, index$2_readSource as readSource, index$2_reencryptCitationEntries as reencryptCitationEntries, index$2_reencryptCitations as reencryptCitations, index$2_refineClaim as refineClaim, index$2_refusalLine as refusalLine, index$2_removalLine as removalLine, index$2_removeFrontmatterCitations as removeFrontmatterCitations, index$2_removeLine as removeLine, index$2_renderCheckGithub as renderCheckGithub, index$2_renderCheckJson as renderCheckJson, index$2_renderCheckPretty as renderCheckPretty, index$2_renderRemoveJson as renderRemoveJson, index$2_renderRemovePretty as renderRemovePretty, index$2_renderUpdateJson as renderUpdateJson, index$2_renderUpdatePretty as renderUpdatePretty, index$2_resolveCiteRun as resolveCiteRun, index$2_resolveSeverity as resolveSeverity, index$2_rewriteLine as rewriteLine, ruleId$1 as ruleId, index$2_runAdd as runAdd, index$2_runCheck as runCheck, index$2_runRemove as runRemove, index$2_runUpdate as runUpdate, index$2_runsHolding as runsHolding, index$2_sentencesOf as sentencesOf, index$2_sharesSentence as sharesSentence, index$2_shiftedEntries as shiftedEntries, index$2_shortCommit as shortCommit, index$2_shortLine as shortLine, index$2_shortPin as shortPin, index$2_shortSrc as shortSrc, index$2_sidecarsFor as sidecarsFor, index$2_sliceLines as sliceLines, index$2_sourceRange as sourceRange, index$2_spellAt as spellAt, index$2_spellLines as spellLines, index$2_spellSource as spellSource, index$2_splice as splice, index$2_spliceEntryField as spliceEntryField, index$2_splitLines as splitLines, index$2_splitUnit as splitUnit, index$2_statementForms as statementForms, index$2_stripMarkers as stripMarkers, index$2_toBodyLines as toBodyLines, index$2_toFileLines as toFileLines, index$2_toValidationResult as toValidationResult, index$2_twoManifestsRefusal as twoManifestsRefusal, index$2_unifiedDiff as unifiedDiff, index$2_unitAt as unitAt, index$2_unitText as unitText, index$2_urlManifestRefusal as urlManifestRefusal, index$2_validateEntry as validateEntry, index$2_withClaimLines as withClaimLines };
+}
+
+/**
+ * The contract every other module is written against.
+ *
+ * Two shapes matter. `DocumentTree` is what a parser owes the rest of the tool:
+ * a nested section tree with real source positions, in a vocabulary that has
+ * nothing to do with Markdown. `Finding` is what the tool owes its caller.
+ * Everything between the two - matching, rules, reporting - touches neither
+ * mdast nor Asciidoctor nor parse5, which is what lets a new input format be
+ * one file plus a line in the parser registry.
+ */
+
+/**
+ * Operational/usage failure. Exits 2; never used for lint findings.
+ *
+ * Extends the umbrella's `ToolError`, which is what the shared bin runner
+ * matches on; the subclass stays so this tool's tests and library callers can
+ * match on it by name. Named for its domain, as `A11yError`, `CiteError` and
+ * `KeyError` are.
+ */
+declare class LintError extends ToolError {
+    constructor(message: string);
+}
+/** A point in a source file. Line and column are 1-based, offset 0-based. */
+interface Point {
+    line: number;
+    column: number;
+    offset: number;
+}
+/** A half-open source span, `start` inclusive and `end` exclusive. */
+interface Position {
+    start: Point;
+    end: Point;
+}
+/**
+ * Content kinds a section can hold, named generically so a rule written once
+ * works on every format. Each parser maps its own AST onto these: mdast
+ * `paragraph`/`code`/`list`, Asciidoctor `paragraph`/`listing`/`ulist`|`olist`,
+ * HTML `<p>`/`<pre>`/`<ul>` - all three onto `paragraph`/`codeBlock`/`list`.
+ *
+ * The vocabulary is wider than any one parser emits today. `table`,
+ * `admonition`, `image`, `blockquote`, `definitionList`, and `element` are
+ * declared here, and in each `DocumentParser.kinds`, only once a parser
+ * actually produces them - see `src/lint/parsers/index.ts`.
+ */
+type ContentKind = "paragraph" | "codeBlock" | "list" | "listItem" | "table" | "tableRow" | "tableCell" | "admonition" | "image" | "blockquote" | "definitionList" | "definitionItem" | "element";
+interface ContentNodeBase {
+    kind: ContentKind;
+    position: Position;
+    /** Plain-text rendering, used by pattern rules. */
+    text: string;
+}
+interface ParagraphNode extends ContentNodeBase {
+    kind: "paragraph";
+}
+interface CodeNode extends ContentNodeBase {
+    kind: "codeBlock";
+    /** Language, when the format carries one. */
+    language?: string;
+    /** The info-string tail after the language, when the format carries one. */
+    fenceInfo?: string;
+}
+interface ListItemNode {
+    kind: "listItem";
+    position: Position;
+    text: string;
+    /** Nested content, so item-level paragraph/code/list rules can run. */
+    children: ContentNode[];
+}
+interface ListNode extends ContentNodeBase {
+    kind: "list";
+    ordered: boolean;
+    items: ListItemNode[];
+}
+interface TableCellNode extends ContentNodeBase {
+    kind: "tableCell";
+    children: ContentNode[];
+}
+interface TableRowNode extends ContentNodeBase {
+    kind: "tableRow";
+    header: boolean;
+    children: TableCellNode[];
+}
+interface TableNode extends ContentNodeBase {
+    kind: "table";
+    children: TableRowNode[];
+}
+/**
+ * A callout, and the flavor the source gave it.
+ *
+ * `variant` is optional because not every format names one this vocabulary
+ * has. reStructuredText has `hint`, `attention`, `error` and a generic
+ * `admonition` directive, and a bare HTML `<aside>` says nothing at all. Those
+ * produce an admonition with no variant rather than an invented equivalence:
+ * mapping `hint` onto `tip` would make `variant: tip` pass on a page that
+ * never said tip. A `variant:` rule reports such a node as a mismatch, and a
+ * plain count rule still counts it.
+ */
+interface AdmonitionNode extends ContentNodeBase {
+    kind: "admonition";
+    variant?: "note" | "tip" | "important" | "caution" | "warning" | "danger";
+    children: ContentNode[];
+}
+interface ImageNode extends ContentNodeBase {
+    kind: "image";
+    url: string;
+    alt: string;
+    title?: string;
+}
+interface BlockquoteNode extends ContentNodeBase {
+    kind: "blockquote";
+    children: ContentNode[];
+}
+interface DefinitionItemNode {
+    kind: "definitionItem";
+    position: Position;
+    text: string;
+    term: string;
+    definition: ContentNode[];
+}
+interface DefinitionListNode extends ContentNodeBase {
+    kind: "definitionList";
+    children: DefinitionItemNode[];
+}
+/**
+ * A named wrapper - an MDX/JSX component today, and where HTML and DITA may
+ * eventually anchor a custom element. Its children are its own content, never
+ * the enclosing section's: a rule reading a section's `children` must not see
+ * inside an `<Element>` it did not ask about.
+ */
+interface ElementNode extends ContentNodeBase {
+    kind: "element";
+    name: string;
+    attributes?: Record<string, string | true>;
+    children: ContentNode[];
+}
+type ContentNode = ParagraphNode | CodeNode | ListNode | TableNode | AdmonitionNode | ImageNode | BlockquoteNode | DefinitionListNode | ElementNode;
+/**
+ * One section of a document, demarcated by a heading.
+ *
+ * `slug`/`title`/`level`/`order`/`parentSlug` intentionally match manni kg's
+ * `Section` (dockg/src/types.ts), so its graph can be built from this tree.
+ *
+ * `children` is in document order and is the single source of truth: the
+ * paragraph/codeBlock/list counts every rule needs are queries over it, not
+ * separately maintained arrays.
+ */
+interface SectionNode {
+    /** Slug of the heading, disambiguated across the document (`install-1`). */
+    slug: string;
+    /** Heading text, with inline markup flattened. */
+    title: string;
+    /** Heading level, 1-6. 0 for the implicit lead section before any heading. */
+    level: number;
+    /** 1-based position among siblings under the same parent. */
+    order: number;
+    /** Slug of the enclosing section, or null at the top level. */
+    parentSlug: string | null;
+    /** Span of the title itself. Null for the implicit lead section. */
+    titlePosition: Position | null;
+    /** Span of the whole section: its heading through the last node before the next sibling heading. */
+    position: Position;
+    /** Direct content, in document order, excluding anything owned by a subsection. */
+    children: ContentNode[];
+    /** Nested sections, in document order. */
+    sections: SectionNode[];
+}
+/** What a parser returns for one file. */
+interface DocumentTree {
+    /** Name of the parser that produced this (`markdown`, `asciidoc`, ...). */
+    format: string;
+    /** Path the content came from, for error messages. */
+    filePath: string;
+    /** Raw frontmatter/metadata values, or null when the file carries none. */
+    frontmatter: Record<string, unknown> | null;
+    /** Span of the frontmatter block, for anchoring findings about it. */
+    frontmatterPosition: Position | null;
+    /** Top-level sections, in document order. */
+    sections: SectionNode[];
+}
+/**
+ * A parser for one input format.
+ *
+ * Shaped after docmeta's `MetadataExtractor` so the two registries read the
+ * same way. A format is registered only when its parser reads it, so every
+ * registered format is one the tool reads, and an extension no parser claims is
+ * skipped by name rather than parsed as Markdown.
+ */
+interface DocumentParser {
+    /** Stable name, also used as `DocumentTree.format`. */
+    name: string;
+    /** Human-readable label for `manni lint tools`. */
+    label: string;
+    /**
+     * The content kinds this parser actually emits today. A capability
+     * declaration, not the full `ContentKind` vocabulary: a kind absent here is
+     * one no rule will ever see from this parser's trees, whatever the format
+     * could in principle represent.
+     */
+    kinds: ContentKind[];
+    /** Lowercase file extensions this parser handles, incl. dot (e.g. ".md"). */
+    extensions: string[];
+    /**
+     * Extensions safe to collect from a directory walk. Defaults to
+     * `extensions`.
+     *
+     * The two differ when an extension is a generic container rather than a
+     * documentation format. `.xml` is the case: this parser can read a DocBook
+     * or DITA document named explicitly, but a docs tree also contains
+     * `pom.xml`, `sitemap.xml`, and `.csproj`, and sweeping those in turns a
+     * clean run into a failure about files the user never asked to lint.
+     */
+    walkExtensions?: string[];
+    /** Parse raw file content into the generic tree. */
+    parse(content: string, filePath: string): DocumentTree;
+}
+
+/**
+ * One structural violation.
+ *
+ * The field set is pinned by manni docevals' tool adapter, which reads
+ * `{ type, heading, message, position }` off the JSON reporter. Additions are
+ * safe; renames are not.
+ */
+interface Finding {
+    /** Machine-readable rule id, e.g. `missing_section`. */
+    type: string;
+    /** Heading of the section the finding is anchored to, if any. */
+    heading: string | null;
+    message: string;
+    position: Position;
+    severity: Severity;
+}
+/**
+ * Why a file was not linted.
+ *
+ * `unreadable` is the one that is not about the document: the file was found,
+ * claimed by a parser, and then could not be opened - a denied permission, a
+ * symlink loop, a page a doc build moved between the walk and the read. It is a
+ * skip rather than a finding because nothing was checked, and calling it a
+ * finding would report the docs as wrong when the filesystem was.
+ */
+type SkipReason = "no-template" | "unsupported-format" | "unreadable";
+/** Result of linting one file. */
+interface FileResult {
+    file: string;
+    /** True when the file was linted and produced no findings. */
+    success: boolean;
+    findings: Finding[];
+    /** Template id/ref applied, or null when skipped. */
+    template: string | null;
+    /** Set when the file was skipped rather than linted. */
+    skipped?: SkipReason;
+}
+
+/**
+ * The template DSL, as TypeScript. `schemas/lint/template.json` is the
+ * authority that user input is validated against; this is the shape the rest of
+ * the code reads once that validation has passed.
+ *
+ * Two things are worth knowing before reading it.
+ *
+ * A template *is* a rule. It describes the page, so it takes every rule key,
+ * plus `title`, `types` and `extends`. It may not take `min` or `max`, because
+ * a page is one page, and the loader refuses those two by hand.
+ *
+ * A rule's children are a **list**, not a map. The v1 format keyed section
+ * rules by name and let YAML key order carry the grammar, which made the order
+ * invisible to the schema and unspeakable in `extends`. A rule names itself
+ * with `id` instead, and that is what `extends` targets.
+ *
+ * The block-rule keys are plural where the node model is singular. That is
+ * deliberate: the node model names one node (`codeBlock`), while a template key
+ * carries a count (`codeBlocks: { min: 1 }`).
+ */
+
+/** Shared by every counted rule: how many of the thing there must be. */
+interface Occurrences {
+    /** Fewest occurrences. Absent means one. */
+    min?: number;
+    /** Most occurrences. Absent is unbounded; `0` forbids. */
+    max?: number;
+}
+/**
+ * What a rule's `heading` may say.
+ *
+ * `undefined` (the key absent) matches 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.
+ */
+type HeadingRule = string | string[] | {
+    pattern: string;
+} | false;
+/**
+ * Attributes a node must carry. A string is the required value, `true`
+ * requires the attribute's presence, and `false` requires its absence.
+ */
+type AttributesRule = Record<string, string | boolean>;
+/** `paragraphs:` - how many paragraphs, and what each must look like. */
+interface ParagraphsRule extends Occurrences {
+    /** Unanchored regular expression every paragraph in the run must match. */
+    pattern?: string;
+}
+/** `codeBlocks:` - how many code blocks, and how they are tagged. */
+interface CodeBlocksRule extends Occurrences {
+    /** Language, or languages, every code block must declare one of. */
+    language?: string | string[];
+    /** Info-string tail after the language; narrows which blocks count. */
+    fenceInfo?: string;
+}
+/** `lists.items:` - how many items per list, and what each item holds. */
+interface ListItemsRule extends Occurrences {
+    sequence?: BlockRule[];
+    contains?: BlockRule;
+}
+/** `lists:` - how many lists, whether they are ordered, and item rules. */
+interface ListsRule extends Occurrences {
+    ordered?: boolean;
+    items?: ListItemsRule;
+}
+/** `tables:` - how many tables, and the header cells in order. */
+interface TablesRule extends Occurrences {
+    columns?: string[];
+}
+/** `admonitions:` - how many, and of which variant. */
+interface AdmonitionsRule extends Occurrences {
+    variant?: "note" | "tip" | "important" | "caution" | "warning" | "danger";
+}
+/** `images:` - how many, and what they point at. */
+interface ImagesRule extends Occurrences {
+    url?: string;
+    alt?: string;
+    attributes?: AttributesRule;
+}
+/** `elements:` - how many named wrappers, and what they hold. */
+interface ElementsRule extends Occurrences {
+    /** Name, or names, an element must carry to be counted by this rule. */
+    tag?: string | string[];
+    attributes?: AttributesRule;
+    sequence?: BlockRule[];
+    contains?: BlockRule;
+}
+/**
+ * What a section holds, keyed by content kind.
+ *
+ * One of these is a whole `contains:`. As an entry of `sequence:` exactly one
+ * key is set, and it names the kind expected at that position.
+ */
+interface BlockRule {
+    paragraphs?: ParagraphsRule;
+    codeBlocks?: CodeBlocksRule;
+    lists?: ListsRule;
+    tables?: TablesRule;
+    admonitions?: AdmonitionsRule;
+    images?: ImagesRule;
+    blockquotes?: Occurrences;
+    definitionLists?: Occurrences;
+    elements?: ElementsRule;
+}
+/** One block-rule key: a content kind, spelled plural. */
+type BlockKind = keyof BlockRule;
+/** Every block-rule key, in the order the schema declares them. */
+declare const BLOCK_KINDS: readonly BlockKind[];
+/** One rule: a section of the page, or a repeated run of sections. */
+interface Rule extends Occurrences {
+    /** Handle, unique among siblings. `extends` targets it. */
+    id?: string;
+    /** Prose description of what the rule is for. Never checked. */
+    description?: string;
+    heading?: HeadingRule;
+    /** Rules matched in order as one unit, repeated by this rule's `min`/`max`. */
+    repeat?: Rule[];
+    /** What the section holds, in order. Not combinable with `contains`. */
+    sequence?: BlockRule[];
+    /** What the section holds, in any order. Not combinable with `sequence`. */
+    contains?: BlockRule;
+    /** Rules for the subsections, in document order. */
+    sections?: Rule[];
+}
+/** One doctype template: the rule that describes a whole page. */
+interface Template extends Rule {
+    /** Human-readable name, shown by `manni lint templates`. */
+    title?: string;
+    /** Doctypes this template serves, matched against a page's `type`. */
+    types?: string[];
+    /** Built-in id, path, or URL to inherit from. */
+    extends?: string;
+}
+/** A template file: named templates plus reusable `$ref` targets. */
+interface TemplateFile {
+    /** Published schema URL, for editors. Ignored by the linter. */
+    $schema?: string;
+    templates?: Record<string, Template>;
+    components?: Record<string, unknown>;
+    info?: Record<string, unknown>;
+}
+/**
+ * A rule is a wildcard when it says nothing about its heading.
+ *
+ * It then matches any heading, and matches a section with none. `heading:
+ * false` is not a wildcard: it states that the section has no heading of its
+ * own, which is as specific as naming one.
+ */
+declare function isWildcard(rule: Rule): boolean;
+/**
+ * How many sections a rule claims: `min` defaulting to one, and `max` as
+ * written, with `null` for unbounded.
+ *
+ * The defaults live here rather than in the schema. A default written into the
+ * data by Ajv is indistinguishable from a value the author typed, so it wins
+ * the `extends` merge against the parent's real value.
+ *
+ * One default is not the naive `min ?? 1`. `max: 0` is how the format forbids
+ * a thing outright, and a bare `max: 0` has to be satisfiable by a page that
+ * truly has none of it. A blanket "min defaults to 1" makes it unsatisfiable -
+ * at least one demanded, at most zero permitted - so `min` defaults to 0
+ * exactly when `max` is written as `0` and `min` itself is not, and to 1
+ * otherwise. `checkCount` in `rules/index.ts` states the same rule for the
+ * content counts; the two agree deliberately.
+ */
+declare function occurrenceRange(rule: Occurrences): {
+    min: number;
+    max: number | null;
+};
+/** Whether a section's title satisfies a rule's `heading`. */
+declare function headingMatches(heading: HeadingRule | undefined, title: string | null): boolean;
+
+/** Where a resolution came from, in precedence order. */
+type ResolutionStage = "cli" | "frontmatter-template" | "config-override" | "type" | "config-default";
+type SkipCause = "no-type" | "unknown-type";
+interface ResolutionStep {
+    stage: ResolutionStage;
+    /** What the stage found, or null when it had nothing to say. */
+    ref: string | null;
+    /** Human-readable account of what the stage saw. */
+    detail: string;
+}
+interface Resolution {
+    /** The template ref to lint with, or null when the page is not linted. */
+    ref: string | null;
+    /** Which stage decided, when one did. */
+    stage: ResolutionStage | null;
+    /** Why no template was found. Only set when `ref` is null. */
+    cause?: SkipCause;
+    /**
+     * The `type` the page declared but that resolved to nothing. Set only for
+     * `unknown-type`, so the caller can name it and suggest near misses.
+     */
+    unknownType?: string;
+    /** Near-miss doctypes, for an unknown-type message. */
+    suggestions?: string[];
+    /**
+     * Every doctype something serves, for an unknown-type message with no near
+     * miss to offer. Carried on the resolution rather than looked up by each
+     * reporter, because the type index does not reach them - which is how the
+     * pretty reporter came to print the list and `--explain` came to print
+     * nothing, for the same page.
+     */
+    knownTypes?: string[];
+    /** The full chain, for `--explain`. */
+    steps: ResolutionStep[];
+}
+/** Per-glob repo policy, from `manni.config.yaml`'s `lint.overrides`. */
+interface TemplateOverride {
+    files: string;
+    template: string;
+}
+
+/**
+ * Everything the `lint:` section can carry. Every key is optional, and an
+ * absent one means "the consumer's default", never a value written in here.
+ *
+ * `overrides[].template` and the `types` values are template refs, left as the
+ * strings they were written as: `resolve-template.ts` owns what a ref means.
+ */
+interface LintConfig {
+    /** Zero matched files is a success, not an operational error. */
+    allowEmpty?: boolean;
+    /** The structure job: what `lint structure` runs and `lint check` includes. */
+    structure?: LintJobConfig;
+    /** Template files to load; their `types:` join the routing table. */
+    templates?: string[];
+    /** Template for a page that declares no doctype. */
+    template?: string;
+    /** Explicit doctype -> template ref map. */
+    types?: Record<string, string>;
+    /** Repo policy, first matching glob wins. */
+    overrides?: TemplateOverride[];
+}
+
+/** One job's settings. The tool that performs it is all a job configures. */
+interface LintJobConfig {
+    tool?: LintTool;
+}
+/**
+ * The tools that can perform a lint job: manni's own engine, and DITA Open
+ * Toolkit for a DITA docset.
+ */
+declare const LINT_TOOLS: readonly ["manni", "dita-ot"];
+type LintTool = (typeof LINT_TOOLS)[number];
+/** The jobs `lint check` runs: `structure`. */
+declare const LINT_JOBS: readonly ["structure"];
+type LintJob = (typeof LINT_JOBS)[number];
+/** The tools each job accepts, in the order its message lists them. */
+declare const TOOLS_BY_JOB: Readonly<Record<LintJob, readonly LintTool[]>>;
+declare function isLintTool(value: string): value is LintTool;
+/**
+ * Parse a whole `manni.config.yaml` and return its `lint:` section.
+ *
+ * `source` names the file in every message. A file that is empty, or that
+ * carries only other tools' sections, returns `{}` rather than throwing - that
+ * is the case that keeps one shared file usable by a project which has not
+ * adopted this tool yet.
+ */
+declare function parseConfig(text: string, source: string): LintConfig;
+/**
+ * Load the config from an explicit path, or by walking up from `cwd`.
+ *
+ * Discovery is the family's: the nearest `manni.config.yaml` with a `lint:`
+ * key or a family key wins, and a family file with neither belongs to a
+ * sibling and is passed over. An explicit path skips discovery and errors if
+ * it is missing; its `lint:` key is unwrapped when present and the whole
+ * document is the section otherwise, so a file passed by hand may be called
+ * anything.
+ *
+ * A wrapper differing from `lint:` only in case is still caught on an
+ * un-wrapped document: nothing else in the section's schema would name it.
+ *
+ * Returns null when discovery finds no config, which is not an error - a repo
+ * whose pages all declare their `type` needs no config at all.
+ */
+declare function loadConfig(explicitPath?: string, cwd?: string): Promise<{
+    config: LintConfig;
+    path: string;
+} | null>;
+/**
+ * Re-base everything a config declares against the config file's own
+ * directory.
+ *
+ * `loadConfig` returns the file's `path` precisely so this can happen, and
+ * discarding it made the same config mean different things depending on where
+ * the tool was invoked from. Running from a subdirectory turned `templates:`
+ * into "file not found" - and turned `overrides:` into nothing at all,
+ * silently: the glob stopped matching, every page fell through to its own
+ * `type`, and the run exited 0 having applied none of the repo's policy.
+ *
+ * Refs go through `refRelativeTo`, which leaves built-in ids, URLs, and
+ * absolute paths alone. Globs become absolute, which is what the run matches
+ * them against. Every non-absolute glob is relative to the config, `**\/*.md`
+ * included: exempting a leading `**` left the original bug half-open, because
+ * from a subdirectory that pattern expanded against the working directory.
+ */
+declare function rebaseConfig(found: {
+    config: LintConfig;
+    path: string;
+} | null): LintConfig;
+interface LintRunOptions {
+    cwd: string;
+    /** `-c/--config`. */
+    configPath?: string;
+    /** `--no-config`: skip discovery and run on the built-in defaults. */
+    noConfig?: boolean;
+    /** Positional inputs; empty means fall back to the selected collections' `paths:`. */
+    inputs: string[];
+    /**
+     * `--collection <name>`, repeatable: the collections this run covers. Empty
+     * or absent means every declared one, the same thing, because commander's
+     * collector hands `[]` over when the flag was never typed.
+     */
+    collection?: string[];
+    onConfigLoaded?: (info: {
+        path: string;
+        dir: string;
+    }) => void;
+}
+/** What every lint command settles before it touches a file. */
+interface ResolvedLintRun {
+    /** The `lint:` section, rebased against the config's directory. */
+    config: LintConfig;
+    /** What to resolve: the positional inputs, or the collections' `paths:`. */
+    inputs: string[];
+    /** The directory `inputs` resolve from. */
+    base: string;
+    /** The collections this run covers; `[]` with no config. */
+    collections: CollectionConfig[];
+    /** Whether `inputs` came from the collections rather than the command line. */
+    fromCollections: boolean;
+    /**
+     * The document's top-level `tools:`, an outside tool's settings (proposal
+     * 0052). `{}` with no config. It is not part of the `lint:` section and is
+     * not rebased here: a path in it is resolved against `configDir` by the run
+     * that needs it, through the helpers in `src/shared/tools.ts`.
+     */
+    tools: ToolsConfig;
+    configDir?: string;
+    configPath?: string;
+    configSource?: string;
+}
+/**
+ * Settle which config governs the run and what it covers. The same shape cite
+ * uses, for the same reason: positional inputs are typed from a shell and stay
+ * cwd-relative, while a collection's `paths:` was written next to the config
+ * and resolves there, so one run has exactly one base.
+ */
+declare function resolveLintRun(opts: LintRunOptions): Promise<ResolvedLintRun>;
+
+/**
+ * `tools` command core. One row per lint job: which tool performs it, whether
+ * this checkout can run it, what it read its settings from, and the input
+ * formats it understands.
+ *
+ * It replaces `formats`, which reported the parser registry alone. Proposal
+ * 0050 records the rename. The registry is here as one column of the job that
+ * reads it, because the formats belong to the tool performing that job.
+ *
+ * The column lists exactly the formats the tool reads, so a row carries no
+ * state: a listed format is one that is read, and `--as` accepts every name in
+ * it.
+ *
+ * Returns data; `src/lint/reporters/index.ts` renders it.
+ */
+
+interface FormatInfo {
+    /** Parser name, also what `--as` accepts. */
+    name: string;
+    label: string;
+    extensions: string[];
+    /** The content kinds this format's parser actually emits today. */
+    kinds: ContentKind[];
+}
+/** One job, and the tool that would perform it on this run. */
+interface ToolInfo {
+    job: LintJob;
+    tool: LintTool;
+    /** Whether the config declares this job, or anything the job's tool reads. */
+    configured: boolean;
+    /** Whether the tool can run here, as its own probe reported it. */
+    available: boolean;
+    /**
+     * The version the probe reported, or null when it reported none.
+     *
+     * Null rather than a placeholder string, because this is the shape
+     * `-f json` emits: a consumer can test for an absent version, where a dash
+     * would be a value it has to know to recognize. The pretty reporter renders
+     * the dash.
+     */
+    version: string | null;
+    /** Where the tool read its settings: the config file, or the defaults. */
+    config: string;
+    /** The input formats the tool reads. */
+    formats: FormatInfo[];
+}
+interface ToolsOptions {
+    cwd?: string;
+    /** `-c/--config`. */
+    configPath?: string;
+    /** `--no-config`: ignore any discovered config file. */
+    noConfig?: boolean;
+}
+/** What a run with no config file to read reports in the `config` column. */
+declare const BUILT_IN_DEFAULTS = "built-in defaults";
+declare function runTools(opts?: ToolsOptions): Promise<ToolInfo[]>;
+
+/** What the launcher did. `code` is null when a signal ended it. */
+interface DitaOtProcessResult {
+    code: number | null;
+    /**
+     * The signal that ended it, when one did, and `code` is then null. Optional
+     * because absent means what it says: the run was not killed.
+     */
+    signal?: string | null;
+    stdout: string;
+    stderr: string;
+}
+/**
+ * Start `launcher` with `args` and wait for it. Resolves for any exit; rejects
+ * when the process could not start, with an error whose `code` is `ENOENT`
+ * when there is no such launcher. Tests inject a stub.
+ */
+type DitaOtSpawn = (launcher: string, args: string[], opts: {
+    cwd?: string;
+}) => Promise<DitaOtProcessResult>;
+/** One diagnostic DITA-OT reported, in the vocabulary the lint branch reads. */
+interface DitaOtMessage {
+    /** DITA-OT's own message id, e.g. `DOTX010E`. Becomes the finding's `type`. */
+    code: string;
+    severity: Severity;
+    message: string;
+    /** The path its `location` URI named, absent when it named none. */
+    file?: string;
+    line?: number;
+    /** The **column**. See `readMessage` for why the log calls it `row`. */
+    column?: number;
+}
+/** What one invocation of DITA-OT had to say about one target. */
+interface DitaOtTargetResult {
+    /** The absolute path this invocation was given as `--input`. */
+    target: string;
+    messages: DitaOtMessage[];
+}
+interface DitaOtRunOptions {
+    /** Absolute paths. One invocation each: DITA-OT takes one `--input`. */
+    targets: string[];
+    /** The directory the run resolves from, and where the launcher is started. */
+    cwd: string;
+    /** `tools.dita-ot.home`, already resolved to an absolute directory. */
+    home?: string;
+    spawn?: DitaOtSpawn;
+}
+/**
+ * DITA-OT over each target, and what its log said.
+ *
+ * ## Why this is not `dita validate`
+ *
+ * Because `dita validate` does not answer the question this tool exists for.
+ * Run against a map whose topic conrefs an id that is not there, it exits 0 and
+ * prints nothing. It parses and checks grammar, and it resolves no references.
+ * Its own `--help` lists neither `--logger` nor `--logfile` nor `--temp`, so
+ * the obvious invocation is silently accepted and silently useless.
+ *
+ * `--format=dita` is the DITA-to-DITA transformation. It runs the whole
+ * preprocessing chain, which is where conref, keyref and link resolution
+ * happen, and it reports what those stages find. Measured against the fixtures
+ * beside this file, it catches everything `validate` catches and the references
+ * as well: a grammar error is `DOTJ088E` with a line and a column, a missing
+ * conref target is `DOTX010E`, an unreadable link target is `DOTX008E`.
+ *
+ * The cost is that a transformation writes output. It goes to the scratch
+ * directory with the logs and the temp trees, and the whole scratch is removed
+ * however the run ends, so nothing of ours lands in the user's tree.
+ *
+ * ## Why verbose
+ *
+ * Because DITA-OT reports an undefined key reference (`DOTJ047I`) at `INFO`,
+ * and the default verbosity drops it. Verbose turns one run of a four-file map
+ * into roughly 135 log entries, of which one carries a `code`. That is what
+ * makes the `code` filter in `parseDitaOtLog` load-bearing rather than tidy.
+ */
+declare function runDitaOtValidate(opts: DitaOtRunOptions): Promise<DitaOtTargetResult[]>;
+
+/** File label used for a document read from stdin. */
+declare const STDIN_LABEL = "<stdin>";
+interface LintOptions {
+    /**
+     * Positional inputs: files, directories, or globs. `-` reads stdin. Empty
+     * falls back to the `collections:` the config declares (proposal 0041).
+     */
+    inputs: string[];
+    /** `--collection <name>`, repeatable: the collections this run covers. */
+    collection?: string[];
+    /**
+     * `--tool`: which tool performs the structure job. Overrides the config's
+     * own `lint.structure.tool`, and defaults to manni's engine.
+     */
+    tool?: string;
+    /** `--template`: a built-in id, a path, or a name inside `templates`. */
+    template?: string;
+    /**
+     * `--templates`: template files whose `types:` join the routing table. A bare
+     * `--template <name>` is resolved as a name inside the *last* of them, which
+     * is the pairing the manni docevals adapter invokes. Last, not first, to
+     * agree with `buildTypeIndex`: a later file overrides an earlier one there,
+     * so resolving a bare name against the first would make one name mean two
+     * different templates depending on how it was written.
+     */
+    templates?: string | string[];
+    /** `--as`: force an input format, by parser name. */
+    as?: string;
+    /** `--ext`: extensions kept during directory and glob expansion. */
+    exts?: string[];
+    /** `--exclude`: globs removed from directory/glob expansion. */
+    exclude?: string[];
+    cwd?: string;
+    /** Content for the `-` input, injected by the CLI and by tests. */
+    stdinContent?: string;
+    /** `--explain`: record how each file's template was chosen. */
+    explain?: boolean;
+    /** Repo policy: first matching glob wins. Overrides the config's own. */
+    overrides?: TemplateOverride[];
+    /** Applied when a page declares no doctype. Overrides the config's own. */
+    defaultTemplate?: string;
+    /** Explicit doctype -> template ref map. Overrides the config's own. */
+    types?: Record<string, string>;
+    /** `--allow-empty`: zero matched files is a success, not an error. */
+    allowEmpty?: boolean;
+    /** `--no-gitignore`: only an explicit `false` travels, so config can decide. */
+    respectGitignore?: boolean;
+    /** `-c/--config`. */
+    configPath?: string;
+    /** `--no-config`: skip discovery and run on the built-in defaults. */
+    noConfig?: boolean;
+    /** Told which config governed the run, and where it came from. */
+    onConfigLoaded?: (info: {
+        path: string;
+        dir: string;
+    }) => void;
+    /** Told what the run had to say beside its findings. */
+    onNotice?: (message: string) => void;
+    /**
+     * The DITA-OT seam, injected by tests, as `term lint` injects Vale's.
+     *
+     * There is no JVM and no DITA-OT on a CI runner of ours, so the only way to
+     * exercise this branch end to end is to hand it the process boundary. The
+     * shipped default is the real one.
+     */
+    runDitaOt?: typeof runDitaOtValidate;
+}
+interface LintSummary {
+    /** Files actually linted. Always `passed + failed`; skips are counted apart. */
+    checked: number;
+    passed: number;
+    failed: number;
+    skipped: number;
+}
+/**
+ * A `FileResult` plus the human-readable reason a file was skipped.
+ *
+ * `types.ts` pins the fields manni docevals reads off the JSON reporter, so
+ * this diagnostic lives here instead: it exists for pretty output, and the
+ * JSON reporter never emits it.
+ */
+interface LintFileResult extends FileResult {
+    /** Why the file was skipped, in words. Set only alongside `skipped`. */
+    reason?: string;
+    /** How the template was chosen. Present when `--explain` asked for it. */
+    resolution?: Resolution;
+    /**
+     * What the alignment block is rendered from. Present when `--explain` asked
+     * for it, and only for a file that routed to a template.
+     *
+     * Nested rather than flat, because `FileResult.template` is already taken by
+     * the template's *ref* - the string a reader sees on the routing line. A
+     * loaded `Template` beside it under the same name would be two things called
+     * one thing, and the reporter would read whichever it got.
+     */
+    alignment?: {
+        tree: DocumentTree;
+        template: Template;
+    };
+}
+interface LintRun {
+    results: LintFileResult[];
+    summary: LintSummary;
+}
+declare function runLint(opts: LintOptions): Promise<LintRun>;
+
+/** `TemplateInfo.source` for a template that ships with the tool. */
+declare const BUILTIN_SOURCE = "builtin";
+interface TemplateInfo {
+    /** The ref to pass to `--template`. */
+    id: string;
+    /**
+     * Human-readable title. Empty for templates read from a user file: the
+     * template DSL has no title field, only the built-in registry carries one.
+     */
+    title: string;
+    /** Doctypes the template serves, matched against a page `type`. */
+    types: string[];
+    /** `builtin`, or the template file this entry came from. */
+    source: string;
+}
+interface TemplatesInfo {
+    templates: TemplateInfo[];
+}
+interface TemplatesOptions {
+    /** Template files whose entries join the built-ins. */
+    templates?: string | string[];
+}
+declare function runTemplates(opts?: TemplatesOptions): Promise<TemplatesInfo>;
+
+/** One rule paired with the section it claimed. */
+interface Match {
+    /** The rule itself - a `repeat` group's member, never the group. */
+    rule: Rule;
+    section: SectionNode;
+    /**
+     * True when the rule was paired with a section whose heading does not
+     * satisfy it, because nothing else could claim that section. Keeps the
+     * precise "Expected title X, but found Y" report for the common one-for-one
+     * case instead of degrading it into missing + unexpected.
+     */
+    coerced: boolean;
+}
+interface MatchResult {
+    matches: Match[];
+    findings: Finding[];
+}
+interface MatchOptions {
+    /** Section these are the subsections of, for anchoring a trailing gap. */
+    parent?: SectionNode | null;
+    /** File the rules came from. Used only to name the state-cap failure. */
+    source?: string;
+    /** Template within that file. Used only to name the state-cap failure. */
+    template?: string;
+}
+/**
+ * Align `sections` against `rules` and say what is missing, what is extra, and
+ * which rule describes which section.
+ *
+ * `rules` being absent means the template says nothing about this level, which
+ * is silence rather than "no sections allowed". An empty list is the other
+ * thing: a rule list that describes no sections, so every section is
+ * unexpected.
+ */
+declare function matchSections(sections: SectionNode[], rules: Rule[] | undefined, options?: MatchOptions): MatchResult;
+
+/**
+ * Run a template over a parsed document.
+ *
+ * Matching and checking are deliberately separate: `match.ts` decides which
+ * section each rule is talking about, and this module asks the content rules
+ * about the pairs it produced. The old code fused the two - it inferred which
+ * section a rule meant by running the rules and seeing whether they passed -
+ * which made "does this section match?" and "is this section valid?" the same
+ * question, so a section could never be both matched and wrong.
+ *
+ * Everything here is synchronous. It was async only to await a language model,
+ * which this tool no longer has.
+ *
+ * Two things beyond that wiring live here, and both are about the document as a
+ * whole rather than about any one section.
+ *
+ * **A template is a rule, and its subject is the page.** Its `heading`
+ * constrains the page's own title, its `sequence`/`contains` describe what sits
+ * before the first heading, and its `sections` describe what follows. See
+ * `pageSection` for which section that makes the subject.
+ *
+ * **A rule the format cannot answer is said out loud.** A parser declares the
+ * content kinds it emits (proposal 0065), and a rule about a kind absent from
+ * that list is dropped and reported as a `warning` rather than silently passing
+ * - or, worse, failing a document for holding none of something its format
+ * cannot express.
+ */
+
+/** What a caller can tell the validator beyond the tree and the template. */
+interface ValidateOptions {
+    /** Template file the rules came from. Names the state-cap failure. */
+    source?: string;
+    /** Template within that file. Named in messages about the template. */
+    template?: string;
+    /**
+     * Content kinds the parser that produced this tree emits. Defaults to what
+     * the registry declares for `tree.format`, which is what the CLI wants; a
+     * caller holding a tree from somewhere else passes its own.
+     */
+    kinds?: ContentKind[];
+}
+/** Match one level of sections, check each pair, then recurse. */
+declare function validateSections(sections: SectionNode[], rules: Rule[] | undefined, options?: MatchOptions): Finding[];
+/** Findings for one document against one template, in document order. */
+declare function validateDocument(tree: DocumentTree, template: Template, options?: ValidateOptions): Finding[];
+
+interface BuiltinInfo {
+    id: string;
+    title: string;
+    types: string[];
+}
+declare function listBuiltins(): BuiltinInfo[];
+type RefKind = "builtin" | "file" | "url";
+declare function classifyRef(ref: string): {
+    kind: RefKind;
+    ref: string;
+};
+interface LoadTemplateOptions {
+    /** Abort a remote fetch after this many ms (default 10_000). */
+    timeoutMs?: number;
+}
+/** Load, dereference, and validate a whole template file. */
+declare function loadTemplateFile(ref: string, options?: LoadTemplateOptions): Promise<TemplateFile>;
+/**
+ * Resolve a single template.
+ *
+ * A built-in id names one directly. A file or URL may name one inside itself
+ * with a `#` fragment; without a fragment a single-template file resolves
+ * unambiguously and anything else is an error listing what is on offer.
+ *
+ * `extends` is left unresolved - see `resolveExtends`.
+ */
+declare function loadTemplate(ref: string, options?: LoadTemplateOptions): Promise<Template>;
+/** How `resolveExtends` turns an `extends` ref into a template. */
+type TemplateResolver = (ref: string) => Promise<Template>;
+/**
+ * Resolve a template's `extends` chain, innermost first.
+ *
+ * `load` is injected because a relative `extends` is relative to the file the
+ * child came from, which this function has no way to know. `chain` is internal
+ * bookkeeping for cycle detection.
+ */
+declare function resolveExtends(template: Template, load?: TemplateResolver, chain?: string[]): Promise<Template>;
+
+/**
+ * Parser registry. Maps file extensions to parsers and resolves a parser by
+ * name for the `--as` override.
+ *
+ * Shaped after docmeta's extractor registry, and for the same reason:
+ * everything downstream of `parse()` operates on the generic `DocumentTree`, so
+ * adding a format is one file plus one line here - no change to matching,
+ * rules, templates, or reporting.
+ *
+ * A format is registered here when, and only when, a parser reads it. That is
+ * what `manni lint tools` lists and what `--as` accepts, so neither can name a
+ * format the tool does not read. An extension no parser claims is skipped by
+ * name, never parsed as Markdown the way the pre-rewrite `inferFileType` did.
+ */
+
+/** Resolve a parser for a file extension (including the dot). */
+declare function parserForExtension(ext: string): DocumentParser | undefined;
+/** Resolve a parser by its `--as` name. */
+declare function parserByName(name: string): DocumentParser | undefined;
+/** Extensions collected from a directory walk. */
+declare function supportedExtensions(): string[];
+/** Every format the tool reads, for `manni lint tools`. */
+declare function listFormats(): {
+    name: string;
+    label: string;
+    extensions: string[];
+    kinds: ContentKind[];
+}[];
+
+/**
+ * JUnit XML, rendered through **meta's** writer rather than a second one.
+ *
+ * There is no authoritative JUnit schema, and the escaping is the part a
+ * hand-rolled writer gets wrong - XML 1.0 forbids characters that sit quite
+ * happily in a JavaScript string, and one of them makes the whole document
+ * unparseable rather than merely mis-rendered. That work is done once, in
+ * `src/meta/reporters/junit.ts`, and cite already rides it. So does lint:
+ * adapt the run onto meta's `ValidationResult`, hand it to that writer, and
+ * the family ships one XML writer, one escaping rule, and one
+ * testcase-per-file convention.
+ *
+ * What is lint's is the two strings that identify the findings as lint's:
+ * the `classname` on every `<testcase>`, and the `<failure type>`, which is
+ * the namespaced rule id.
+ */
+
+/**
+ * Straight to meta's JUnit writer rather than through its `render`, which
+ * takes a `RunSummary` its junit branch does not forward. Building one here
+ * only to have it dropped read as though the suite's counts came from the run,
+ * and they do not: they are the length of the list above and how much of it
+ * carries an error-severity finding.
+ */
+declare function renderJunit(run: LintRun): string;
+
+/**
+ * Every `-f` value, plus `--explain`.
+ *
+ * The findings formats are the family's, taken from meta rather than restated,
+ * so a format added there is available here the moment lint's `render` grows a
+ * case for it - and a value lint does not handle is a compile error instead of
+ * a silent fall-through to pretty. `explain` is lint's own: it is reachable
+ * through `--explain` and never through `-f`, because it reports on
+ * configuration rather than on documents.
+ */
+type ReportFormat = ReportFormat$1 | "explain";
+/** Listing commands have nothing to annotate, so they offer no `github`. */
+type ListFormat = "pretty" | "json";
+interface ReportOptions {
+    color?: boolean;
+    /**
+     * Directory the run's relative paths are relative to, forwarded to the SARIF
+     * reporter and ignored by the others. Defaults to the process cwd, which is
+     * right for the CLI because `runLint` defaults its `cwd` the same way.
+     *
+     * It is here rather than only on `renderSarif` because `render` is the entry
+     * point a library caller reaches for, and without it that caller was pinned
+     * to the process cwd with no way out short of bypassing `render` entirely -
+     * for the one reporter whose whole output is paths.
+     */
+    root?: string;
+}
+declare function renderPretty(run: LintRun, opts?: ReportOptions): string;
+/**
+ * The published JSON shape, and the reason this builds objects by hand rather
+ * than stringifying `run.results` directly.
+ *
+ * manni docevals reads `[{ file, success, errors: [{ type, heading, message,
+ * position: { start: { line, column } } }] }]` off stdout, and it parses
+ * rather than validates - a renamed key produces zero findings, not an error.
+ * So: a bare array at the top level, and `errors`, even though the internal
+ * field is `findings`. Adding keys is safe; renaming or nesting is not.
+ */
+declare function renderJson(run: LintRun): string;
+/**
+ * GitHub workflow commands: one annotation per finding, shaped as cite's are -
+ * `::<severity> file=…,line=…,col=…,title=<ruleId>::<message>`.
+ *
+ * The rule id is a `title=` property rather than a `[type]` prefix inside the
+ * message. GitHub renders the title as the alert's own heading, so the prefix
+ * spelled the rule's name a second time; and `title` is the field a reader can
+ * group and filter on, which prose can never be.
+ *
+ * The level is the severity, not a constant `error`. The family scale was
+ * chosen to be GitHub's for exactly this: `::warning` and `::notice` render
+ * inline like `::error` but do not fail the check, which is the severity
+ * invariant in GitHub's terms, and it is load-bearing rather than theoretical:
+ * `unsupported_content_kind` is a `warning`, so it annotates the file without
+ * failing the job.
+ *
+ * Line breaks are escaped rather than collapsed to spaces, as this once did.
+ * `%0A` is the format's own answer and GitHub renders it as a multi-line
+ * annotation, so the message arrives whole; collapsing threw away the author's
+ * line breaks to solve a problem the escape already solves, and its `\r?\n`
+ * pattern let a bare carriage return through into the command untouched.
+ *
+ * The escaping itself is the family's, from `src/shared/github.ts`. It lives
+ * there precisely so a second renderer cannot re-derive it: the replacements
+ * are order-dependent (`%` first, or the escape sequences get escaped again),
+ * and a local copy that got the order wrong would look identical in review and
+ * only show itself on a message carrying a literal `%`.
+ */
+declare function renderGithub(run: LintRun): string;
+declare function render(run: LintRun, format: ReportFormat, opts?: ReportOptions): string;
+declare function renderTemplates(info: TemplatesInfo, format: ListFormat, opts?: ReportOptions): string;
+/**
+ * `manni lint tools`: one block per job. Every column is printed for every
+ * job, the negatives included - "not configured" beside a job that still runs
+ * on defaults is the answer someone ran this command to get.
+ */
+declare function renderTools(tools: ToolInfo[], format: ListFormat, opts?: ReportOptions): string;
+
+interface SarifOptions {
+    /**
+     * Directory the relative paths in `LintRun` are relative to - the lint run's
+     * `cwd`. Defaults to the process cwd, which is what `runLint` itself
+     * defaults to. It is a parameter rather than a bare read of `process.cwd()`
+     * so the URI mapping, the part most likely to be silently wrong, is testable
+     * without moving the whole process into a fixture directory.
+     */
+    root?: string;
+}
+declare function renderSarif(run: LintRun, opts?: SarifOptions): string;
+
+/**
+ * A finding's **rule identity**: `manni:lint/<job>/<rule>`.
+ *
+ * One id, in one place, for every consumer that files or correlates findings -
+ * the SARIF `ruleId`, the JUnit `<failure type>`, the GitHub annotation's
+ * `title`, and the `ruleId` the JSON reporter carries beside `type`. A rule id
+ * is durable by contract: rename one and every historical alert in a
+ * dashboard closes, then reopens as new.
+ *
+ * Three segments rather than cite's two. The job is what makes a second lint
+ * tool possible without collisions: a prose job will report
+ * `manni:lint/prose/Google.Passive`, keeping Vale's own rule name because that
+ * is the name Vale's documentation uses, and nothing about it can be confused
+ * with a structure rule. Proposal 0050 records the shape, and warns that
+ * anything parsing family rule ids must not assume two segments.
+ *
+ * The rule half is derived from the finding's `type` rather than authored
+ * beside it. `type` is already the machine-readable name the JSON reporter
+ * publishes - manni docevals' grader reads it - so a hand-maintained second
+ * table would be one more thing to keep in step, and the derivation cannot
+ * drift. `_error` is dropped because it says only that a finding is a finding;
+ * `heading_pattern_error` is the rule "heading-pattern".
+ */
+
+/** Every lint rule id starts here. */
+declare const RULE_ID_PREFIX = "manni:lint";
+/** The tool that performs the structure job, reported beside every finding. */
+declare const TOOL_NAME = "manni";
+/**
+ * `heading_pattern_error` -> `heading-pattern`; `parse_error` -> `parse`.
+ *
+ * Only a trailing `_error` is dropped, so a rule that is genuinely *about*
+ * errors keeps the word.
+ */
+declare function ruleName(type: string): string;
+/** `manni:lint/<job>/<rule>` for one finding `type`. */
+declare function ruleId(type: string, job?: LintJob): string;
+
+/**
+ * Drop every process-lifetime cache: parsed built-ins, fetched template files,
+ * compiled override globs, and compiled heading patterns.
+ *
+ * A CLI run never needs this - it lints one docset and exits, and the caches
+ * are what stop a tree of one doctype from re-reading the same template per
+ * page. A long-lived host is the different case: the maps grow with the number
+ * of distinct refs and patterns seen, and a cached remote template is served
+ * for the life of the process, so one republished upstream is never picked up.
+ * Call this between runs, or when a template may have changed underneath.
+ */
+declare function clearCaches(): void;
+
+type index$1_AdmonitionNode = AdmonitionNode;
+type index$1_AdmonitionsRule = AdmonitionsRule;
+type index$1_AttributesRule = AttributesRule;
+declare const index$1_BLOCK_KINDS: typeof BLOCK_KINDS;
+declare const index$1_BUILTIN_SOURCE: typeof BUILTIN_SOURCE;
+declare const index$1_BUILT_IN_DEFAULTS: typeof BUILT_IN_DEFAULTS;
+type index$1_BlockKind = BlockKind;
+type index$1_BlockRule = BlockRule;
+type index$1_BlockquoteNode = BlockquoteNode;
+type index$1_BuiltinInfo = BuiltinInfo;
+type index$1_CodeBlocksRule = CodeBlocksRule;
+type index$1_CodeNode = CodeNode;
+type index$1_ContentKind = ContentKind;
+type index$1_ContentNode = ContentNode;
+type index$1_ContentNodeBase = ContentNodeBase;
+type index$1_DefinitionItemNode = DefinitionItemNode;
+type index$1_DefinitionListNode = DefinitionListNode;
+type index$1_DocumentParser = DocumentParser;
+type index$1_DocumentTree = DocumentTree;
+type index$1_ElementNode = ElementNode;
+type index$1_ElementsRule = ElementsRule;
+type index$1_FileResult = FileResult;
+type index$1_Finding = Finding;
+type index$1_FormatInfo = FormatInfo;
+type index$1_HeadingRule = HeadingRule;
+type index$1_ImageNode = ImageNode;
+type index$1_ImagesRule = ImagesRule;
+declare const index$1_LINT_JOBS: typeof LINT_JOBS;
+declare const index$1_LINT_TOOLS: typeof LINT_TOOLS;
+type index$1_LintConfig = LintConfig;
+type index$1_LintError = LintError;
+declare const index$1_LintError: typeof LintError;
+type index$1_LintFileResult = LintFileResult;
+type index$1_LintJob = LintJob;
+type index$1_LintJobConfig = LintJobConfig;
+type index$1_LintOptions = LintOptions;
+type index$1_LintRun = LintRun;
+type index$1_LintRunOptions = LintRunOptions;
+type index$1_LintSummary = LintSummary;
+type index$1_LintTool = LintTool;
+type index$1_ListFormat = ListFormat;
+type index$1_ListItemNode = ListItemNode;
+type index$1_ListItemsRule = ListItemsRule;
+type index$1_ListNode = ListNode;
+type index$1_ListsRule = ListsRule;
+type index$1_LoadTemplateOptions = LoadTemplateOptions;
+type index$1_Match = Match;
+type index$1_MatchResult = MatchResult;
+type index$1_Occurrences = Occurrences;
+type index$1_ParagraphNode = ParagraphNode;
+type index$1_ParagraphsRule = ParagraphsRule;
+type index$1_Point = Point;
+type index$1_Position = Position;
 declare const index$1_RULE_ID_PREFIX: typeof RULE_ID_PREFIX;
-type index$1_ReadPageOptions = ReadPageOptions;
-type index$1_ReadSourceResult = ReadSourceResult;
-type index$1_RecommitReason = RecommitReason;
-type index$1_ReencryptCitationsResult = ReencryptCitationsResult;
-type index$1_ReencryptEntriesResult = ReencryptEntriesResult;
-type index$1_ReencryptOptions = ReencryptOptions;
-type index$1_ReencryptedCitation = ReencryptedCitation;
-type index$1_RefineClaimInput = RefineClaimInput;
-type index$1_Removal = Removal;
-type index$1_RemoveOptions = RemoveOptions;
-type index$1_RemovePage = RemovePage;
-type index$1_RemoveRun = RemoveRun;
-declare const index$1_SRC_PATTERN: typeof SRC_PATTERN;
-type index$1_ShiftOptions = ShiftOptions;
-type index$1_Shifted = Shifted;
-type index$1_ShownFile = ShownFile;
-type index$1_SourceEnd = SourceEnd;
-type index$1_SourceIndex = SourceIndex;
-type index$1_SourceRange = SourceRange;
-type index$1_SourceStatus = SourceStatus;
-type index$1_StatementForm = StatementForm;
-type index$1_TextEdit = TextEdit;
-type index$1_UpdateOptions = UpdateOptions;
-type index$1_UpdatePage = UpdatePage;
-type index$1_UpdateRewrite = UpdateRewrite;
-type index$1_UpdateRun = UpdateRun;
-declare const index$1_anchoredLines: typeof anchoredLines;
-declare const index$1_appendFrontmatterCitation: typeof appendFrontmatterCitation;
-declare const index$1_blockMatches: typeof blockMatches;
-declare const index$1_bodyLineOf: typeof bodyLineOf;
-declare const index$1_buildSourceIndex: typeof buildSourceIndex;
-declare const index$1_checkCitations: typeof checkCitations;
-declare const index$1_citationInputs: typeof citationInputs;
-declare const index$1_claimDiff: typeof claimDiff;
-declare const index$1_claimEnd: typeof claimEnd;
-declare const index$1_claimHistory: typeof claimHistory;
-declare const index$1_claimLine: typeof claimLine;
-declare const index$1_claimMessageFor: typeof claimMessageFor;
-declare const index$1_claimWords: typeof claimWords;
-declare const index$1_classifyCitation: typeof classifyCitation;
-declare const index$1_detectEol: typeof detectEol;
-declare const index$1_duplicateJoinRefusal: typeof duplicateJoinRefusal;
-declare const index$1_entryObject: typeof entryObject;
-declare const index$1_errorSite: typeof errorSite;
-declare const index$1_fenceSpanAt: typeof fenceSpanAt;
-declare const index$1_fencedBlockAfter: typeof fencedBlockAfter;
-declare const index$1_fencedBlockAt: typeof fencedBlockAt;
-declare const index$1_fencedBlocks: typeof fencedBlocks;
-declare const index$1_findWindows: typeof findWindows;
-declare const index$1_findingsFor: typeof findingsFor;
-declare const index$1_formatSrc: typeof formatSrc;
-declare const index$1_formatStatement: typeof formatStatement;
-declare const index$1_gitClient: typeof gitClient;
-declare const index$1_hashLines: typeof hashLines;
-declare const index$1_hashRange: typeof hashRange;
-declare const index$1_historyOf: typeof historyOf;
-declare const index$1_holdsWords: typeof holdsWords;
-declare const index$1_insertStatementBefore: typeof insertStatementBefore;
-declare const index$1_insideFence: typeof insideFence;
-declare const index$1_isBoundLine: typeof isBoundLine;
-declare const index$1_isCiteRule: typeof isCiteRule;
-declare const index$1_isKeyedPin: typeof isKeyedPin;
-declare const index$1_isTableRow: typeof isTableRow;
-declare const index$1_isUnitText: typeof isUnitText;
-declare const index$1_itemLine: typeof itemLine;
-declare const index$1_lineAt: typeof lineAt;
-declare const index$1_lineSpec: typeof lineSpec;
-declare const index$1_loadCitationSidecars: typeof loadCitationSidecars;
-declare const index$1_loadCiteConfig: typeof loadCiteConfig;
-declare const index$1_markerClaimEnd: typeof markerClaimEnd;
-declare const index$1_markerRunAt: typeof markerRunAt;
-declare const index$1_markerUnit: typeof markerUnit;
-declare const index$1_messageFor: typeof messageFor;
-declare const index$1_mintCitation: typeof mintCitation;
-declare const index$1_misplacedMarkerAt: typeof misplacedMarkerAt;
-declare const index$1_misplacedMarkers: typeof misplacedMarkers;
-declare const index$1_misplacedMessageFor: typeof misplacedMessageFor;
-declare const index$1_movedUnit: typeof movedUnit;
-declare const index$1_noGit: typeof noGit;
-declare const index$1_noUnitAt: typeof noUnitAt;
-declare const index$1_normalizeText: typeof normalizeText;
-declare const index$1_normalizeWhitespace: typeof normalizeWhitespace;
-declare const index$1_offsetOfLine: typeof offsetOfLine;
-declare const index$1_orphanRefusal: typeof orphanRefusal;
-declare const index$1_ownedMessage: typeof ownedMessage;
-declare const index$1_paragraphAfter: typeof paragraphAfter;
-declare const index$1_parseCiteConfig: typeof parseCiteConfig;
-declare const index$1_parseLines: typeof parseLines;
-declare const index$1_parseSrc: typeof parseSrc;
-declare const index$1_parseStatements: typeof parseStatements;
-declare const index$1_pickExtractor: typeof pickExtractor;
-declare const index$1_pinOfLines: typeof pinOfLines;
-declare const index$1_pre43Span: typeof pre43Span;
-declare const index$1_rangeLines: typeof rangeLines;
-declare const index$1_readCiteConfigFile: typeof readCiteConfigFile;
-declare const index$1_readPage: typeof readPage;
-declare const index$1_readSource: typeof readSource;
-declare const index$1_reencryptCitationEntries: typeof reencryptCitationEntries;
-declare const index$1_reencryptCitations: typeof reencryptCitations;
-declare const index$1_refineClaim: typeof refineClaim;
-declare const index$1_refusalLine: typeof refusalLine;
-declare const index$1_removalLine: typeof removalLine;
-declare const index$1_removeFrontmatterCitations: typeof removeFrontmatterCitations;
-declare const index$1_removeLine: typeof removeLine;
-declare const index$1_renderCheckGithub: typeof renderCheckGithub;
-declare const index$1_renderCheckJson: typeof renderCheckJson;
-declare const index$1_renderCheckPretty: typeof renderCheckPretty;
-declare const index$1_renderRemoveJson: typeof renderRemoveJson;
-declare const index$1_renderRemovePretty: typeof renderRemovePretty;
-declare const index$1_renderUpdateJson: typeof renderUpdateJson;
-declare const index$1_renderUpdatePretty: typeof renderUpdatePretty;
-declare const index$1_resolveCiteRun: typeof resolveCiteRun;
-declare const index$1_resolveSeverity: typeof resolveSeverity;
-declare const index$1_rewriteLine: typeof rewriteLine;
+type index$1_RefKind = RefKind;
+type index$1_ReportFormat = ReportFormat;
+type index$1_ReportOptions = ReportOptions;
+type index$1_ResolvedLintRun = ResolvedLintRun;
+type index$1_Rule = Rule;
+declare const index$1_STDIN_LABEL: typeof STDIN_LABEL;
+declare const index$1_STDIN_TOKEN: typeof STDIN_TOKEN;
+type index$1_SarifOptions = SarifOptions;
+type index$1_SectionNode = SectionNode;
+type index$1_Severity = Severity;
+type index$1_SkipReason = SkipReason;
+declare const index$1_TOOLS_BY_JOB: typeof TOOLS_BY_JOB;
+declare const index$1_TOOL_NAME: typeof TOOL_NAME;
+type index$1_TableCellNode = TableCellNode;
+type index$1_TableNode = TableNode;
+type index$1_TableRowNode = TableRowNode;
+type index$1_TablesRule = TablesRule;
+type index$1_Template = Template;
+type index$1_TemplateFile = TemplateFile;
+type index$1_TemplateInfo = TemplateInfo;
+type index$1_TemplateResolver = TemplateResolver;
+type index$1_TemplatesInfo = TemplatesInfo;
+type index$1_TemplatesOptions = TemplatesOptions;
+type index$1_ToolInfo = ToolInfo;
+type index$1_ToolsOptions = ToolsOptions;
+declare const index$1_classifyRef: typeof classifyRef;
+declare const index$1_clearCaches: typeof clearCaches;
+declare const index$1_headingMatches: typeof headingMatches;
+declare const index$1_isLintTool: typeof isLintTool;
+declare const index$1_isWildcard: typeof isWildcard;
+declare const index$1_listBuiltins: typeof listBuiltins;
+declare const index$1_listFormats: typeof listFormats;
+declare const index$1_loadConfig: typeof loadConfig;
+declare const index$1_loadTemplate: typeof loadTemplate;
+declare const index$1_loadTemplateFile: typeof loadTemplateFile;
+declare const index$1_matchSections: typeof matchSections;
+declare const index$1_occurrenceRange: typeof occurrenceRange;
+declare const index$1_palette: typeof palette;
+declare const index$1_parseConfig: typeof parseConfig;
+declare const index$1_parserByName: typeof parserByName;
+declare const index$1_parserForExtension: typeof parserForExtension;
+declare const index$1_rebaseConfig: typeof rebaseConfig;
+declare const index$1_render: typeof render;
+declare const index$1_renderGithub: typeof renderGithub;
+declare const index$1_renderJson: typeof renderJson;
+declare const index$1_renderJunit: typeof renderJunit;
+declare const index$1_renderPretty: typeof renderPretty;
+declare const index$1_renderSarif: typeof renderSarif;
+declare const index$1_renderTemplates: typeof renderTemplates;
+declare const index$1_renderTools: typeof renderTools;
+declare const index$1_resolveExtends: typeof resolveExtends;
+declare const index$1_resolveLintRun: typeof resolveLintRun;
 declare const index$1_ruleId: typeof ruleId;
-declare const index$1_runAdd: typeof runAdd;
-declare const index$1_runCheck: typeof runCheck;
-declare const index$1_runRemove: typeof runRemove;
-declare const index$1_runUpdate: typeof runUpdate;
-declare const index$1_runsHolding: typeof runsHolding;
-declare const index$1_sentencesOf: typeof sentencesOf;
-declare const index$1_sharesSentence: typeof sharesSentence;
-declare const index$1_shiftedEntries: typeof shiftedEntries;
-declare const index$1_shortCommit: typeof shortCommit;
-declare const index$1_shortLine: typeof shortLine;
-declare const index$1_shortPin: typeof shortPin;
-declare const index$1_shortSrc: typeof shortSrc;
-declare const index$1_sidecarsFor: typeof sidecarsFor;
-declare const index$1_sliceLines: typeof sliceLines;
-declare const index$1_sourceRange: typeof sourceRange;
-declare const index$1_spellAt: typeof spellAt;
-declare const index$1_spellLines: typeof spellLines;
-declare const index$1_spellSource: typeof spellSource;
-declare const index$1_splice: typeof splice;
-declare const index$1_spliceEntryField: typeof spliceEntryField;
-declare const index$1_splitLines: typeof splitLines;
-declare const index$1_splitUnit: typeof splitUnit;
-declare const index$1_statementForms: typeof statementForms;
-declare const index$1_stripMarkers: typeof stripMarkers;
-declare const index$1_toBodyLines: typeof toBodyLines;
-declare const index$1_toFileLines: typeof toFileLines;
-declare const index$1_toValidationResult: typeof toValidationResult;
-declare const index$1_twoManifestsRefusal: typeof twoManifestsRefusal;
-declare const index$1_unifiedDiff: typeof unifiedDiff;
-declare const index$1_unitAt: typeof unitAt;
-declare const index$1_unitText: typeof unitText;
-declare const index$1_urlManifestRefusal: typeof urlManifestRefusal;
-declare const index$1_validateEntry: typeof validateEntry;
-declare const index$1_withClaimLines: typeof withClaimLines;
+declare const index$1_ruleName: typeof ruleName;
+declare const index$1_runLint: typeof runLint;
+declare const index$1_runTemplates: typeof runTemplates;
+declare const index$1_runTools: typeof runTools;
+declare const index$1_shouldColor: typeof shouldColor;
+declare const index$1_supportedExtensions: typeof supportedExtensions;
+declare const index$1_validateDocument: typeof validateDocument;
+declare const index$1_validateSections: typeof validateSections;
 declare namespace index$1 {
-  export { type index$1_AddOptions as AddOptions, type index$1_AddResult as AddResult, type index$1_BuildIndexOptions as BuildIndexOptions, index$1_CITATIONS_KEY as CITATIONS_KEY, index$1_CITE_RULES as CITE_RULES, index$1_CITE_SECTION as CITE_SECTION, type index$1_CheckOptions as CheckOptions, type index$1_CheckPageOptions as CheckPageOptions, type index$1_CheckRun as CheckRun, type index$1_Citation as Citation, type index$1_CitationAnchor as CitationAnchor, type index$1_CitationClaim as CitationClaim, type index$1_CitationFinding as CitationFinding, type index$1_CitationInput as CitationInput, type index$1_CitationManifest as CitationManifest, type index$1_CitationOrigin as CitationOrigin, type index$1_CitationResult as CitationResult, type index$1_CitationSidecars as CitationSidecars, type index$1_CitationSource as CitationSource, type index$1_CiteConfig as CiteConfig, index$1_CiteError as CiteError, type index$1_CiteRule as CiteRule, type index$1_CiteRun as CiteRun, type index$1_CiteRunOptions as CiteRunOptions, type index$1_CiteSeverity as CiteSeverity, type index$1_ClaimEnd as ClaimEnd, type index$1_ClaimHistory as ClaimHistory, type index$1_ClaimHistoryInput as ClaimHistoryInput, type index$1_ClaimStatus as ClaimStatus, type index$1_ClaimUnit as ClaimUnit, type index$1_ClassifyOptions as ClassifyOptions, index$1_DEFAULT_CITE_BASELINE_PATH as DEFAULT_CITE_BASELINE_PATH, index$1_DEFAULT_SEVERITY as DEFAULT_SEVERITY, type index$1_EntryPath as EntryPath, index$1_FILE_PATTERN as FILE_PATTERN, type index$1_FindWindowsOptions as FindWindowsOptions, index$1_GIT_UNAVAILABLE_COMMIT as GIT_UNAVAILABLE_COMMIT, index$1_GIT_UNAVAILABLE_HISTORY as GIT_UNAVAILABLE_HISTORY, type index$1_GitClient as GitClient, type index$1_HeldManifest as HeldManifest, type index$1_History as History, type index$1_InlineStatement as InlineStatement, type index$1_LineSpec as LineSpec, type index$1_LoadSidecarOptions as LoadSidecarOptions, type index$1_LoadedCiteConfig as LoadedCiteConfig, index$1_MARKER_JSON as MARKER_JSON, index$1_MAX_MARKERS_PER_PAGE as MAX_MARKERS_PER_PAGE, index$1_MAX_PAGE_COMMITS as MAX_PAGE_COMMITS, index$1_MAX_RANGE_LINES as MAX_RANGE_LINES, index$1_MOVE_BUDGET_BYTES as MOVE_BUDGET_BYTES, index$1_MOVE_WINDOW_LINES as MOVE_WINDOW_LINES, type ManifestChange$1 as ManifestChange, index$1_ManifestSet as ManifestSet, type index$1_ManifestWrite as ManifestWrite, type index$1_MarkerEnd as MarkerEnd, type index$1_MintOptions as MintOptions, type index$1_MisplacedMarker as MisplacedMarker, type index$1_MisplacedMarkerReport as MisplacedMarkerReport, type index$1_MissingReason as MissingReason, type index$1_NoUnit as NoUnit, type index$1_OriginKind as OriginKind, index$1_PAGE_HISTORY_UNAVAILABLE as PAGE_HISTORY_UNAVAILABLE, type index$1_PageCitation as PageCitation, type index$1_PageCitationReport as PageCitationReport, type index$1_PageCitations as PageCitations, type index$1_PageCommit as PageCommit, type index$1_PageHistory as PageHistory, type index$1_PageLines as PageLines, type index$1_PageSidecar as PageSidecar, type index$1_PrettyOptions as PrettyOptions, index$1_RULE_ID_PREFIX as RULE_ID_PREFIX, type index$1_ReadPageOptions as ReadPageOptions, type index$1_ReadSourceResult as ReadSourceResult, type index$1_RecommitReason as RecommitReason, type index$1_ReencryptCitationsResult as ReencryptCitationsResult, type index$1_ReencryptEntriesResult as ReencryptEntriesResult, type index$1_ReencryptOptions as ReencryptOptions, type index$1_ReencryptedCitation as ReencryptedCitation, type index$1_RefineClaimInput as RefineClaimInput, type index$1_Removal as Removal, type index$1_RemoveOptions as RemoveOptions, type index$1_RemovePage as RemovePage, type index$1_RemoveRun as RemoveRun, index$1_SRC_PATTERN as SRC_PATTERN, type index$1_ShiftOptions as ShiftOptions, type index$1_Shifted as Shifted, type index$1_ShownFile as ShownFile, type index$1_SourceEnd as SourceEnd, type index$1_SourceIndex as SourceIndex, type index$1_SourceRange as SourceRange, type index$1_SourceStatus as SourceStatus, type index$1_StatementForm as StatementForm, type index$1_TextEdit as TextEdit, type index$1_UpdateOptions as UpdateOptions, type index$1_UpdatePage as UpdatePage, type index$1_UpdateRewrite as UpdateRewrite, type index$1_UpdateRun as UpdateRun, index$1_anchoredLines as anchoredLines, index$1_appendFrontmatterCitation as appendFrontmatterCitation, index$1_blockMatches as blockMatches, index$1_bodyLineOf as bodyLineOf, index$1_buildSourceIndex as buildSourceIndex, index$1_checkCitations as checkCitations, index$1_citationInputs as citationInputs, index$1_claimDiff as claimDiff, index$1_claimEnd as claimEnd, index$1_claimHistory as claimHistory, index$1_claimLine as claimLine, index$1_claimMessageFor as claimMessageFor, index$1_claimWords as claimWords, index$1_classifyCitation as classifyCitation, index$1_detectEol as detectEol, index$1_duplicateJoinRefusal as duplicateJoinRefusal, index$1_entryObject as entryObject, index$1_errorSite as errorSite, index$1_fenceSpanAt as fenceSpanAt, index$1_fencedBlockAfter as fencedBlockAfter, index$1_fencedBlockAt as fencedBlockAt, index$1_fencedBlocks as fencedBlocks, index$1_findWindows as findWindows, index$1_findingsFor as findingsFor, index$1_formatSrc as formatSrc, index$1_formatStatement as formatStatement, index$1_gitClient as gitClient, index$1_hashLines as hashLines, index$1_hashRange as hashRange, index$1_historyOf as historyOf, index$1_holdsWords as holdsWords, index$1_insertStatementBefore as insertStatementBefore, index$1_insideFence as insideFence, index$1_isBoundLine as isBoundLine, index$1_isCiteRule as isCiteRule, index$1_isKeyedPin as isKeyedPin, index$1_isTableRow as isTableRow, index$1_isUnitText as isUnitText, index$1_itemLine as itemLine, index$1_lineAt as lineAt, index$1_lineSpec as lineSpec, index$1_loadCitationSidecars as loadCitationSidecars, index$1_loadCiteConfig as loadCiteConfig, index$1_markerClaimEnd as markerClaimEnd, index$1_markerRunAt as markerRunAt, index$1_markerUnit as markerUnit, index$1_messageFor as messageFor, index$1_mintCitation as mintCitation, index$1_misplacedMarkerAt as misplacedMarkerAt, index$1_misplacedMarkers as misplacedMarkers, index$1_misplacedMessageFor as misplacedMessageFor, index$1_movedUnit as movedUnit, index$1_noGit as noGit, index$1_noUnitAt as noUnitAt, index$1_normalizeText as normalizeText, index$1_normalizeWhitespace as normalizeWhitespace, index$1_offsetOfLine as offsetOfLine, index$1_orphanRefusal as orphanRefusal, index$1_ownedMessage as ownedMessage, index$1_paragraphAfter as paragraphAfter, index$1_parseCiteConfig as parseCiteConfig, index$1_parseLines as parseLines, index$1_parseSrc as parseSrc, index$1_parseStatements as parseStatements, index$1_pickExtractor as pickExtractor, index$1_pinOfLines as pinOfLines, index$1_pre43Span as pre43Span, index$1_rangeLines as rangeLines, index$1_readCiteConfigFile as readCiteConfigFile, index$1_readPage as readPage, index$1_readSource as readSource, index$1_reencryptCitationEntries as reencryptCitationEntries, index$1_reencryptCitations as reencryptCitations, index$1_refineClaim as refineClaim, index$1_refusalLine as refusalLine, index$1_removalLine as removalLine, index$1_removeFrontmatterCitations as removeFrontmatterCitations, index$1_removeLine as removeLine, index$1_renderCheckGithub as renderCheckGithub, index$1_renderCheckJson as renderCheckJson, index$1_renderCheckPretty as renderCheckPretty, index$1_renderRemoveJson as renderRemoveJson, index$1_renderRemovePretty as renderRemovePretty, index$1_renderUpdateJson as renderUpdateJson, index$1_renderUpdatePretty as renderUpdatePretty, index$1_resolveCiteRun as resolveCiteRun, index$1_resolveSeverity as resolveSeverity, index$1_rewriteLine as rewriteLine, index$1_ruleId as ruleId, index$1_runAdd as runAdd, index$1_runCheck as runCheck, index$1_runRemove as runRemove, index$1_runUpdate as runUpdate, index$1_runsHolding as runsHolding, index$1_sentencesOf as sentencesOf, index$1_sharesSentence as sharesSentence, index$1_shiftedEntries as shiftedEntries, index$1_shortCommit as shortCommit, index$1_shortLine as shortLine, index$1_shortPin as shortPin, index$1_shortSrc as shortSrc, index$1_sidecarsFor as sidecarsFor, index$1_sliceLines as sliceLines, index$1_sourceRange as sourceRange, index$1_spellAt as spellAt, index$1_spellLines as spellLines, index$1_spellSource as spellSource, index$1_splice as splice, index$1_spliceEntryField as spliceEntryField, index$1_splitLines as splitLines, index$1_splitUnit as splitUnit, index$1_statementForms as statementForms, index$1_stripMarkers as stripMarkers, index$1_toBodyLines as toBodyLines, index$1_toFileLines as toFileLines, index$1_toValidationResult as toValidationResult, index$1_twoManifestsRefusal as twoManifestsRefusal, index$1_unifiedDiff as unifiedDiff, index$1_unitAt as unitAt, index$1_unitText as unitText, index$1_urlManifestRefusal as urlManifestRefusal, index$1_validateEntry as validateEntry, index$1_withClaimLines as withClaimLines };
+  export { type index$1_AdmonitionNode as AdmonitionNode, type index$1_AdmonitionsRule as AdmonitionsRule, type index$1_AttributesRule as AttributesRule, index$1_BLOCK_KINDS as BLOCK_KINDS, index$1_BUILTIN_SOURCE as BUILTIN_SOURCE, index$1_BUILT_IN_DEFAULTS as BUILT_IN_DEFAULTS, type index$1_BlockKind as BlockKind, type index$1_BlockRule as BlockRule, type index$1_BlockquoteNode as BlockquoteNode, type index$1_BuiltinInfo as BuiltinInfo, type index$1_CodeBlocksRule as CodeBlocksRule, type index$1_CodeNode as CodeNode, type index$1_ContentKind as ContentKind, type index$1_ContentNode as ContentNode, type index$1_ContentNodeBase as ContentNodeBase, type index$1_DefinitionItemNode as DefinitionItemNode, type index$1_DefinitionListNode as DefinitionListNode, type index$1_DocumentParser as DocumentParser, type index$1_DocumentTree as DocumentTree, type index$1_ElementNode as ElementNode, type index$1_ElementsRule as ElementsRule, type index$1_FileResult as FileResult, type index$1_Finding as Finding, type index$1_FormatInfo as FormatInfo, type index$1_HeadingRule as HeadingRule, type index$1_ImageNode as ImageNode, type index$1_ImagesRule as ImagesRule, index$1_LINT_JOBS as LINT_JOBS, index$1_LINT_TOOLS as LINT_TOOLS, type index$1_LintConfig as LintConfig, index$1_LintError as LintError, type index$1_LintFileResult as LintFileResult, type index$1_LintJob as LintJob, type index$1_LintJobConfig as LintJobConfig, type index$1_LintOptions as LintOptions, type index$1_LintRun as LintRun, type index$1_LintRunOptions as LintRunOptions, type index$1_LintSummary as LintSummary, type index$1_LintTool as LintTool, type index$1_ListFormat as ListFormat, type index$1_ListItemNode as ListItemNode, type index$1_ListItemsRule as ListItemsRule, type index$1_ListNode as ListNode, type index$1_ListsRule as ListsRule, type index$1_LoadTemplateOptions as LoadTemplateOptions, type index$1_Match as Match, type index$1_MatchResult as MatchResult, type index$1_Occurrences as Occurrences, type index$1_ParagraphNode as ParagraphNode, type index$1_ParagraphsRule as ParagraphsRule, type index$1_Point as Point, type index$1_Position as Position, index$1_RULE_ID_PREFIX as RULE_ID_PREFIX, type index$1_RefKind as RefKind, type index$1_ReportFormat as ReportFormat, type index$1_ReportOptions as ReportOptions, type index$1_ResolvedLintRun as ResolvedLintRun, type index$1_Rule as Rule, index$1_STDIN_LABEL as STDIN_LABEL, index$1_STDIN_TOKEN as STDIN_TOKEN, type index$1_SarifOptions as SarifOptions, type index$1_SectionNode as SectionNode, type index$1_Severity as Severity, type index$1_SkipReason as SkipReason, index$1_TOOLS_BY_JOB as TOOLS_BY_JOB, index$1_TOOL_NAME as TOOL_NAME, type index$1_TableCellNode as TableCellNode, type index$1_TableNode as TableNode, type index$1_TableRowNode as TableRowNode, type index$1_TablesRule as TablesRule, type index$1_Template as Template, type index$1_TemplateFile as TemplateFile, type index$1_TemplateInfo as TemplateInfo, type index$1_TemplateResolver as TemplateResolver, type index$1_TemplatesInfo as TemplatesInfo, type index$1_TemplatesOptions as TemplatesOptions, type index$1_ToolInfo as ToolInfo, type index$1_ToolsOptions as ToolsOptions, index$1_classifyRef as classifyRef, index$1_clearCaches as clearCaches, index$1_headingMatches as headingMatches, index$1_isLintTool as isLintTool, index$1_isWildcard as isWildcard, index$1_listBuiltins as listBuiltins, index$1_listFormats as listFormats, index$1_loadConfig as loadConfig, index$1_loadTemplate as loadTemplate, index$1_loadTemplateFile as loadTemplateFile, index$1_matchSections as matchSections, index$1_occurrenceRange as occurrenceRange, index$1_palette as palette, index$1_parseConfig as parseConfig, index$1_parserByName as parserByName, index$1_parserForExtension as parserForExtension, index$1_rebaseConfig as rebaseConfig, index$1_render as render, index$1_renderGithub as renderGithub, index$1_renderJson as renderJson, index$1_renderJunit as renderJunit, index$1_renderPretty as renderPretty, index$1_renderSarif as renderSarif, index$1_renderTemplates as renderTemplates, index$1_renderTools as renderTools, index$1_resolveExtends as resolveExtends, index$1_resolveLintRun as resolveLintRun, index$1_ruleId as ruleId, index$1_ruleName as ruleName, index$1_runLint as runLint, index$1_runTemplates as runTemplates, index$1_runTools as runTools, index$1_shouldColor as shouldColor, index$1_supportedExtensions as supportedExtensions, index$1_validateDocument as validateDocument, index$1_validateSections as validateSections };
 }
 
 /**
@@ -6050,4 +7526,4 @@ declare namespace index {
   export { type index_EncryptionContext as EncryptionContext, index_KeyError as KeyError, type index_KeyRotateOptions as KeyRotateOptions, type index_KeyRotateResult as KeyRotateResult, type index_KeySetOptions as KeySetOptions, type index_KeySetResult as KeySetResult, type index_KeySource as KeySource, type index_ResolvedKey as ResolvedKey, type index_RotateManifest as RotateManifest, type index_RotateOutcome as RotateOutcome, type index_RotatePage as RotatePage, type index_RotatedCitation as RotatedCitation, type index_RotatedManifestValue as RotatedManifestValue, type index_RotatedMetadata as RotatedMetadata, type index_RotatedValue as RotatedValue, type index_SkippedCitation as SkippedCitation, type index_SkippedManifestValue as SkippedManifestValue, type index_SkippedMetadata as SkippedMetadata, type index_SkippedValue as SkippedValue, index_decryptValue as decryptValue, index_encryptValue as encryptValue, index_isEncryptedValue as isEncryptedValue, index_resolveEncryptionKey as resolveEncryptionKey, index_runKeyRotate as runKeyRotate, index_runKeySet as runKeySet };
 }
 
-export { type ApplyOptions, type Approval, type BaselineSummary, BinMissing, type BuiltinDerivableField, COMMON_FORMATS, type CheckConfig, type CollectionConfig, type CommandSourceOptions, type CommandSourceResult, type CommonFormat, type ConfigNotice, DEFAULT_SCHEMAS, DEFAULT_TTL_HOURS, DEFAULT_VENDOR_DIR, DERIVABLE_FIELDS, DERIVED_KEYWORD, DERIVED_STALE_SCHEMA, DERIVE_FORMATS, DERIVE_SOURCES, type DerivableField, type DeriveCommand, type DeriveCommandConfig, type DeriveConfig, type DeriveContext, type DeriveFileResult, type DeriveInput, type DeriveOptions, type DeriveReportFormat, type DeriveReportOptions, type DeriveResult, type DeriveRun, type DeriveSource, type DeriveSummary, type DerivedField, type DerivedRecord, type DerivedStatus, type DerivedValue, type DocmetaConfig, DocmetaError, type DocumentRefTrust, EXTERNAL_DUPLICATE_SCHEMA, EXTERNAL_KEYWORD, EXTERNAL_METADATA_FETCH_MAX_BYTES, EXTERNAL_METADATA_FETCH_TIMEOUT_MS, EXTERNAL_OWNED_SCHEMA, type ExternalMetadataCollision, type ExternalMetadataConfig, type ExternalMetadataEntry, type ExternalMetadataFetchOptions, type ExternalMetadataIndex, type ExternalMetadataJoin, type ExternalMetadataValue, type ExtractOptions, type ExtractedMetadata, FIELD_SOURCES, FILL_FORMATS, type FetchedSchema, type FieldError, type FieldLocation, type FillConfig, type FillFileResult, type FillOptions, type FillReportFormat, type FillReportOptions, type FillRun, type FillSummary, type FilledField, type FingerprintContext, type FrontmatterFlavor, type FrontmatterLocation, type GetFileResult, type GetOptions, type GetReportOptions, GitHubClient, GitLabClient, INTEGRITY_SHAPE, type JunitOptions, LOCATION_KEYWORD, type LoadExternalMetadataOptions, type LoadSchemaOptions, type LoadedConfig, type LocationPreference, type MergedChange, type MergedMetadata, type MetadataExtractor, type MetadataPatch, PATH_JOIN, PATH_PLACEHOLDER, QUERY_FORMATS, type QueryChange, type QueryFormat, type QueryOptions, type QueryReportOptions, type QueryRun, REPORT_FORMATS, RESOLVED_VIEW, REVIEW_CACHE_DIR, REVIEW_CACHE_VERSION, type ReadOptions, type ReencryptMetadataResult, type ReencryptedValue, type RelocateOptions, type RelocateResult, type RemoteIdentity, type ReportFormat, type ReportOptions, ReviewCache, type ReviewClient, type ReviewFacts, type ReviewSourceInput, type ReviewSourceResult, type Run, type RunConfig, type RunConfigOptions, type RunSummary, SCHEMA_CACHE_DIR, SCHEMA_CACHE_VERSION, type SarifOptions, SchemaCache, type SchemaCacheConfig, type SchemaCacheEntry, type SchemaEntry, type SchemaPin, type SchemaRefEntry, type SchemaTrustConfig, type SkipReason, type SourceLocation, type SourceStatus$1 as SourceStatus, type SpawnOptions, type ValidateOptions, type ValidateRun, type ValidationResult, Validator, type VendorOptions, type VendorResult, applyFrontmatter, argvFor, assertSourcesAvailable, cachedClient, index$1 as cite, classifyRef, collectSchemaPins, compareDerived, consultedSources, createResolvedView, createReviewClient, deriveFromCommands, deriveFromReviews, deriveMetadata, externalMetadataJoin, externalMetadataPointer, externalMetadataUrlProblem, extractFrontmatter, extractorForExtension, fetchExternalMetadata, fetchSchemaBytes, frontmatterInnerText, getSchemasInfo, identityFromOrigin, integrityOf, isBuiltinField, isCommonFormat, isDeriveFormat, isDeriveSource, isErrorSeverity, isFillFormat, isIntegrity, isMember, isPerFile, isQueryFormat, isReportFormat, index as key, listBuiltins, loadConfig, loadExternalMetadata, loadSchema, locateFrontmatter, memberOf, mentionsResolved, mergeExternalMetadata, orphanEntries, orphanError, orphanJoins, parseCollections, parseConfig, parseOriginUrl, rebaseConfigSchemaRefs, reencryptMetadata, render, renderDerive, renderFill, renderFillGithub, renderGet, renderJunit, renderQuery, renderQueryCsv, renderSarif, resolveRunConfig, resolveSchemaSet, resolvedColumns, run, runDerive, runFill, runGet, runQuery, runRelocate, runValidate, runVendorSchema, schemaCacheDir, schemaEntryRef, schemaLoadOptions, selectCollections, sourcesFor, staleFindings, stringifyValue, supportedExtensions, valueOf, vendorFileName, writeFileAtomic };
+export { type ApplyOptions, type Approval, type BaselineSummary, BinMissing, type BuiltinDerivableField, COMMON_FORMATS, type CheckConfig, type CollectionConfig, type CommandSourceOptions, type CommandSourceResult, type CommonFormat, type ConfigNotice, DEFAULT_SCHEMAS, DEFAULT_TTL_HOURS, DEFAULT_VENDOR_DIR, DERIVABLE_FIELDS, DERIVED_KEYWORD, DERIVED_STALE_SCHEMA, DERIVE_FORMATS, DERIVE_SOURCES, type DerivableField, type DeriveCommand, type DeriveCommandConfig, type DeriveConfig, type DeriveContext, type DeriveFileResult, type DeriveInput, type DeriveOptions, type DeriveReportFormat, type DeriveReportOptions, type DeriveResult, type DeriveRun, type DeriveSource, type DeriveSummary, type DerivedField, type DerivedRecord, type DerivedStatus, type DerivedValue, type DocmetaConfig, DocmetaError, type DocumentRefTrust, EXTERNAL_DUPLICATE_SCHEMA, EXTERNAL_KEYWORD, EXTERNAL_METADATA_FETCH_MAX_BYTES, EXTERNAL_METADATA_FETCH_TIMEOUT_MS, EXTERNAL_OWNED_SCHEMA, type ExternalMetadataCollision, type ExternalMetadataConfig, type ExternalMetadataEntry, type ExternalMetadataFetchOptions, type ExternalMetadataIndex, type ExternalMetadataJoin, type ExternalMetadataValue, type ExtractOptions, type ExtractedMetadata, FIELD_SOURCES, FILL_FORMATS, type FetchedSchema, type FieldError, type FieldLocation, type FillConfig, type FillFileResult, type FillOptions, type FillReportFormat, type FillReportOptions, type FillRun, type FillSummary, type FilledField, type FingerprintContext, type FrontmatterFlavor, type FrontmatterLocation, type GetFileResult, type GetOptions, type GetReportOptions, GitHubClient, GitLabClient, INTEGRITY_SHAPE, type JunitOptions, LOCATION_KEYWORD, type LoadExternalMetadataOptions, type LoadSchemaOptions, type LoadedConfig, type LocationPreference, MERGE_SAFE_FIELDS, type MergedChange, type MergedMetadata, type MetadataExtractor, type MetadataPatch, PATH_JOIN, PATH_PLACEHOLDER, QUERY_FORMATS, type QueryChange, type QueryFormat, type QueryOptions, type QueryReportOptions, type QueryRun, REPORT_FORMATS, RESOLVED_VIEW, REVIEW_CACHE_DIR, REVIEW_CACHE_VERSION, type ReadOptions, type ReencryptMetadataResult, type ReencryptedValue, type RegisteredSchema, type RegisteredSchemas, type RelocateOptions, type RelocateResult, type RemoteIdentity, type ReportFormat$1 as ReportFormat, type ReportOptions$1 as ReportOptions, ReviewCache, type ReviewClient, type ReviewFacts, type ReviewSourceInput, type ReviewSourceResult, type Run, type RunConfig, type RunConfigOptions, type RunSummary, SCHEMA_CACHE_DIR, SCHEMA_CACHE_VERSION, type SarifOptions$1 as SarifOptions, SchemaCache, type SchemaCacheConfig, type SchemaCacheEntry, type SchemaEntry, type SchemaPin, type SchemaRefEntry, type SchemaTrustConfig, type SkipReason$1 as SkipReason, type SourceLocation, type SourceStatus$1 as SourceStatus, type SpawnOptions, type ValidateOptions$1 as ValidateOptions, type ValidateRun, type ValidationResult, Validator, type VendorOptions, type VendorResult, applyFrontmatter, argvFor, assertSourcesAvailable, cachedClient, index$2 as cite, classifyRef$1 as classifyRef, collectSchemaPins, compareDerived, consultedSources, createResolvedView, createReviewClient, deriveFromCommands, deriveFromReviews, deriveMetadata, externalMetadataJoin, externalMetadataPointer, externalMetadataUrlProblem, extractFrontmatter, extractorForExtension, fetchExternalMetadata, fetchSchemaBytes, frontmatterInnerText, getSchemasInfo, identityFromOrigin, integrityOf, isBuiltinField, isCommonFormat, isDeriveFormat, isDeriveSource, isErrorSeverity, isFillFormat, isIntegrity, isMember, isPerFile, isQueryFormat, isReportFormat, index as key, index$1 as lint, listBuiltins$1 as listBuiltins, loadConfig$1 as loadConfig, loadExternalMetadata, loadSchema, locateFrontmatter, memberOf, mentionsResolved, mergeExternalMetadata, orphanEntries, orphanError, orphanJoins, parseCollections, parseConfig$1 as parseConfig, parseOriginUrl, rebaseConfigSchemaRefs, reencryptMetadata, render$1 as render, renderDerive, renderFill, renderFillGithub, renderGet, renderJunit$1 as renderJunit, renderQuery, renderQueryCsv, renderSarif$1 as renderSarif, resolveRunConfig, resolveSchemaSet, resolvedColumns, run, runDerive, runFill, runGet, runQuery, runRelocate, runValidate, runVendorSchema, schemaCacheDir, schemaEntryRef, schemaLoadOptions, selectCollections, sourcesFor, staleFindings, stringifyValue, supportedExtensions$1 as supportedExtensions, valueOf, vendorFileName, writeFileAtomic };