@heroiclands/package-build 20.7.0 → 21.1.0

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

@@ -61,6 +61,16 @@ export const CONTENT_FORMAT_PATH: string;
  * @property {number} line - 1-based line of the row.
  * @property {number} column - 1-based column of the cell's first character.
  */
+/**
+ * One closed vocabulary the specification states as a table.
+ *
+ * @typedef {object} VocabularySpec
+ * @property {string} name - The key the header names, without its backticks.
+ * @property {number} line - 1-based line of the header row.
+ * @property {string[]} values - The values, in document order. A row whose
+ *   first cell is not a single inline-code span states no value and is skipped,
+ *   which is how a table says "no marker" in a row of its own.
+ */
 /**
  * The specification, as data.
  *
@@ -68,6 +78,8 @@ export const CONTENT_FORMAT_PATH: string;
  * @property {string} file - Where it was read from, for diagnostics.
  * @property {Map<string, TypeSpec>} types - Note type → what its section declares.
  * @property {MappingClaim[]} claims - Every `system.*` target, in document order.
+ * @property {Map<string, VocabularySpec>} vocabularies - Key → the values it
+ *   admits, for every closed vocabulary the document states as a table.
  */
 /**
  * What a shared row's `noteType` reads, in place of a type name.
@@ -147,6 +159,25 @@ export type MappingClaim = {
      */
     column: number;
 };
+/**
+ * One closed vocabulary the specification states as a table.
+ */
+export type VocabularySpec = {
+    /**
+     * - The key the header names, without its backticks.
+     */
+    name: string;
+    /**
+     * - 1-based line of the header row.
+     */
+    line: number;
+    /**
+     * - The values, in document order. A row whose
+     * first cell is not a single inline-code span states no value and is skipped,
+     * which is how a table says "no marker" in a row of its own.
+     */
+    values: string[];
+};
 /**
  * The specification, as data.
  */
@@ -163,4 +194,9 @@ export type ContentFormat = {
      * - Every `system.*` target, in document order.
      */
     claims: MappingClaim[];
+    /**
+     * - Key → the values it
+     * admits, for every closed vocabulary the document states as a table.
+     */
+    vocabularies: Map<string, VocabularySpec>;
 };

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

@@ -0,0 +1,281 @@
+/**
+ * What is wrong with an image's address, or `""` when nothing is.
+ *
+ * The address is the one piece of author-supplied text that has to reach an
+ * `src` attribute, so it is the one piece that has to be held to a shape. A
+ * scheme this does not name — `javascript:`, `data:`, `vbscript:` — is refused
+ * rather than escaped, because escaping makes it inert markup and this makes it
+ * a finding the author can act on.
+ *
+ * @param {string} src - The address, exactly as authored.
+ * @returns {string} The problem, as a finding's sentence, or `""`.
+ */
+export function imageSourceProblem(src: string): string;
+/**
+ * Read the directive on an image.
+ *
+ * Values are validated here rather than at the point of rendering, so a mistake
+ * is one finding with a position rather than three surfaces quietly drawing
+ * something else. A directive that holds a problem yields **no** class and no
+ * float: a half-honoured directive is the silent failure in a smaller costume.
+ *
+ * @param {string} [raw] - The text between the braces, braces included or not.
+ * @returns {{classes: string[], float: string, problems: string[]}} What was
+ *   written, and what cannot be honoured.
+ */
+export function parseImageDirective(raw?: string): {
+    classes: string[];
+    float: string;
+    problems: string[];
+};
+/**
+ * The classes a figure carries, from a parsed directive.
+ *
+ * @param {{classes?: string[], float?: string}} [directive] - As parsed.
+ * @returns {string} A space-separated class list, always naming
+ *   {@link IMAGE_FIGURE_CLASS} first.
+ */
+export function figureClasses({ classes, float }?: {
+    classes?: string[];
+    float?: string;
+}): string;
+/**
+ * Text going inside an HTML attribute or between tags.
+ *
+ * @param {string} text - The raw value.
+ * @returns {string} The same value, safe in markup.
+ */
+export function escapeHtml(text: string): string;
+/**
+ * One image as the `<figure>` both HTML surfaces render.
+ *
+ * The website and a Foundry journal page get the identical string, from one
+ * function, so the two cannot drift into styling the same directive through
+ * different class names.
+ *
+ * @param {object} image - The image.
+ * @param {string} image.src - The address, resolved for the surface.
+ * @param {string} [image.alt] - The alt text, which is also the caption.
+ * @param {string[]} [image.classes] - Width classes, from the directive.
+ * @param {string} [image.float] - The float position, from the directive.
+ * @returns {string} The figure, as one HTML block.
+ */
+export function imageFigureHtml({ src, alt, classes, float }: {
+    src: string;
+    alt?: string | undefined;
+    classes?: string[] | undefined;
+    float?: string | undefined;
+}): string;
+/**
+ * Whether a match sits alone in its own paragraph.
+ *
+ * "Alone" is the whole of a block: nothing else on its line, and a blank line
+ * or the end of the body either side of it. A leading `>` or list marker
+ * disqualifies it for the same reason a word does — the paragraph it belongs to
+ * holds something the figure would have to be lifted out of.
+ *
+ * @param {string} text - The body the match indexes into.
+ * @param {number} start - Where the match begins.
+ * @param {number} end - Where it ends.
+ * @returns {boolean} Whether the match is a block of its own.
+ */
+export function standsAlone(text: string, start: number, end: number): boolean;
+/**
+ * Every image in one body, with its directive and its position.
+ *
+ * Code is skipped, because an image shown as an example is prose *about* an
+ * image and resolving it would make this very module impossible to document.
+ *
+ * @param {string} body - The note's markdown, without its frontmatter.
+ * @returns {Array<{alt: string, src: string, title: string, directive: string,
+ *   index: number, length: number, block: boolean}>} One entry per image, in
+ *   source order.
+ */
+export function imagesIn(body: string): Array<{
+    alt: string;
+    src: string;
+    title: string;
+    directive: string;
+    index: number;
+    length: number;
+    block: boolean;
+}>;
+/**
+ * Every image address one body names, in order of appearance.
+ *
+ * What a build reads to know which files it has to stage before a compiler can
+ * see them.
+ *
+ * @param {string} body - The note's markdown.
+ * @returns {string[]} The addresses, with repeats.
+ */
+export function imageSourcesIn(body: string): string[];
+/**
+ * Every defect in one note's images.
+ *
+ * **Errors, not warnings.** A refusal that does not fail the build is not a
+ * refusal: `reportFindings` fails on an error and not on a warning, so a
+ * directive reported as advisory publishes anyway, looking exactly like one
+ * that worked.
+ *
+ * @param {string} body - The note's markdown, without its frontmatter.
+ * @param {string} file - The note's path, for the finding.
+ * @param {object} [opts]
+ * @param {number} [opts.bodyLine=1] - The 1-based file line the body starts on.
+ * @param {number} [opts.bodyColumn=1] - The 1-based file column it starts at.
+ * @returns {Array<{file: string, line: number, column: number|undefined,
+ *   severity: "error", message: string}>} One finding per defect, in source
+ *   order.
+ */
+export function checkImages(body: string, file: string, { bodyLine, bodyColumn }?: {
+    bodyLine?: number | undefined;
+    bodyColumn?: number | undefined;
+}): Array<{
+    file: string;
+    line: number;
+    column: number | undefined;
+    severity: "error";
+    message: string;
+}>;
+/**
+ * Walk a content tree and report every image it cannot render as authored.
+ *
+ * Its own walk, like the icon and HTML checks beside it, so all three stay
+ * leaves with nothing imported between them.
+ *
+ * @param {string} contentBase - Root of the content tree.
+ * @param {object} [opts]
+ * @param {readonly string[]} [opts.skipDirectories] - Directory names to ignore
+ *   in addition to the dot-directories always skipped.
+ * @returns {{findings: Array<{file: string, line: number, column: number|undefined,
+ *   severity: "error", message: string}>, files: number}} The findings, and how
+ *   many files were read.
+ */
+export function lintContentImages(contentBase: string, { skipDirectories }?: {
+    skipDirectories?: readonly string[] | undefined;
+}): {
+    findings: Array<{
+        file: string;
+        line: number;
+        column: number | undefined;
+        severity: "error";
+        message: string;
+    }>;
+    files: number;
+};
+/**
+ * Rewrite every block image in a body into the figure the website publishes.
+ *
+ * **Hugo is handed markdown, not a rendered page.** The site emitter writes a
+ * note's body through verbatim, so a `{…}` directive left in it reaches the
+ * page as its own literal braces: Goldmark's block-attribute parser is off, and
+ * turning it on would accept `style` and `id` alongside the two vocabularies,
+ * which is the injection surface this rule exists to avoid. So the directive is
+ * resolved here, into markup Goldmark passes through.
+ *
+ * An image whose directive does not parse is left exactly as written, so the
+ * page shows the braces and the lint says why — the same visible degradation an
+ * unknown icon name gets.
+ *
+ * Call this **inside** {@link module:engine/code-fences.protectCode}: an image
+ * in a fence is an example of one.
+ *
+ * @param {string} body - The note's markdown.
+ * @param {(src: string) => string} [resolveSrc] - Translates an authored
+ *   pathname into the address this surface serves. The default is the identity,
+ *   for a caller rendering the format rather than publishing it.
+ * @returns {string} The same body, with each block image as a `<figure>`.
+ */
+export function renderImageFigures(body: string, resolveSrc?: (src: string) => string): string;
+/**
+ * A markdown-it plugin that reads an image's directive and renders its figure.
+ *
+ * **A core rule, not an inline one.** markdown-it's own `image` rule consumes
+ * `![alt](src)` and leaves `{float: top-left}` behind as text, and a rule
+ * running before it would have to re-implement link parsing to find the brace.
+ * Reading the token stream afterwards costs one pass and re-implements nothing.
+ *
+ * Two things happen to a paragraph holding one image and nothing else: the
+ * directive is lifted off the text token that follows it, and the paragraph's
+ * own tokens are hidden, so the figure is a block rather than a `<figure>`
+ * nested inside a `<p>`. The Typst renderer reads the same `meta`, which is
+ * what keeps the book and the two HTML surfaces honouring one statement.
+ *
+ * An image whose directive does not parse keeps its braces and renders as its
+ * own literal text, which is how the author sees the mistake without reading a
+ * log.
+ *
+ * @param {(src: string) => string} [resolveSrc] - Translates an authored
+ *   address into the one this surface serves. Foundry is handed the path inside
+ *   the install; a renderer that resolves the address itself — the book stages
+ *   its own copy — passes nothing and gets the address as authored.
+ * @returns {(md: object) => void} A markdown-it plugin.
+ */
+export function imagePlugin(resolveSrc?: (src: string) => string): (md: object) => void;
+/**
+ * The width classes an image may carry, and what each means to a renderer.
+ *
+ * **The ordinary width is absent from this table on purpose.** It is what an
+ * image with no marker gets, and giving it a name would invite a note to write
+ * it — two spellings of one thing, one of which every existing note omits.
+ *
+ * `scope` is Typst's: a float placed with `scope: "parent"` spans every column
+ * of the page, and one placed with `scope: "column"` occupies the column it
+ * sits in. The book is set in one column, where the two measure the same, and
+ * stays correct when it is set in two.
+ *
+ * `class` is the class the HTML surfaces put on the `<figure>`. Named rather
+ * than reused from the authored spelling so a bare `full-width` in some other
+ * stylesheet cannot claim it.
+ *
+ * @type {Readonly<Record<string, {class: string, scope: string, describe: string}>>}
+ */
+export const IMAGE_CLASSES: Readonly<Record<string, {
+    class: string;
+    scope: string;
+    describe: string;
+}>>;
+/**
+ * The `float:` positions an image may take, and where each puts it.
+ *
+ * `align` is the Typst alignment the float is placed at. **Print cannot wrap
+ * text around an arbitrary shape**: a Typst float occupies the column measure,
+ * so the horizontal half of a position has no effect on the page and only the
+ * vertical half — top of the column, or bottom of it — does. The website and a
+ * Foundry journal get true CSS wrap from the same directive. Same statement,
+ * different fidelity, which is stated in the specification rather than left for
+ * a reader to discover by comparing two outputs.
+ *
+ * @type {Readonly<Record<string, {class: string, align: string, describe: string}>>}
+ */
+export const IMAGE_FLOATS: Readonly<Record<string, {
+    class: string;
+    align: string;
+    describe: string;
+}>>;
+/**
+ * The class every figure carries, whatever its width or position.
+ *
+ * One hook a stylesheet can reach every authored image through, so the two
+ * vocabularies stay about what differs between images rather than what they
+ * share.
+ *
+ * @type {string}
+ */
+export const IMAGE_FIGURE_CLASS: string;
+/**
+ * A markdown image, with the directive it may carry.
+ *
+ * The alt text admits no `]`, and the address no whitespace or `)`, which is
+ * the shape markdown-it itself accepts for the common case and the only shape
+ * this format asks anyone to write. A title — `![alt](src "title")` — is
+ * matched so it can be reported rather than silently dropped.
+ *
+ * The directive is `{…}` immediately after the closing parenthesis, holding no
+ * newline: a brace that opens and never closes on its line is prose, not a
+ * directive, and reading on to the next paragraph to find its `}` would make
+ * one stray character swallow a page.
+ *
+ * @type {RegExp}
+ */
+export const IMAGE_PATTERN: RegExp;

package/types/engine/dependency-bump.d.mts

@@ -0,0 +1,89 @@
+/**
+ * The indentation a JSON file already uses, as the literal string to indent
+ * with.
+ *
+ * Read from the first indented line rather than assumed, because the two-space
+ * default is right for some consumers and wrong for most of them. A file whose
+ * second line is not indented — a one-line document — reports the npm default,
+ * which is what rewriting it would produce anyway.
+ *
+ * @param {string} text - The file's contents.
+ * @returns {string} The indent string, e.g. `"    "` or `"  "`.
+ */
+export function detectJsonIndent(text: string): string;
+/**
+ * Rewrite a JSON file with a given indent, leaving its content untouched.
+ *
+ * @param {string} file - Absolute path to the JSON file.
+ * @param {string} indent - The indent string to write with.
+ * @returns {boolean} Whether the file's bytes changed.
+ */
+export function reindentJsonFile(file: string, indent: string): boolean;
+/**
+ * Every package name a manifest declares a range for, in declaration order.
+ *
+ * @param {object} manifest - The parsed `package.json`.
+ * @returns {string[]} The declared package names.
+ */
+export function declaredDependencies(manifest: object): string[];
+/**
+ * The packages a bump targets when the caller names none.
+ *
+ * The first-party scope, because that is the bump a consumer runs by hand: a
+ * third-party one arrives from Dependabot on its own schedule, while a
+ * first-party release is taken the moment it publishes, usually to unblock the
+ * very change that prompted it.
+ *
+ * @param {object} manifest - The parsed `package.json`.
+ * @param {string} [scope] - The scope prefix to match.
+ * @returns {string[]} The package names to bump.
+ */
+export function firstPartyDependencies(manifest: object, scope?: string): string[];
+/**
+ * The version the lockfile currently resolves a package to.
+ *
+ * Read from the lockfile rather than the manifest, because the manifest states
+ * a *range* and the lockfile states what `npm ci` will actually install — which
+ * is the thing a bump moves. A caret range that already admits the new version
+ * needs no manifest change at all, and reporting the range would then show a
+ * bump as changing nothing.
+ *
+ * @param {object} lock - The parsed `package-lock.json`.
+ * @param {string} name - The package name.
+ * @returns {string|undefined} The locked version, if the lockfile holds one.
+ */
+export function lockedVersion(lock: object, name: string): string | undefined;
+/**
+ * Take the newest published version of one or more dependencies.
+ *
+ * npm performs the resolution — so a bump that changes the dependency set is
+ * as correct as one that moves three lines — and both JSON files are restored
+ * to the indentation they already used.
+ *
+ * @param {object} options - Options.
+ * @param {string} options.rootDir - The repository root holding `package.json`.
+ * @param {string[]} [options.packages] - Packages to bump. Defaults to every
+ *   first-party dependency the manifest declares.
+ * @param {string} [options.tag] - The dist-tag to take. Defaults to `latest`.
+ * @param {boolean} [options.check] - Report what would change and write nothing.
+ * @param {(command: string, args: string[], cwd: string) => void} [options.run] -
+ *   How to invoke npm. Injected by the tests, which have no registry.
+ * @returns {{changes: Array<{name: string, from: string|undefined, to: string|undefined}>,
+ *   unchanged: string[], reindented: string[], checked: boolean}} What moved.
+ */
+export function bumpDependencies({ rootDir, packages, tag, check, run }: {
+    rootDir: string;
+    packages?: string[] | undefined;
+    tag?: string | undefined;
+    check?: boolean | undefined;
+    run?: ((command: string, args: string[], cwd: string) => void) | undefined;
+}): {
+    changes: Array<{
+        name: string;
+        from: string | undefined;
+        to: string | undefined;
+    }>;
+    unchanged: string[];
+    reindented: string[];
+    checked: boolean;
+};

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

@@ -239,6 +239,29 @@ export const UNIVERSAL_KEYS: ReadonlySet<string>;
  * @type {Readonly<Record<string, SystemBlockSpec>>}
  */
 export const DEFAULT_SYSTEM_BLOCKS: Readonly<Record<string, SystemBlockSpec>>;
+/**
+ * The frontmatter fields that name artwork, and so resolve through
+ * {@link module:engine/helpers.resolveImg}.
+ *
+ * Both, always: a being carries `img` and `portrait` independently — the token
+ * art and the sheet portrait — and a rule about how the translator reads an
+ * empty value belongs to the translator, not to whichever key happens to be
+ * more common. Eleven `sohl-kethira-basic` beings write `portrait: ""` and no
+ * note in any tree writes `img: ""` on a being; a check keyed on `img` alone
+ * would have called that tree clean.
+ *
+ * **Each carries where it is authored**, because the two no longer agree. The
+ * specification puts an actor's portrait under `data:` and leaves its token art
+ * at the note's top level, so `portrait` has a third position to read and `img`
+ * does not — and a check that read only the two they share would pass a
+ * `data.portrait: ""` it could not see.
+ *
+ * @type {readonly {key: string, inData: boolean}[]}
+ */
+export const ART_FIELDS: readonly {
+    key: string;
+    inData: boolean;
+}[];
 /**
  * What one system block accepts beyond the keys every block carries.
  */

package/types/engine/helpers.d.mts

@@ -178,90 +178,48 @@ export function systemTemplatePriority(fm: object, label: string): number | null
  */
 export function makeFilename(name: any, id: any): string;
 /**
- * Translate a content-relative image path into its Foundry-relative form.
- *
- * Content frontmatter (`img` / `portrait`) authors a single path that has to
- * work for Foundry, the knowledgebase, and the website. **Its first segment
- * says which package owns the file**, and there are exactly three
- * answers:
- *
- * | Authored path starts with | Owner                 | Emitted              |
- * | ------------------------- | --------------------- | -------------------- |
- * | `systems/`                | a separate **system** | unchanged            |
- * | `modules/`                | a separate **module** | unchanged            |
- * | anything else             | **this package**      | `<assetRoot>/<path>` |
- *
- * So `icons/relic.svg` compiles to `systems/sohl/assets/icons/relic.svg` here
- * and to `modules/sohl-thalorna/assets/icons/relic.svg` in a module — the asset
- * root is derived from the configuration, and is the one place `systems/sohl`
- * is ever spelled. An authored
- * `systems/sohl/assets/icons/noun/shield.svg` is left exactly as written,
- * whichever package is compiling it.
- *
- * **This is a rule about ownership, not an allowlist of directories.** It used
- * to prefix `icons/…` and `images/…` and pass everything else through — the
- * same answer for every path any tree authors today, and the wrong one for the
- * next directory a package ships. `sohl-kethira-basic` keeps art under
- * `assets/artwork/`, so an authored `artwork/deity.webp` would have shipped
- * unprefixed: a 404 in Foundry, reported by nothing. That a package owns its
- * own tree is the fact; the directory names inside it are that package's
- * business.
- *
- * **Off-install addresses pass through too**, which is the same rule rather
- * than a fourth: a URL, a `data:` URI, or a `/`-rooted path names something no
- * package owns. See {@link addressesAnotherPackage}.
- *
- * **`banner:` does not follow this rule, deliberately.** It is not an
- * asset path inside a Foundry install at all: it reaches no compiled document,
- * and its only consumer is the Hugo theme, which prefixes a relative value with
- * `images/` and joins it onto `params.cdnBaseURL`. The two fields look alike
- * and address different places — `img:` a file Foundry serves, `banner:` a file
- * the CDN serves — so they are documented apart rather than reconciled into one
- * rule that would be true of neither.
- *
- * **Two empties, and they mean opposite things.** `null` — or an absent
- * key, which reaches here as `undefined` — means _unset_: the note names no art
- * and the caller's default applies. `""` means _blank on purpose_: the note
- * names no art **and wants none**, so no default may replace it. Both come back
+ * Translate an authored pathname into the address a Foundry install serves.
+ *
+ * The Foundry half of {@link module:engine/pathnames.resolvePathname}, which
+ * states the rule and derives the other three surfaces from the same
+ * statement. Kept as its own function because the compilers want one address
+ * and nothing else, and because the default a caller applies to an unset one is
+ * domain-specific — actors default differently from items, and gear differently
+ * again — so each compiler owns its default and applies it with **nullish**
+ * coalescing: `resolveImg(fm.img) ?? <default>`. Not `||`, which would collapse
+ * a deliberate blank back into the default.
+ *
+ * **Two empties, and they mean opposite things.** `null` — or an absent key,
+ * which reaches here as `undefined` — means _unset_: the note names no art and
+ * the caller's default applies. `""` means _blank on purpose_: the note names
+ * no art **and wants none**, so no default may replace it. Both come back
  * distinguishable, `null` and `""` respectively, and neither is invented from
  * the other.
  *
- * This used to open `if (!raw) return ""`, which made the two one case: every
- * caller then applied its default with `||`, so a deliberate blank was
- * unspellable and an unset key and an empty string compiled identically. That
- * is the convention the project already rejects for an optional "not specified"
- * DataModel string, where `nullable, initial: null` keeps "unset" a single
- * honest value rather than two.
- *
  * **`title` does not follow this rule**, and must not be made to. On a
  * `type: affiliation` note `title` is *also* a declared item field whose default
  * is `""` (`sohl/item-fields.mjs`), resolved from the very same shared top-level
  * key the site emitter reads as the page title — so `title: null` stringifies
  * into the compiled document as the literal `"null"`. One key, two destinations
- * that disagree about what empty means; see.
- *
- * This is translation only: the default for an unset path is domain-specific
- * (actors default differently from items, and gear differently again), so each
- * compiler owns its own default and applies it to the result with **nullish**
- * coalescing — `resolveImg(fm.img) ?? <default>`. Not `||`: that would collapse
- * a deliberate blank back into the default and undo the distinction. For items
- * that default is the art paired with the type's builder, reached through
- * `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.
+ * that disagree about what empty means.
+ *
+ * **`banner:` does not follow it either, deliberately.** It is not a file
+ * inside a Foundry install: it reaches no compiled document and no book, its
+ * only consumer is the Hugo theme, and the theme resolves it against the site's
+ * own asset root. See `docs/content-format.md`.
+ *
+ * For items, the default is the art paired with the type's builder, reached
+ * through `itemArt()`, which runs the pathname back through this function so a
+ * registry entry and a note's `img:` are spelled the same way.
+ *
+ * @param {string | null | undefined} raw - The pathname from frontmatter.
  * @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.
+ * @throws {Error} When no Foundry address can be derived — a `documentation`
+ *   package, which Foundry installs nothing of, or a pathname naming a package
+ *   this build declares no relationship with.
  */
 export function resolveImg(raw: string | null | undefined, config?: {
     assetRoot: string | null;

package/types/engine/index.d.mts

@@ -19,6 +19,9 @@ export * as systems from "./systems.mjs";
 export * as contentSlug from "./content-slug.mjs";
 export * as contentAddress from "./content-address.mjs";
 export * as subtypeRegistry from "./subtype-registry.mjs";
+export * as infobox from "./infobox.mjs";
+export * as infoboxRegistry from "./infobox-registry.mjs";
+export * as infoboxRender from "./infobox-render.mjs";
 export * as noteIds from "./note-ids.mjs";
 export * as noteRenames from "./note-renames.mjs";
 export * as metadataIndex from "./metadata-index.mjs";
@@ -29,6 +32,8 @@ export * as contentLint from "./content-lint.mjs";
 export * as contentCharset from "./content-charset.mjs";
 export * as contentIcons from "./content-icons.mjs";
 export * as contentHtml from "./content-html.mjs";
+export * as contentImages from "./content-images.mjs";
+export * as pathnames from "./pathnames.mjs";
 export * as contentLinks from "./content-links.mjs";
 export * as webWikilinks from "./web-wikilinks.mjs";
 export * as contentTables from "./content-tables.mjs";

package/types/engine/infobox-registry.d.mts

@@ -0,0 +1,36 @@
+/**
+ * One system's declaration, by its id.
+ *
+ * @param {string|undefined} system - The system id.
+ * @returns {object|undefined} Its declaration, or `undefined` where this
+ *   toolchain ships none for it.
+ */
+export function infoboxFor(system: string | undefined): object | undefined;
+/**
+ * Every box one note carries, wired to the registries this toolchain ships.
+ *
+ * The one call each medium makes. What varies between them is the resolver —
+ * a website has URLs, a compendium has UUIDs, the book has its own labels —
+ * and nothing else, which is what keeps the three showing the same panel.
+ *
+ * @param {object} fm - The note's frontmatter.
+ * @param {object} [options] - Options.
+ * @param {(ref: unknown, hint?: object) => object|undefined} [options.resolve] -
+ *   Resolves a reference to `{name, url?, uuid?, address?, subType?}`.
+ * @returns {object[]} The boxes, in the order every medium renders them.
+ * @throws {Error} When the built set disagrees with what the note's type maps
+ *   to — see {@link module:engine/infobox.assertInfoboxSet}.
+ */
+export function noteInfoboxes(fm: object, { resolve }?: {
+    resolve?: ((ref: unknown, hint?: object) => object | undefined) | undefined;
+}): object[];
+/**
+ * Every system's infobox declaration, in the order a page shows them.
+ *
+ * The order matches {@link module:engine/subtype-registry.KNOWN_DOCUMENT_SUBTYPE_MAPS},
+ * because the box set is derived from those maps and a reader meeting two
+ * pages of one type should meet the boxes in one order.
+ *
+ * @type {readonly object[]}
+ */
+export const KNOWN_INFOBOXES: readonly object[];