@heroiclands/package-build 19.0.0 → 20.2.0

package/types/engine/actor-compiler.d.mts

@@ -41,6 +41,54 @@ export function deepMerge(base: any, overlay: any): any;
  * @returns {string} The address, `subType:shortcode`.
  */
 export function itemAddress(subType: string, shortcode: string): string;
+/**
+ * The key one predefined item is held under **for the package that publishes
+ * it** — the address a `model:` naming that package resolves through (#334).
+ *
+ * The unqualified {@link itemAddress} stays beside it, and the two answer
+ * different questions. A `model` that names no package means *this* one and
+ * takes the unqualified key, where a local definition still shadows a
+ * dependency's. A `model` that names a package takes this one, which nothing
+ * can shadow: that is the whole point of writing the package down.
+ *
+ * Not the canonical wikilink address, because this map is keyed in the
+ * **document's** vocabulary — a Foundry Item subtype — while a canonical address
+ * carries the *note* type. The two differ wherever a system maps a type to a
+ * differently-named subtype, and translating here would put the translation in
+ * two places.
+ *
+ * @param {string} pkg - The content package that publishes the item.
+ * @param {string} subType - The Foundry Item subtype.
+ * @param {string} shortcode - The item's `system.shortcode`.
+ * @returns {string} The address, `package:subType:shortcode`.
+ */
+export function packagedItemAddress(pkg: string, subType: string, shortcode: string): string;
+/**
+ * The key one predefined item is held under **in the catalogue**, with the
+ * shortcode folded to lower case.
+ *
+ * A shortcode is case-sensitive and routinely mixed — `Clb`, `LtShoe`,
+ * `HsTunic` — while an **address** is not: `readQualifier` normalises what it
+ * reads, and every canonical address is lowercase. So the moment a `model:` is
+ * read as an address (#334), `weapongear-clb` has to find the document whose
+ * `system.shortcode` is `Clb`, and an exact match cannot (#346).
+ *
+ * Folding is safe because the fold is already the address: no two items in any
+ * published tree differ only by the case of their shortcode, and #340 will make
+ * that impossible rather than merely true.
+ *
+ * **This is not {@link itemAddress}, and must not become it.** That one seeds
+ * {@link embeddedItemId}, so folding there would change the `_id` of every
+ * embedded item whose identity carries a capital — a silent re-identification of
+ * documents nothing about which had changed. The catalogue is a lookup table;
+ * an id is a promise.
+ *
+ * @param {string} subType - The Foundry Item subtype.
+ * @param {string} shortcode - The item's `system.shortcode`, in any case.
+ * @param {string} [pkg] - The publishing package, for the qualified form.
+ * @returns {string} The catalogue key.
+ */
+export function catalogueKey(subType: string, shortcode: string, pkg?: string): string;
 /**
  * What identifies one embedded item on its actor.
  *
@@ -136,6 +184,13 @@ export class SystemActorCompiler extends BasePackCompiler {
     /** @type {readonly string[]} */
     itemsSourceDirs: readonly string[];
     foreignSourceDirs: any;
+    /**
+     * Every package a `model:` may name besides this one — the dependencies
+     * whose item catalogues were supplied (#334).
+     *
+     * @returns {Set<string>} The dependency package ids.
+     */
+    get foreignPackages(): Set<string>;
     /**
      * This pass's system map, or a message naming the class that forgot it.
      *
@@ -195,9 +250,34 @@ export class SystemActorCompiler extends BasePackCompiler {
      * @returns {object|null} The embedded item, or null when it resolved to
      *   nothing — always with a finding emitted.
      */
-    resolveEmbedded(itemsMap: Map<string, object>, actorId: string, type: string, shortcode: string | null, overlay?: object, indexKey: string, ctx: string, { fmKey }?: {
-        fmKey?: string | undefined;
-    }): object | null;
+    /**
+     * Read an entry's `model:` — the address of the item it is a copy of.
+     *
+     * The address grammar is the wikilink one (#336), so a `model` is written at
+     * whatever length says what it means: `skill-wpnc` within this package,
+     * `sohl-sohl-skill-wpnc` to reach another. The system segment defaults from
+     * the block the entry sits in — `<system>.items` — which is what makes the
+     * short form name an *Item* here while the same string in body prose names
+     * a page.
+     *
+     * It replaced a top-level `shortcode:` that meant something different from
+     * the `system.shortcode` beside it and could not say which package a
+     * template came from (#334).
+     *
+     * @param {unknown} model - The authored value.
+     * @param {number} index - The entry's position, for the message.
+     * @param {string} ctx - Diagnostic context (the actor's label).
+     * @returns {{type: string, shortcode: string, package: string|null}|null}
+     *   The parsed address, or `null` after reporting why it is not one.
+     */
+    readModel(model: unknown, index: number, ctx: string): {
+        type: string;
+        shortcode: string;
+        package: string | null;
+    } | null;
+    resolveEmbedded(itemsMap: any, actorId: any, type: any, shortcode: any, overlay: any, indexKey: any, ctx: any, { fmKey, modelPackage }?: {
+        modelPackage?: null | undefined;
+    }): any;
     #private;
 }
 import { BasePackCompiler } from "./base-compiler.mjs";

package/types/engine/address-charset.d.mts

@@ -37,11 +37,29 @@ export function isAddressSegment(value: unknown): boolean;
  * @module
  */
 /**
- * The shape every address segment must match: ASCII letters and digits only.
+ * The shape every address segment must match: **lowercase** ASCII letters and
+ * digits only.
  *
- * Case is deliberately **not** constrained. Hundreds of authored shortcodes are
- * mixed-case and collide with nothing, and case has no bearing on the
- * separator, which is the whole of what this pattern is protecting.
+ * Case *was* deliberately unconstrained, on the reasoning that case has no
+ * bearing on the separator — which is true, and beside the point (#340).
+ *
+ * **Two names that differ only in case are two names nobody can tell apart.** A
+ * shortcode is how a person names a thing when writing a reference —
+ * `model: weapongear-dgr`, `[[skill-melee|…]]` — and `Dgr` beside `dgr` is a
+ * distinction you cannot say out loud and can only see by looking twice.
+ *
+ * The toolchain had already half-decided it: {@link canonicalKey} lowercases the
+ * address it builds, so a note declaring `Clb` published
+ * `sohl-sohl-weapongear-clb` and its `_id` derived from that. The authored name
+ * and its address disagreed, and everything downstream keys on the address —
+ * which left two notes differing only in case sharing one address, one `_id` and
+ * one URL, with nothing to report it. It also forced two exceptions elsewhere:
+ * #336 had to exempt the shortcode from the lowercase rule it pinned on every
+ * other segment, and #346 had to fold the shortcode's case in the item catalogue
+ * because an address is lowercased when read.
+ *
+ * One case, one spelling, no exceptions. Every tree already complies but two,
+ * and nothing in any of them collides when folded.
  *
  * @type {RegExp}
  */

package/types/engine/base-compiler.d.mts

@@ -99,14 +99,42 @@ export class BasePackCompiler {
      * @type {boolean}
      */
     static requiresSystemBlock: boolean;
+    /**
+     * The **art fields** this pass reads off a note and writes onto its
+     * document — `img`, `portrait`, whichever of them reaches the output.
+     *
+     * Empty by default, and every shipped pass states its own, for the reason
+     * {@link BasePackCompiler.readsPackOutputOf} does: the fact belongs to the
+     * class that does the writing, and a second list of it somewhere else is a
+     * list free to disagree with what is actually emitted.
+     *
+     * The reader is the frontmatter lint. `img` is a *shared top-level* field —
+     * legal on every note whatever its type, because
+     * `BLOCK_DOCUMENT_PROPERTIES` maps it onto `document.img` — so a note whose
+     * document has no such property authors it, validates, compiles, and loses
+     * the value with nothing said. That is #349: `Parrot` in `sohl-thalorna`
+     * had declared `img:` since long before the art rule existed and compiled
+     * `img: null` exactly as a note declaring nothing does. Naming the fields
+     * here is what lets the lint tell an inert key from a live one.
+     *
+     * A pass that emits art **anywhere** in its document declares it, not only
+     * one that writes a top-level `img`: the scenes pass puts the path on the
+     * scene's background rather than on a property called `img`, and the value
+     * is no less live for it. The question this answers is whether the authored
+     * path reaches the output at all.
+     *
+     * @type {readonly string[]}
+     */
+    static emitsArt: readonly string[];
     /**
      * @param {object} options
      * @param {string} options.contentBase - Root of the content tree.
      * @param {string} options.dest - Where this pass writes its JSON.
      * @param {readonly string[]} options.skipDirectories - Directories the walk
      *   never descends into. Required: see {@link assertStatedScope}.
-     * @param {(path: string|null) => string|null} [options.folderResolver] -
-     *   Resolves a `sohl.folder` id against this pack's folder hierarchy.
+     * @param {(address: string|null) => string|null} [options.folderResolver] -
+     *   Resolves a `packFolder` — a folder note's address — to the Foundry
+     *   folder id it materialises as in this pack (#255, #257).
      * @param {string} [options.packName] - The pack this pass writes.
      * @param {string} [options.docType] - The Foundry document type it holds.
      * @param {{resolve: Function}} [options.router] - The pack router. Omit it
@@ -118,7 +146,7 @@ export class BasePackCompiler {
         contentBase: string;
         dest: string;
         skipDirectories: readonly string[];
-        folderResolver?: ((path: string | null) => string | null) | undefined;
+        folderResolver?: ((address: string | null) => string | null) | undefined;
         packName?: string | undefined;
         docType?: string | undefined;
         router?: {
@@ -236,6 +264,29 @@ export class BasePackCompiler {
      *   the note's own file can be read.
      */
     eligibleFor(fm: object): boolean;
+    /**
+     * A refusal only this pass can make, because its subject is the note's
+     * **type** (#330).
+     *
+     * The `assertNo*Field` family above it in the walk is type-agnostic by
+     * construction: it runs before `selects`, so that a note declaring a
+     * retired field is answered whichever pass would have claimed it. A rule
+     * about what a *`trauma`* may write cannot live there — it needs the type's
+     * field declaration, which only the pass that compiles the type can reach.
+     *
+     * So it is a hook, called once the note is known to be this pass's, and its
+     * throw is counted and located exactly as the family's is: the note is
+     * declined rather than skipped, and the build fails naming the line.
+     *
+     * The default refuses nothing, which is the honest position for a pass
+     * whose documents have no schema to have opinions about.
+     *
+     * @param {object} fm - The note's frontmatter.
+     * @returns {void}
+     * @throws {Error} When the note authors something its type forbids. The
+     *   error may carry a `position` for the diagnostic.
+     */
+    assertAuthorable(fm: object): void;
     /**
      * Whether this pass claims a note. **Required.**
      *

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

@@ -113,6 +113,70 @@ export function packageAddress(fm: object): string;
  * @returns {string} `package-system-type-shortcode`, lowercased.
  */
 export function canonicalKey(pkg: string, system: string, type: string, shortcode: string): string;
+/**
+ * Which system a frontmatter key path is written under.
+ *
+ * The **enclosing system block** decides, at any depth within it, and nothing
+ * else does: `sohl.items[3].model` and `sohl.system.body.structure` are both
+ * `sohl` because both sit under `sohl:`. Everywhere else is {@link NO_SYSTEM} —
+ * top-level frontmatter, the shared `data:` container, and body prose, which has
+ * no key path at all and passes `undefined`.
+ *
+ * It is the block rather than the field, so a `WikiLink` field needs no opinion
+ * about systems and no per-field table has to be kept in step with the schema.
+ *
+ * The first segment must **be** a declared system, not merely look like one:
+ * `sohlish.items` is a key called `sohlish`, and `notes.sohl.thing` names no
+ * block at all.
+ *
+ * @param {string} [keyPath] - The dotted frontmatter key path, or `undefined`
+ *   for body prose.
+ * @returns {string} The system id, or `none`.
+ */
+export function blockSystem(keyPath?: string): string;
+/**
+ * Expand a written address to the one canonical address it names.
+ *
+ * **An omitted segment defaults from where the link is written** (#336) — it is
+ * not a wildcard, and resolution is not a search. Package omitted means the
+ * citing note's own; system omitted means {@link blockSystem} of the key path it
+ * was written under. So every short form has exactly one expansion, computed
+ * before anything is looked up, and there is no candidate set to disambiguate.
+ *
+ * **Under `none`, a system-bearing type addresses its documentation journal.**
+ * A note's `none` address *is* its `doc<type>` entry — the Item is the one with
+ * a system — so a prose `[[affiliation-sirvadar|…]]` names the page, which is
+ * almost always what prose means. A link that means the Item states the system
+ * and gets it. This is the defaulting rule applied, not an exception carved out
+ * of it.
+ *
+ * **Only a type whose own document carries a system is redirected.** A `macro`
+ * and the map types have documentation journals too, but their own documents
+ * are core ones and already live at `none` — so `<pkg>-none-macro-x` names the
+ * Macro and `<pkg>-none-docmacro-x` its journal, two live addresses that the
+ * redirect would collapse into one. The test is the note type's own system,
+ * not merely whether it has a doc entry.
+ *
+ * A `doc<type>` written explicitly is `none` **wherever** it appears, even
+ * inside a system block: no game system defines a JournalEntry, so there is no
+ * other system for one to belong to.
+ *
+ * @param {{type: string, shortcode: string, package?: string, system?: string,
+ *   itemDoc?: boolean}} read - A qualifier, as `readQualifier` returns one.
+ * @param {{package: string, system?: string}} where - The citing context: the
+ *   tree's own content package, and the system of the block the link sits in.
+ * @returns {string} The canonical `package-system-type-shortcode`.
+ */
+export function expandAddress(read: {
+    type: string;
+    shortcode: string;
+    package?: string;
+    system?: string;
+    itemDoc?: boolean;
+}, where: {
+    package: string;
+    system?: string;
+}): string;
 /**
  * Reads a canonical key back into its parts.
  *

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

@@ -0,0 +1,127 @@
+/**
+ * Tier 1 — the letters, and the two whitespace characters a file is made of.
+ *
+ * The Latin-1 range is split around `U+00D7` and `U+00F7` deliberately: `×` and
+ * `÷` sit inside the letter block but are operators, and they are admitted
+ * below in Tier 3 on their own merits rather than smuggled in as letters.
+ *
+ * @param {number} cp - A Unicode code point.
+ * @returns {boolean} Whether Tier 1 admits it.
+ */
+export function isLetterTier(cp: number): boolean;
+/**
+ * Whether the charset admits a code point anywhere in a note.
+ *
+ * @param {number} cp - A Unicode code point.
+ * @returns {boolean} Whether it is allowed outside a code fence.
+ */
+export function isAllowedCodePoint(cp: number): boolean;
+/**
+ * Whether a code point is diagram furniture, admitted inside a fence only.
+ *
+ * A fenced block is set in the mono face, and the mono face is not the book
+ * face — so the question "does the text font have this" is the wrong question
+ * to ask about a character in an ASCII-art org chart. All three ranges were
+ * confirmed present in DejaVu Sans Mono, the mono face Typst embeds.
+ *
+ * @param {number} cp - A Unicode code point.
+ * @returns {boolean} Whether a fence may carry it.
+ */
+export function isDiagramCodePoint(cp: number): boolean;
+/**
+ * The reason a code point is refused.
+ *
+ * @param {number} cp - A Unicode code point.
+ * @returns {string} A clause naming what it is and what to do instead.
+ */
+export function refusalFor(cp: number): string;
+/**
+ * Every non-NFC run in a string, with the composed form it should have been.
+ *
+ * Reported as **runs** rather than as bare combining marks, because `y` plus
+ * `U+0301` is one authoring mistake and pointing at the accent alone would name
+ * the half the author did not type.
+ *
+ * @param {string} text - File contents.
+ * @returns {Array<{sequence: string, composed: string, index: number}>} Each
+ *   offending run, in the order it appears.
+ */
+export function decomposedRuns(text: string): Array<{
+    sequence: string;
+    composed: string;
+    index: number;
+}>;
+/**
+ * Check one file's text against the charset and the normalization rule.
+ *
+ * Findings are **deduplicated per character per line**: a 60-cell table of
+ * `━` is one mistake made once, and sixty findings would bury the other
+ * fifty-nine things wrong with the tree.
+ *
+ * @param {string} text - The file's contents.
+ * @param {string} file - Path to report, relative to the tree.
+ * @returns {Array<{file: string, line: number, column: number,
+ *   severity: "error", message: string}>} What is wrong, in file order.
+ */
+export function checkText(text: string, file: string): Array<{
+    file: string;
+    line: number;
+    column: number;
+    severity: "error";
+    message: string;
+}>;
+/**
+ * Walk a content tree and check every authored file in it.
+ *
+ * Dot-directories are skipped: `.obsidian` carries editor state, and a plugin
+ * manifest's CRLF line endings are not this tree's prose. That is not a
+ * theoretical exclusion — it was the first thing a run over `sohl-thalorna`
+ * reported before the skip existed.
+ *
+ * @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.
+ * @param {readonly string[]} [opts.extensions] - File extensions to read.
+ * @returns {{findings: Array<{file: string, line: number, column: number,
+ *   severity: "error", message: string}>, files: number}} The findings, and how
+ *   many files produced them.
+ */
+export function lintContentCharset(contentBase: string, { skipDirectories, extensions }?: {
+    skipDirectories?: readonly string[] | undefined;
+    extensions?: readonly string[] | undefined;
+}): {
+    findings: Array<{
+        file: string;
+        line: number;
+        column: number;
+        severity: "error";
+        message: string;
+    }>;
+    files: number;
+};
+/**
+ * Tier 2 — typography, enumerated one codepoint at a time.
+ *
+ * **Not the General Punctuation block.** `U+2000`–`U+206F` carries `U+200B`
+ * ZERO WIDTH SPACE, the `U+200E`/`U+200F` direction marks, the `U+2028`/`U+2029`
+ * separators, the `U+202A`–`U+202E` bidi overrides and `U+2060` WORD JOINER —
+ * precisely the invisibles this charset exists to refuse. Admitting the block
+ * to reach the em dash would admit all of them, so the ten that are wanted are
+ * named and the block is not.
+ *
+ * @type {ReadonlySet<number>}
+ */
+export const TYPOGRAPHY: ReadonlySet<number>;
+/**
+ * Tier 3 — the notation the rules and price tables are written in.
+ *
+ * Every one of these is carried by seven or eight of the eight probed faces, so
+ * the tier costs nothing in font freedom. It is a separate tier from the
+ * typography above only because it is a separate argument: these earn their
+ * place by being *needed* — a Shock threshold reads `≥ 10`, a wall is `10′ ×
+ * 11′` — where the typography earns it by being unavoidable.
+ *
+ * @type {ReadonlySet<number>}
+ */
+export const NOTATION: ReadonlySet<number>;

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

@@ -40,6 +40,9 @@ export const CONTENT_FORMAT_PATH: string;
  *   property — what a note actually writes. `appearance.eye_color` is authored
  *   as `appearance`, so that is the key recorded.
  * @property {Set<string>} dataPaths - The declared paths, whole.
+ * @property {string[]} subTypes - The `subType` values the section enumerates,
+ *   in document order — empty when it states none, which is the ordinary case
+ *   for a type that has no `subType` at all.
  */
 /**
  * One `system.*` target the specification names for one note type.
@@ -99,6 +102,12 @@ export type TypeSpec = {
      * - The declared paths, whole.
      */
     dataPaths: Set<string>;
+    /**
+     * - The `subType` values the section enumerates,
+     * in document order — empty when it states none, which is the ordinary case
+     * for a type that has no `subType` at all.
+     */
+    subTypes: string[];
 };
 /**
  * One `system.*` target the specification names for one note type.

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

@@ -0,0 +1,151 @@
+/**
+ * Look one name up.
+ *
+ * @param {string} name - The name written between the colons, without `icon-`.
+ * @param {Record<string, object>} [registry] - Defaults to {@link DEFAULT_ICONS}.
+ * @returns {{style: string, icon: string, label: string}|null} The entry, or
+ *   `null` when the registry does not declare it.
+ */
+export function resolveIcon(name: string, registry?: Record<string, object>): {
+    style: string;
+    icon: string;
+    label: string;
+} | null;
+/**
+ * The HTML the journals and the website emit — what the system already renders.
+ *
+ * Carries an accessible name rather than `aria-hidden`. The system's own
+ * templates hide their icons because a labelled parent element speaks for them;
+ * an icon dropped into a sentence has no such parent, and "the ☆ toggles it"
+ * read aloud as "the toggles it" is a sentence with a hole in it.
+ *
+ * @param {{style: string, icon: string, label: string}} entry - A registry entry.
+ * @returns {string} An `<i>` element.
+ */
+export function iconHtml(entry: {
+    style: string;
+    icon: string;
+    label: string;
+}): string;
+/**
+ * Every icon a string names, in the order written.
+ *
+ * @param {string} text - Markdown source.
+ * @returns {Array<{name: string, index: number, raw: string}>} What it names.
+ */
+export function iconsIn(text: string): Array<{
+    name: string;
+    index: number;
+    raw: string;
+}>;
+/**
+ * Report every icon a tree names that its registry does not declare.
+ *
+ * The whole point of a registry is that a typo is answerable, so this is the
+ * half that makes `:icon-stra:` a finding rather than three words of literal
+ * text nobody notices in a rendered page.
+ *
+ * @param {string} text - The file's contents.
+ * @param {string} file - Path to report.
+ * @param {Record<string, object>} [registry] - Defaults to {@link DEFAULT_ICONS}.
+ * @returns {Array<{file: string, line: number, column: number,
+ *   severity: "error", message: string}>} The unknown names.
+ */
+export function lintIcons(text: string, file: string, registry?: Record<string, object>): Array<{
+    file: string;
+    line: number;
+    column: number;
+    severity: "error";
+    message: string;
+}>;
+/**
+ * Refuse a registry that names a style Font Awesome Free does not ship.
+ *
+ * @param {Record<string, object>} registry - A package's icon table.
+ * @param {string} [where="icons"] - Where to say the fault is.
+ * @returns {Array<{severity: "error", message: string}>} What is wrong with it.
+ */
+export function checkIconRegistry(registry: Record<string, object>, where?: string): Array<{
+    severity: "error";
+    message: string;
+}>;
+/**
+ * Walk a content tree and report every icon name its registry does not declare.
+ *
+ * Its own walk rather than the charset check's, so both modules stay leaves
+ * with nothing imported between them. The cost is one extra pass over the tree,
+ * which is the cheaper half of a lint that already parses every note.
+ *
+ * @param {string} contentBase - Root of the content tree.
+ * @param {object} [opts]
+ * @param {readonly string[]} [opts.skipDirectories] - Directory names to ignore.
+ * @param {Record<string, object>} [opts.registry] - The package's icon table.
+ * @returns {{findings: Array<{file: string, line: number, column: number,
+ *   severity: "error", message: string}>, files: number}} What it found.
+ */
+export function lintContentIcons(contentBase: string, { skipDirectories, registry }?: {
+    skipDirectories?: readonly string[] | undefined;
+    registry?: Record<string, object> | undefined;
+}): {
+    findings: Array<{
+        file: string;
+        line: number;
+        column: number;
+        severity: "error";
+        message: string;
+    }>;
+    files: number;
+};
+/**
+ * A markdown-it plugin rendering `:icon-name:` inline.
+ *
+ * An unknown name is left **exactly as written** rather than dropped. The name
+ * is reported by {@link lintIcons}, and a rendered page that still shows
+ * `:icon-stra:` is how the author finds it without reading a log.
+ *
+ * @param {Record<string, object>} [registry] - Defaults to {@link DEFAULT_ICONS}.
+ * @returns {(md: object) => void} A markdown-it plugin.
+ */
+export function iconPlugin(registry?: Record<string, object>): (md: object) => void;
+/**
+ * The Font Awesome styles a registry entry may name.
+ *
+ * Free ships these three and no others, so a `light` or `duotone` entry would
+ * name a glyph the shipped font does not contain — refused here rather than
+ * discovered as a blank space in a printed book.
+ *
+ * @type {readonly string[]}
+ */
+export const ICON_STYLES: readonly string[];
+/**
+ * The icons the user guide already depicts, under the names it should call them.
+ *
+ * Each entry was read off the interface it describes rather than invented: the
+ * `star`/`star-outline` pair is the filled and hollow star the mastery row and
+ * the improve flag draw, and `edit` is the pencil the formula editor opens
+ * from. The names are what a *writer* would reach for — `delete`, not
+ * `trash-can` — because the writer is the one typing them; the Font Awesome
+ * spelling is this table's business, not theirs.
+ *
+ * @type {Readonly<Record<string, {style: string, icon: string, label: string}>>}
+ */
+export const DEFAULT_ICONS: Readonly<Record<string, {
+    style: string;
+    icon: string;
+    label: string;
+}>>;
+/**
+ * The shape a note writes, and the one this module claims.
+ *
+ * The `icon-` prefix is what keeps it out of the way of an emoji shortcode: a
+ * surface that also renders `:smile:` can tell the two apart without a lookup,
+ * and a reader can tell what `:icon-star:` is without knowing this module
+ * exists. Names are lowercase, digits and hyphens — the charset an address
+ * segment already uses (#59), so nothing new has to be explained.
+ *
+ * Not `:name[content]`. That is remark-directive syntax, and this toolchain
+ * parses with markdown-it; a directive would render as its own literal text.
+ *
+ * @type {RegExp}
+ */
+export const ICON_PATTERN: RegExp;