@heroiclands/package-build 20.4.0 → 20.6.0

package/types/engine/content-lint.d.mts

@@ -46,7 +46,8 @@ export function lintContentTree(contentBase: string, { skipDirectories, contentP
     keys: number;
 };
 /**
- * The shape every `shortcode` must match: ASCII letters and digits only.
+ * The shape every `shortcode` must match: lowercase ASCII letters and digits
+ * only.
  *
  * This is {@link ADDRESS_SEGMENT_PATTERN}, not a second copy of it. A shortcode
  * is the last segment of a canonical address, and the rule it is held to is the
@@ -54,9 +55,10 @@ export function lintContentTree(contentBase: string, { skipDirectories, contentP
  * free to drift apart. The name survives because this is where the rule
  * is applied to a note.
  *
- * Case is deliberately **not** constrained: hundreds of authored shortcodes are
- * mixed-case and collide with nothing, so tightening that is a separate
- * decision from this one.
+ * Case is held to that rule with no exception: two shortcodes differing only
+ * in case are two names nobody can tell apart, and `canonicalKey` lowercases
+ * every address it builds regardless, so a mixed-case shortcode addresses the
+ * same document as its lowercase spelling.
  *
  * A consuming system's *runtime* keeps its own copy of this pattern — it cannot
  * import a build-time dependency into shipped code — and is expected to pin the

package/types/engine/content-tables.d.mts

@@ -73,34 +73,65 @@ export function selectRows(spec: object, docs: Array<ContentTableDoc>, self?: Co
  * @returns {string} The markdown table (no trailing newline).
  */
 export function renderContentTable(spec: object, rows: Array<ContentTableDoc>, linkable: (doc: ContentTableDoc) => boolean, self?: ContentTableDoc): string;
-export function expandContentTables(markdown: any, { docs, linkable, source, self, sqlTables, }?: {
-    docs?: never[] | undefined;
-    linkable?: (() => boolean) | undefined;
+/**
+ * Expand every fenced `dataview` and `sql` block in a markdown body.
+ *
+ * A block that cannot be honoured — malformed or unsupported — is left in the
+ * body verbatim and reported in `errors`, so the failure is visible in the
+ * output as well as on the console. Every other code fence, and every code
+ * span, is left alone (that is how the syntax is documented).
+ *
+ * A query that selects **no** note is an error unless the fence says
+ * `allow-empty`, which states that an empty table is the intended result.
+ *
+ * @param {string} markdown - The note body, frontmatter already stripped.
+ * @param {object} ctx
+ * @param {Array<ContentTableDoc>} ctx.docs - The searchable universe: every
+ *   content note the caller considers in scope.
+ * @param {(doc: ContentTableDoc) => boolean} [ctx.linkable] - Whether a note can
+ *   be linked to from a cell; defaults to never.
+ * @param {string} [ctx.source] - The note being expanded, for error reports.
+ * @param {ContentTableDoc} [ctx.self] - The note being expanded, as a searchable
+ *   doc: what a query's `this` reads.
+ * @param {object[]} [ctx.sqlTables] - This note's prepared `sql` results, in
+ *   document order, from
+ *   {@link module:engine/sql-tables.prepareSqlTables}. An `sql` directive with
+ *   no prepared result is an error: nothing here runs a query.
+ * @returns {{markdown: string, errors: Array<{source: string, directive: string,
+ *   reason: string, line: number, column?: number}>,
+ *   warnings: Array<{source: string, line: number, column: number,
+ *   reason: string}>, lineMap: Array<{line: number, generated: boolean}>}}
+ *   `lineMap` is parallel to the emitted lines and says which authored line
+ *   each came from, so a diagnostic about the expanded body can name an
+ *   authored position. An `errors` entry carries the 0-based line of the
+ *   directive that failed, for the same reason. `warnings` holds one entry per
+ *   `dataview` directive the body still authors.
+ */
+export function expandContentTables(markdown: string, { docs, linkable, source, self, sqlTables, }?: {
+    docs: Array<ContentTableDoc>;
+    linkable?: ((doc: ContentTableDoc) => boolean) | undefined;
     source?: string | undefined;
-    self?: undefined;
-    sqlTables?: undefined;
+    self?: ContentTableDoc | undefined;
+    sqlTables?: object[] | undefined;
 }): {
     markdown: string;
-    errors: ({
-        source: string;
-        directive: string;
-        reason: any;
-        line: number;
-        column: number;
-    } | {
+    errors: Array<{
         source: string;
         directive: string;
-        reason: any;
+        reason: string;
         line: number;
-        column?: undefined;
-    })[];
-    warnings: {
+        column?: number;
+    }>;
+    warnings: Array<{
         source: string;
         line: number;
         column: number;
         reason: string;
-    }[];
-    lineMap: any[];
+    }>;
+    lineMap: Array<{
+        line: number;
+        generated: boolean;
+    }>;
 };
 /**
  * One content note as a content build hands it to the expander: its parsed

package/types/engine/frontmatter-lint.d.mts

@@ -112,8 +112,9 @@ export function matchesKind(value: unknown, kind: string): boolean;
  * @param {object} note - A note from the link index (`{fm, file, raw, type}`).
  * @param {object} opts
  * @param {Record<string, readonly object[]>} opts.schemas - Type → declaration.
- * @param {object} [opts.index] - The link index, for the reference check. Its
- *   absence skips that check rather than reporting every reference as dead.
+ * @param {object} [opts.index] - The link index, for the reference check, which
+ *   runs through its `referenceHit`. Its absence skips that check rather than
+ *   reporting every reference as dead.
  * @param {Record<string, object>} [opts.vocabulary] - Type → the closed regions
  *   it declares, as `engine/note-vocabulary.mjs` states them. Supplied
  *   by the caller for the same reason `schemas` is: this module validates a

package/types/engine/helpers.d.mts

@@ -23,24 +23,6 @@ export function parseMarkdownFile(filePath: any): {
     bodyLine: number;
     bodyColumn: number;
 };
-/**
- * Recursively yields every `.md` file under `rootDir`, parsed.
- * Yields `{ frontmatter, body, description, file, absPath, bodyLine,
- * bodyColumn }` for each match — the last two from
- * {@link parseMarkdownFile}, so a caller can report a position inside the
- * body as a position in the file.
- * Silently skips directories that don't exist.
- *
- * Directory names in `skipDirectories` are ignored wherever they appear. The
- * walk itself knows nothing about what they mean: `Templates/` is an Obsidian
- * templater convention this repository's vault happens to use, not a property
- * of a content tree, so it is configured rather than hard-coded.
- *
- * @param {string} rootDir - Root of the tree to walk.
- * @param {object} [opts]
- * @param {readonly string[]} [opts.skipDirectories] - Directory names to ignore.
- *   Defaults to the configured list.
- */
 /**
  * Refuse a corpus read whose scope its caller did not state.
  *
@@ -78,8 +60,35 @@ export function assertStatedScope(skipDirectories: readonly string[] | undefined
  * @returns {void}
  */
 export function assertSuppliedCorpus(records: readonly object[] | undefined, who: string): void;
-export function walkMarkdownTree(rootDir: any, { skipDirectories }?: {}): Generator<{
-    file: string;
+/**
+ * Recursively yields every `.md` file under `rootDir`, parsed.
+ *
+ * Yields `{ frontmatter, body, description, file, absPath, bodyLine,
+ * bodyColumn }` for each match — the last from {@link parseMarkdownFile}, so a
+ * caller can report a position inside the body as a position in the file. A
+ * root that does not exist yields nothing, and a directory that cannot be read
+ * is warned about and skipped.
+ *
+ * Directory names in `skipDirectories` are ignored wherever they appear. The
+ * walk itself knows nothing about what they mean: `Templates/` is an Obsidian
+ * templater convention this repository's vault happens to use, not a property
+ * of a content tree, so it is stated by the caller rather than hard-coded.
+ *
+ * @param {string} rootDir - Root of the tree to walk.
+ * @param {object} opts
+ * @param {readonly string[]} opts.skipDirectories - Directory names to ignore.
+ *   Required: the scope is the caller's to state, so two passes cannot
+ *   disagree about which files are the corpus.
+ * @yields {{frontmatter: object|null, body: string, description: string,
+ *   file: string, absPath: string, bodyLine?: number, bodyColumn?: number}}
+ *   One entry per `.md` file found.
+ * @throws {Error} When `skipDirectories` is not stated — see
+ *   {@link assertStatedScope}.
+ */
+export function walkMarkdownTree(rootDir: string, { skipDirectories }?: {
+    skipDirectories: readonly string[];
+}): Generator<{
+    file: string & NonSharedBuffer;
     absPath: string;
     frontmatter: null;
     body: string;
@@ -87,7 +96,7 @@ export function walkMarkdownTree(rootDir: any, { skipDirectories }?: {}): Genera
     bodyLine?: undefined;
     bodyColumn?: undefined;
 } | {
-    file: string;
+    file: string & NonSharedBuffer;
     absPath: string;
     frontmatter: any;
     body: string;
@@ -240,14 +249,22 @@ export function makeFilename(name: any, id: any): string;
  * `itemArt()`, which runs the path back through this function so a registry
  * entry and a note's `img:` are spelled the same way (#7).
  *
+ * **A package with no asset root cannot answer at all.** `assetRoot` is derived
+ * from the package kind, and a `documentation` package has none: Foundry serves
+ * no files for it. Only a compiling pass reaches here, and a documentation
+ * package runs none, so a path arriving with no root to put it under is a pass
+ * running where it should not — reported as that, rather than emitted as
+ * `null/icons/relic.svg` into a document nobody would check.
+ *
  * @param {string | null | undefined} raw - content-relative path from frontmatter.
- * @param {{assetRoot: string}} [config] - The resolved build configuration.
+ * @param {{assetRoot: string|null}} [config] - The resolved build configuration.
  *   Defaults to this repository's.
  * @returns {string | null} the Foundry-relative path; `""` for a deliberate
  *   blank, and `null` when the note names no art at all.
+ * @throws {Error} When the configuration has no asset root.
  */
 export function resolveImg(raw: string | null | undefined, config?: {
-    assetRoot: string;
+    assetRoot: string | null;
 }): string | null;
 /**
  * Resolves the display name from frontmatter, preferring `name.full`,
@@ -368,9 +385,23 @@ export function defaultStats(): object;
  * @param {object} [router] - The pack router. Supplied by the calling pass so
  *   the index and the compile agree about where each note landed; defaults to
  *   this repository's own.
+ * @param {object} [opts]
+ * @param {readonly string[]} [opts.skipDirectories] - Part of the options bag
+ *   every corpus reader takes; the scope is already settled by `records`.
+ * @param {object} [opts.config] - The resolved build configuration; loaded when
+ *   omitted.
+ * @param {readonly object[]} [opts.records] - The corpus, derived once per
+ *   compile and handed in. Required: see {@link assertSuppliedCorpus}.
+ * @param {object[]} [opts.problems] - Part of the same options bag; the notes
+ *   the index cannot record are collected where the corpus is derived.
  * @returns {{byShortcode: Map, types: Set}} From `buildWikilinkIndex`.
  */
-export function buildContentLinkIndex(contentBase: string, router?: object, { skipDirectories, config, records, problems }?: {}): {
+export function buildContentLinkIndex(contentBase: string, router?: object, { skipDirectories, config, records, problems }?: {
+    skipDirectories?: readonly string[] | undefined;
+    config?: object | undefined;
+    records?: readonly object[] | undefined;
+    problems?: object[] | undefined;
+}): {
     byShortcode: Map<any, any>;
     types: Set<any>;
 };
@@ -386,18 +417,42 @@ export function buildContentLinkIndex(contentBase: string, router?: object, { sk
  * inventing a position.
  *
  * @param {string} body - The note's markdown body, tables already expanded.
- * @param {object} ctx - `{ type, id, pack, docPack, index, name }` — `name` is
- *   used in the message, and the two pack names address a `[[#slug]]`
- *   self-link, whose target is the source note itself and so has no index
- *   entry. Position is carried by `{ file, bodyLine, bodyColumn, lineMap }`,
- *   the last from {@link expandNoteTables}.
+ * @param {object} ctx
+ * @param {string} ctx.type - The source note's content type.
+ * @param {string} ctx.id - The source note's document id.
+ * @param {string} ctx.pack - The pack the note's own document lands in, which
+ *   addresses a `[[#slug]]` self-link: its target is the source note itself, so
+ *   it has no index entry.
+ * @param {string} ctx.docPack - The pack the note's documentation journal lands
+ *   in, addressing a self-link the same way.
+ * @param {object} ctx.index - The address index every link resolves through.
+ * @param {string} ctx.name - The note, for the message.
+ * @param {string} [ctx.file] - The note's file, so a report names it.
+ * @param {number} [ctx.bodyLine] - 1-based file line of the body's first line.
+ * @param {number} [ctx.bodyColumn] - 1-based file column of the same character.
+ * @param {Array<{line: number, generated: boolean}>} [ctx.lineMap] - Which
+ *   authored line each body line came from, from {@link expandNoteTables}.
  * @returns {{markdown: string, unresolved: Array<object>}}
  * @throws {Error} On any link that does not resolve — an unlabelled one, a
  *   target that is not an address, or an address nothing publishes. The error
  *   carries `file` and `position`, so a caller reports it in the same form
  *   rather than re-deriving one.
  */
-export function convertNoteWikilinks(body: string, { type, id, pack, docPack, index, name, file, bodyLine, bodyColumn, lineMap }: object): {
+export function convertNoteWikilinks(body: string, { type, id, pack, docPack, index, name, file, bodyLine, bodyColumn, lineMap }: {
+    type: string;
+    id: string;
+    pack: string;
+    docPack: string;
+    index: object;
+    name: string;
+    file?: string | undefined;
+    bodyLine?: number | undefined;
+    bodyColumn?: number | undefined;
+    lineMap?: {
+        line: number;
+        generated: boolean;
+    }[] | undefined;
+}): {
     markdown: string;
     unresolved: Array<object>;
 };
@@ -407,10 +462,24 @@ export function convertNoteWikilinks(body: string, { type, id, pack, docPack, in
  * a table that leaves rows tied still emits identically on every build.
  *
  * @param {string} contentBase - Root of the content tree.
+ * @param {object} [opts]
+ * @param {readonly string[]} [opts.skipDirectories] - Part of the options bag
+ *   every corpus reader takes; the scope is already settled by `records`.
+ * @param {object} [opts.config] - The resolved build configuration; loaded when
+ *   omitted.
+ * @param {readonly object[]} [opts.records] - The corpus, derived once per
+ *   compile and handed in. Required: see {@link assertSuppliedCorpus}.
+ * @param {object[]} [opts.problems] - Part of the same options bag; the notes
+ *   the walk cannot read are collected where the corpus is derived.
  * @returns {Array<{fm: object, path: string, tld: string, folder: string,
  *   absPath: string}>}
  */
-export function collectContentDocs(contentBase: string, { skipDirectories, config, records, problems }?: {}): Array<{
+export function collectContentDocs(contentBase: string, { skipDirectories, config, records, problems }?: {
+    skipDirectories?: readonly string[] | undefined;
+    config?: object | undefined;
+    records?: readonly object[] | undefined;
+    problems?: object[] | undefined;
+}): Array<{
     fm: object;
     path: string;
     tld: string;
@@ -434,6 +503,10 @@ export function collectContentDocs(contentBase: string, { skipDirectories, confi
  *   query's `this` reads. Its entry in `docs` supplies the path as well.
  * @param {number} [ctx.bodyLine] - 1-based file line of the body's first line,
  *   so a failing directive can be reported at its position in the file.
+ * @param {object[]} [ctx.sqlTables] - This note's prepared `sql` results, in
+ *   document order, from
+ *   {@link module:engine/sql-tables.prepareSqlTables}. An `sql` directive with
+ *   no prepared result fails the note: nothing here runs a query.
  * @returns {{markdown: string, lineMap: Array<{line: number,
  *   generated: boolean}>}} The body with every table expanded, and where each
  *   emitted line came from — which is what lets a diagnostic about the
@@ -447,6 +520,7 @@ export function expandNoteTables(body: string, { docs, name, fm, bodyLine, sqlTa
     name: string;
     fm?: object | undefined;
     bodyLine?: number | undefined;
+    sqlTables?: object[] | undefined;
 }): {
     markdown: string;
     lineMap: Array<{

package/types/engine/index.d.mts

@@ -39,6 +39,10 @@ export * as itemDocs from "./item-docs.mjs";
 export * as wikilinks from "./wikilinks.mjs";
 export * as wikilinkSyntax from "./wikilink-syntax.mjs";
 export * as siteIndex from "./site-index.mjs";
+export * as pdfToc from "./pdf-toc.mjs";
+export * as pdfRender from "./pdf-render.mjs";
+export * as pdfFonts from "./pdf-fonts.mjs";
+export * as pdfBuild from "./pdf-build.mjs";
 export * as baseCompiler from "./base-compiler.mjs";
 export * as journals from "./journals.mjs";
 export * as macros from "./macros.mjs";

package/types/engine/journals.d.mts

@@ -147,6 +147,15 @@ export function buildJournalEntry({ id, name, markdown, leadName, folder, flags,
     flags?: object | undefined;
     stats?: object | undefined;
 }): object;
+/**
+ * Journals pack compiler.
+ *
+ * Walks the content tree and compiles every `type: doc` note, and every note of
+ * a doc-carrying type, into one JournalEntry document: the body split into
+ * pages on its top-level H1 headings, each rendered to HTML. A doc-carrying
+ * note's entry is that document's documentation, filed in the document's own
+ * folder.
+ */
 export class Journals extends BasePackCompiler {
     /**
      * How many of the compiled entries were documentation for a document

package/types/engine/note-claims.d.mts

@@ -7,10 +7,7 @@
  * pack from appearing to answer for any note.
  *
  * @param {string} docType - The Foundry document type a pack holds.
- * @param {ClaimSources} [sources] - What to answer from.
- * @param {object} [opts] - Options.
- * @param {readonly object[]} [opts.records] - The corpus, derived once by the
- *   compile and handed in — required, for the reason above. Defaults to the
+ * @param {ClaimSources} [sources] - What to answer from. Defaults to the
  *   configured registries and the systems this toolchain ships.
  * @returns {ReadonlySet<string>} The note types such a pass would claim.
  */
@@ -88,9 +85,6 @@ export function documentClassesFor(type: string, sources?: ClaimSources, { hasPr
  * @param {object} [config] - The resolved build configuration. Defaults to this
  *   repository's.
  * @param {ClaimSources} [sources] - What to answer from.
- * @param {object} [opts] - Options.
- * @param {readonly object[]} [opts.records] - The corpus, derived once by the
- *   compile and handed in — required, for the reason above.
  * @returns {ReadonlySet<string>} The claimed note types.
  */
 export function claimedNoteTypes(config?: object, sources?: ClaimSources): ReadonlySet<string>;
@@ -104,9 +98,6 @@ export function claimedNoteTypes(config?: object, sources?: ClaimSources): Reado
  * declare on top.
  *
  * @param {ClaimSources} [sources] - What to answer from.
- * @param {object} [opts] - Options.
- * @param {readonly object[]} [opts.records] - The corpus, derived once by the
- *   compile and handed in — required, for the reason above.
  * @returns {ReadonlySet<string>} The vocabulary.
  */
 export function noteTypeVocabulary(sources?: ClaimSources): ReadonlySet<string>;
@@ -150,6 +141,22 @@ export function unclaimedNoteFindings(config?: object, sources?: ClaimSources, {
  * @type {ReadonlySet<string>}
  */
 export const NEVER_PACKED_TYPES: ReadonlySet<string>;
+/**
+ * The whole note vocabulary of a package that compiles no Foundry documents.
+ *
+ * Every other type in the vocabulary exists to *become* a document: a `skill` is
+ * an Item, a `being` an Actor, a `place` a JournalEntry, a `folder` the Folder
+ * they are filed under. In a `documentation` package none of them has a
+ * destination, so a note carrying one would be authored, validated, walked and
+ * then published as a page of something that was meant to be a compendium
+ * entry — the plausible-looking result that reads as success.
+ *
+ * `doc` is prose whose single document *is* the prose, and `homepage` is the
+ * authored front page every package publishes. Both are already pages first.
+ *
+ * @type {ReadonlySet<string>}
+ */
+export const DOCUMENTATION_NOTE_TYPES: ReadonlySet<string>;
 /**
  * Content types the specification states and this toolchain does not yet
  * compile.

package/types/engine/note-vocabulary.d.mts

@@ -105,17 +105,19 @@ export function dataFields(type: string, vocabulary?: Readonly<Record<string, Ty
  */
 export function subTypes(type: string, vocabulary?: Readonly<Record<string, TypeVocabulary>>): readonly string[] | null | undefined;
 /**
- * Every note type this toolchain compiles, and the closed vocabulary it
- * declares.
+ * The declared tag that marks a note as **unfinished**.
  *
- * Taken from the content-format specification, one `### type:` section per
- * entry. Where the specification and the shape notes are authored in today
- * disagree, the specification wins on the **name** — that is what a `data:`
- * key will be called — and the disagreement is recorded on the field rather
- * than resolved silently.
+ * Named once and referenced from the declaration below, because a second
+ * spelling is how the two come apart: rename the tag in `DECLARED_TAGS` and a
+ * private copy elsewhere keeps matching the old word, silently.
  *
- * @type {Readonly<Record<string, TypeVocabulary>>}
+ * It is a **presentation** fact and nothing more. A draft note compiles,
+ * validates, publishes and resolves like any other; only a link *into* it
+ * renders marked. What it emphatically is not is the retired `draft:` field,
+ * whose entire effect was to move a note from published to unresolvable — see
+ * {@link draftRetiredMessage}.
  */
+export const DRAFT_TAG: "draft";
 /**
  * The tags that **classify** a note, grouped by what they classify.
  *
@@ -142,20 +144,6 @@ export function subTypes(type: string, vocabulary?: Readonly<Record<string, Type
  * fishing village is a `village` that is `fishing`, and the single-valued field
  * this replaced had to spell it `Fishing Village` as a value of its own.
  */
-/**
- * The declared tag that marks a note as **unfinished**.
- *
- * Named once and referenced from the declaration below, because a second
- * spelling is how the two come apart: rename the tag in `DECLARED_TAGS` and a
- * private copy elsewhere keeps matching the old word, silently.
- *
- * It is a **presentation** fact and nothing more. A draft note compiles,
- * validates, publishes and resolves like any other; only a link *into* it
- * renders marked. What it emphatically is not is the retired `draft:` field,
- * whose entire effect was to move a note from published to unresolvable — see
- * {@link draftRetiredMessage}.
- */
-export const DRAFT_TAG: "draft";
 export const DECLARED_TAGS: Readonly<{
     /** What a place *is*. */
     placeKind: Readonly<{
@@ -183,180 +171,19 @@ export const DECLARED_TAGS: Readonly<{
         tags: readonly string[];
     }>;
 }>;
-export const NOTE_VOCABULARY: Readonly<{
-    being: Readonly<{
-        subTypes: null;
-        data: readonly DataFieldSpec[];
-    }>;
-    vehicle: Readonly<{
-        subTypes: null;
-        data: readonly DataFieldSpec[];
-    }>;
-    affiliation: Readonly<{
-        subTypes: readonly string[];
-        data: readonly DataFieldSpec[];
-    }>;
-    affliction: Readonly<{
-        subTypes: readonly string[];
-        data: readonly DataFieldSpec[];
-    }>;
-    armorgear: Readonly<{
-        data: readonly DataFieldSpec[];
-    }>;
-    armorlocation: Readonly<{
-        subTypes: null;
-        data: readonly DataFieldSpec[];
-    }>;
-    attribute: Readonly<{
-        data: readonly DataFieldSpec[];
-    }>;
-    concoctiongear: Readonly<{
-        subTypes: readonly string[];
-        data: readonly (DataFieldSpec | Readonly<{
-            describe: "How many of the thing there are; one when unstated.";
-            shape: "number";
-            kind: "number";
-            name: "quantity";
-        }>)[];
-    }>;
-    containergear: Readonly<{
-        data: readonly DataFieldSpec[];
-    }>;
-    miscgear: Readonly<{
-        data: readonly (DataFieldSpec | Readonly<{
-            describe: "How many of the thing there are; one when unstated.";
-            shape: "number";
-            kind: "number";
-            name: "quantity";
-        }>)[];
-    }>;
-    mystery: Readonly<{
-        subTypes: readonly string[];
-        data: readonly DataFieldSpec[];
-    }>;
-    mysticalability: Readonly<{
-        subTypes: readonly string[];
-        data: readonly DataFieldSpec[];
-    }>;
-    projectilegear: Readonly<{
-        subTypes: readonly string[];
-        data: readonly (DataFieldSpec | Readonly<{
-            describe: "How many of the thing there are; one when unstated.";
-            shape: "number";
-            kind: "number";
-            name: "quantity";
-        }>)[];
-    }>;
-    skill: Readonly<{
-        subTypes: readonly string[];
-        data: readonly DataFieldSpec[];
-    }>;
-    trauma: Readonly<{
-        subTypes: readonly string[];
-        data: readonly DataFieldSpec[];
-    }>;
-    weapongear: Readonly<{
-        data: readonly DataFieldSpec[];
-    }>;
-    doc: Readonly<{
-        subTypes: readonly string[];
-        data: readonly never[];
-    }>;
-    macro: Readonly<{
-        data: readonly never[];
-    }>;
-    folder: Readonly<{
-        data: readonly ({
-            describe: string;
-            shape: "a wikilink, or a map of wikilinks keyed by pack";
-            kind: "scalar-or-map";
-            entryShape: "a wikilink";
-            keys: "pack";
-            name: string;
-        } | {
-            describe: string;
-            shape: "string";
-            kind: "string";
-            name: string;
-        })[];
-    }>;
-    bundle: Readonly<{
-        data: readonly {
-            describe: string;
-            shape: "list of wikilinks";
-            kind: "list";
-            name: string;
-        }[];
-    }>;
-    lore: Readonly<{
-        subTypes: readonly string[];
-        data: readonly never[];
-    }>;
-    place: Readonly<{
-        subTypes: readonly string[];
-        data: readonly ({
-            describe: string;
-            shape: "string";
-            kind: "string";
-            name: string;
-        } | {
-            describe: string;
-            shape: "list of wikilinks";
-            kind: "list";
-            name: string;
-        } | {
-            describe: string;
-            shape: "number";
-            kind: "number";
-            name: string;
-        })[];
-    }>;
-    scenario: Readonly<{
-        subTypes: readonly string[];
-        data: readonly ({
-            describe: string;
-            shape: "list of wikilinks";
-            kind: "list";
-            name: string;
-        } | {
-            describe: string;
-            shape: "string";
-            kind: "string";
-            name: string;
-        } | {
-            describe: string;
-            shape: "list";
-            kind: "list";
-            name: string;
-        })[];
-    }>;
-    homepage: Readonly<{
-        data: readonly never[];
-    }>;
-    map: Readonly<{
-        subTypes: readonly string[];
-        data: readonly ({
-            describe: string;
-            shape: "string";
-            kind: "string";
-            name: string;
-        } | {
-            describe: string;
-            shape: "list";
-            kind: "list";
-            name: string;
-        } | {
-            describe: string;
-            shape: "number";
-            kind: "number";
-            name: string;
-        } | {
-            describe: string;
-            shape: "as authored";
-            name: string;
-        })[];
-    }>;
-}>;
+/**
+ * Every note type this toolchain compiles, and the closed vocabulary it
+ * declares.
+ *
+ * Taken from the content-format specification, one `### type:` section per
+ * entry. Where the specification and the shape notes are authored in today
+ * disagree, the specification wins on the **name** — that is what a `data:`
+ * key will be called — and the disagreement is recorded on the field rather
+ * than resolved silently.
+ *
+ * @type {Readonly<Record<string, TypeVocabulary>>}
+ */
+export const NOTE_VOCABULARY: Readonly<Record<string, TypeVocabulary>>;
 /**
  * One `data:` key a note type may carry.
  *