@heroiclands/package-build 18.2.0 → 20.0.0

package/engine/helpers.mjs

@@ -400,15 +400,92 @@ export function makeFilename(name, id) {
  * non-alphanumerics collapsed to single hyphens.
  */
 
+/**
+ * The path prefixes that name a package other than the one being compiled.
+ *
+ * Foundry serves every installed package from a root named for its kind, so a
+ * path opening with one of these is already a served address and belongs to
+ * somebody else — most often `systems/sohl/assets/…`, where every default this
+ * toolchain ships lives, and which a module's content cites as readily as the
+ * system's own does.
+ *
+ * **Two, not "the ones we happen to use".** `worlds/` is left out on purpose: a
+ * package may not ship art out of a world, so a note that writes one has made a
+ * mistake, and prefixing it yields a plainly broken path rather than a
+ * plausible one that fails silently much later.
+ *
+ * @type {readonly string[]}
+ */
+const FOREIGN_PACKAGE_ROOTS = Object.freeze(["systems/", "modules/"]);
+
+/**
+ * Whether a path already addresses something this package does not own, and so
+ * must be emitted exactly as authored.
+ *
+ * Three shapes qualify, each a different kind of "not mine":
+ *
+ * - **Another package** — `systems/…` or `modules/…`, per
+ *   {@link FOREIGN_PACKAGE_ROOTS}.
+ * - **Somewhere off this install** — a URI scheme (`https:`, `data:`) or a
+ *   protocol-relative `//cdn…`.
+ * - **The data root itself** — a leading `/`, which Foundry serves from the
+ *   install rather than from any package.
+ *
+ * @param {string} s - A non-empty authored path.
+ * @returns {boolean} Whether it passes through untranslated.
+ */
+function addressesAnotherPackage(s) {
+    if (FOREIGN_PACKAGE_ROOTS.some((root) => s.startsWith(root))) return true;
+    // `//host/x.png` — protocol-relative, so it leaves this origin entirely.
+    // Checked before the single-slash case, which would otherwise claim it.
+    if (s.startsWith("//")) return true;
+    // `/x.png` — rooted at the Foundry data root, not at any package.
+    if (s.startsWith("/")) return true;
+    // `https://…`, `data:…`, `file:…` — a scheme, so not a path at all.
+    return /^[a-z][a-z0-9+.-]*:/i.test(s);
+}
+
 /**
  * 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. For Foundry the bundled
- * asset roots — `icons/...` and `images/...` — are served from the package
- * directory, so they are rewritten to `<assetRoot>/<path>` — `systems/sohl/assets`
- * for this repository, `modules/<id>/assets` for a module (#1508). Any other
- * path (already package-rooted, an absolute URL) is returned unchanged.
+ * work for Foundry, the knowledgebase, and the website. **Its first segment
+ * says which package owns the file** (#331), 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 (#1508). 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 (#331).
+ *
+ * **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 (#331).** 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 (#218).** `null` — or an absent
  * key, which reaches here as `undefined` — means _unset_: the note names no art
@@ -453,10 +530,10 @@ export function resolveImg(raw, config = loadPackConfig()) {
     const s = String(raw);
     // Blank on purpose — the caller's default must not apply.
     if (s === "") return "";
-    if (s.startsWith("icons/") || s.startsWith("images/")) {
-        return `${config.assetRoot}/${s}`;
-    }
-    return s;
+    // Somebody else's to serve — emit it exactly as authored.
+    if (addressesAnotherPackage(s)) return s;
+    // Ours, so root it where Foundry serves this package's files from.
+    return `${config.assetRoot}/${s}`;
 }
 
 /**
@@ -913,102 +990,9 @@ export function expandNoteTables(body, { docs, name, fm, bodyLine, sqlTables })
 }
 
 /* ------------------------------------------------------------------------ */
-/*  Folder hierarchy: loading, resolution, emission                         */
+/*  Folder document filenames                                               */
 /* ------------------------------------------------------------------------ */
 
-/**
- * Loads a folders.yaml file as an array of folder entries. Returns []
- * when the file is missing (logging a warning) so packs without folders
- * can opt out simply by not committing the file.
- */
-export function loadFolders(foldersFile) {
-    if (!fs.existsSync(foldersFile)) {
-        log.warn(`No folders.yaml at ${foldersFile}; no folders will be emitted`);
-        return [];
-    }
-    const raw = fs.readFileSync(foldersFile, "utf8");
-    const parsed = yaml.parse(raw);
-    if (parsed == null) return [];
-    if (!Array.isArray(parsed)) {
-        throw new Error(`folders.yaml must contain a YAML list; got ${typeof parsed}`);
-    }
-    return parsed;
-}
-
-/**
- * Validates folder invariants and returns a resolver function that maps a
- * folder id to the same id (after verifying it exists). Returns `null` for
- * a null/empty input; throws for an unknown id.
- *
- * Invariants:
- *   - Every folder must have a non-empty id
- *   - Every folder must have a name
- *   - Sibling folders (same parentFolderId) must have unique names
- *   - Every parentFolderId must match an existing folder id (or be "")
- *
- * Returns { resolver, folders } where folders is the validated list.
- */
-export function buildFolderResolver(folders) {
-    const byId = new Map();
-    for (const f of folders) {
-        if (!f.id) {
-            throw new Error(`Folder missing id: ${JSON.stringify(f)}`);
-        }
-        if (!f.name) {
-            throw new Error(`Folder ${f.id} missing name`);
-        }
-        if (byId.has(f.id)) {
-            throw new Error(`Duplicate folder id ${f.id}`);
-        }
-        byId.set(f.id, f);
-    }
-
-    const siblingsByParent = new Map();
-    for (const f of folders) {
-        const parentId = f.parentFolderId || "";
-        if (parentId && !byId.has(parentId)) {
-            throw new Error(
-                `Folder ${f.id} (${f.name}) references unknown parentFolderId ${parentId}`,
-            );
-        }
-        if (!siblingsByParent.has(parentId)) {
-            siblingsByParent.set(parentId, new Set());
-        }
-        const siblings = siblingsByParent.get(parentId);
-        if (siblings.has(f.name)) {
-            throw new Error(
-                `Sibling folders share name "${f.name}" under parent ${parentId || "(root)"} — names must be unique among siblings`,
-            );
-        }
-        siblings.add(f.name);
-    }
-
-    /**
-     * The folder id a note names, by id.
-     *
-     * **Only by id.** This resolver answers for `folder:` alone; `packFolder:`
-     * names a folder *note* and is resolved through the address index instead
-     * (#255). The path lookup that briefly lived here is gone with the path
-     * spelling it served — it was never released, so there is nothing to
-     * deprecate.
-     *
-     * @param {string|null|undefined} value - As authored.
-     * @returns {string|null} The id, or `null` for an absent value.
-     * @throws {Error} When the id is not one this pack declares.
-     */
-    function resolver(value) {
-        if (value == null || value === "") return null;
-        const authored = String(value).trim();
-        if (!authored) return null;
-        if (!byId.has(authored)) {
-            throw new Error(`Unknown folder id "${authored}"`);
-        }
-        return authored;
-    }
-
-    return { resolver, folders };
-}
-
 /**
  * Builds a compendium-source filename for a folder JSON document:
  * `folder_Name_id.json` with non-alphanumeric runs replaced by
@@ -1017,28 +1001,3 @@ export function buildFolderResolver(folders) {
 export function folderFilename(name, id) {
     return `folder_${unidecode(name)}_${id}`.replace(/[^0-9a-zA-Z]+/g, "_") + ".json";
 }
-
-/**
- * Writes one JSON document per folder into `destDir`. `documentType`
- * determines the folder's Foundry `type` field — `"Item"` for the items
- * pack, `"JournalEntry"` for the journals pack.
- */
-export function writeFolderDocs(folders, stats, destDir, documentType) {
-    for (const folder of folders) {
-        const doc = {
-            name: folder.name,
-            sorting: "a",
-            folder: folder.parentFolderId || null,
-            type: documentType,
-            _id: folder.id,
-            sort: 0,
-            color: folder.color,
-            flags: folder.flags || {},
-            _stats: stats,
-            _key: `!folders!${folder.id}`,
-        };
-        const outPath = path.join(destDir, folderFilename(folder.name, folder.id));
-        fs.writeFileSync(outPath, JSON.stringify(doc, null, 2), "utf8");
-    }
-    log.info(`Emitted ${folders.length} folder document(s) to ${destDir}`);
-}

package/engine/index.mjs

@@ -69,6 +69,9 @@ export * as notePackage from "./note-package.mjs";
 /** Frontmatter fields a note may no longer declare, and the refusal of them. */
 export * as retiredFields from "./retired-fields.mjs";
 
+/** Schema fields a note may never declare, because play writes them. */
+export * as runtimeOnlyFields from "./runtime-only-fields.mjs";
+
 /** The package homepage: the note type that compiles to a page, not a document. */
 export * as homepage from "./homepage.mjs";
 

package/engine/item-compiler.mjs

@@ -66,6 +66,9 @@ import { documentSubtype, subtypeRow } from "./document-subtypes.mjs";
 // `system` verbatim, and `<system>.img` / `.effects` / `.flags` overriding
 // their shared top-level forms for this system alone (#58).
 import { blockField, blockProperty, claimedPaths, mergeSystemData } from "./system-block.mjs";
+// The other direction of the same declaration: a field the *document* writes in
+// play, which a note may not author and the builder does not emit (#330).
+import { assertNoRuntimeOnlyFields } from "./runtime-only-fields.mjs";
 
 /**
  * The description an item carries: a pointer to its **item doc**, the
@@ -113,6 +116,17 @@ export class SystemItemCompiler extends BasePackCompiler {
      */
     static requiresSystemBlock = true;
 
+    /**
+     * An Item carries an `img` — its icon — which this pass writes from the
+     * note's own path, falling back to the type's default art.
+     *
+     * `portrait` is **not** among them: a portrait is a being's sheet picture,
+     * and an item has nowhere to put one.
+     *
+     * @type {readonly string[]}
+     */
+    static emitsArt = Object.freeze(["img"]);
+
     /**
      * The note-type → document-subtype map this pass compiles against.
      *
@@ -174,6 +188,29 @@ export class SystemItemCompiler extends BasePackCompiler {
         return !row || row.document === "Item";
     }
 
+    /**
+     * Refuse a note authoring one of its type's **runtime-only** fields (#330).
+     *
+     * A schema declares fields the document writes for itself — an affliction's
+     * `onsetDate` is the world time its onset fired at — and a note authoring
+     * one used to compile, because `<system>.system` is a verbatim passthrough
+     * and the field really is in the schema. The result was shipped content
+     * carrying one world's play state, with the build reporting success.
+     *
+     * The declaration says which, so nothing here knows a field name; see
+     * {@link module:engine/runtime-only-fields}.
+     *
+     * @param {object} fm - The note's frontmatter.
+     * @returns {void}
+     * @throws {Error} When the note authors one.
+     */
+    assertAuthorable(fm) {
+        assertNoRuntimeOnlyFields(fm, itemFields(fm.type, this.system), {
+            block: this.system,
+            absPath: this.currentNote?.absPath,
+        });
+    }
+
     /**
      * The Foundry Item subtype a note compiles into.
      *
@@ -296,15 +333,13 @@ export class SystemItemCompiler extends BasePackCompiler {
         });
 
         const effects = blockProperty(fm, system, "effects");
-        // Read through the system block like every other item field, so both
-        // spellings work wherever a note already writes one. `packFolder` is a
-        // folder note's address and `folder` an id; which it is comes from the
-        // field, never from the string (#251, #255).
-        const packFolderAddress = blockField(fm, system, "packFolder", null);
-        const folder =
-            packFolderAddress ?
-                this.folderResolver(packFolderAddress, { isAddress: true })
-            :   this.folderResolver(blockField(fm, system, "folder", null));
+        // Read through the system block like every other item field. There is
+        // one spelling: `packFolder` names a folder note by its address, the
+        // `folder:` id spelling having been retired with the per-pack YAML it
+        // resolved against (#251, #255, #260).
+        const folder = this.folderResolver(blockField(fm, system, "packFolder", null), {
+            isAddress: true,
+        });
 
         return {
             name,

package/engine/journals.mjs

@@ -30,10 +30,13 @@
  * any other: the macro pass reads the same page independently, and withholds
  * nothing from the journal (#1514).
  *
- * Folder placement is identical to the items pack: `sohl.folder` in
- * frontmatter is the target folder's id (from folders.yaml), resolved
- * against a folders.yaml list via the constructor's `folderResolver`. A
- * documentation entry reuses its document's folder id verbatim.
+ * Folder placement is identical to the items pack: `sohl.packFolder` in
+ * frontmatter is a folder **note's address**, resolved through the shared
+ * address index by the constructor's `folderResolver` (#255, #260). A folder
+ * materialises in every pack holding a document that names it, so a journals
+ * pack needs to declare nothing (#257) — which is what stopped this pass
+ * filing documentation into folders its own pack had never heard of. A
+ * documentation entry reuses its document's folder verbatim.
  *
  * Not a standalone script — exports the `Journals` compiler class, imported
  * and driven by `packages/content-build/engine/generate.mjs` (via `npm run build:compiledb`).
@@ -311,6 +314,20 @@ export class Journals extends BasePackCompiler {
      */
     static requiresId = false;
 
+    /**
+     * **None.** A JournalEntry has no artwork — no `img` property, and no
+     * nested place for one — so a note whose whole document is prose has
+     * nowhere to put an authored path (#349).
+     *
+     * The emptiness is the declaration, in the sense `JOURNAL_ONLY_FIELDS` is:
+     * it is what separates a pass that emits no art from one that has simply
+     * not said, and it is the fact the frontmatter lint reports a `lore` note's
+     * inert `img:` from.
+     *
+     * @type {readonly string[]}
+     */
+    static emitsArt = Object.freeze([]);
+
     /**
      * How many of the compiled entries were documentation for a document
      * compiled elsewhere, for the summary.
@@ -381,12 +398,8 @@ export class Journals extends BasePackCompiler {
 
         // A documentation entry is filed exactly where the document it
         // describes is, so the journals pack mirrors the items pack and a doc
-        // sits under the same heading a reader found the item under. The id is
-        // taken verbatim rather than through `folderResolver`, which validates
-        // against this pack's own folders.yaml — an item folder is declared in
-        // the items one, a macro folder in the macros one, and a map's in the
-        // scenes one.
-        const { value: authoredFolder, isAddress } = folderField(fm);
+        // sits under the same heading a reader found the item under.
+        //
         // An address is resolved wherever it is written, including here — and
         // resolving it *here* is what cures the defect this comment used to
         // describe. A folder note has one definition and one address, so the
@@ -395,12 +408,10 @@ export class Journals extends BasePackCompiler {
         // with the first, and so no arrangement to assume: the mirroring
         // failure is unrepresentable rather than merely reported.
         //
-        // `folder:` is unchanged, and still crosses packs verbatim on the
-        // assumption both declare it — the arrangement #260 retires.
-        const folder =
-            isAddress ? this.folderResolver(authoredFolder, { isAddress: true })
-            : ownsDoc ? authoredFolder
-            : this.folderResolver(authoredFolder);
+        // The id spelling used to cross packs verbatim here, on the assumption
+        // both declared it — the arrangement #260 retires with the YAML.
+        const { value: authoredFolder } = folderField(fm);
+        const folder = this.folderResolver(authoredFolder, { isAddress: true });
 
         return buildJournalEntry({
             id,

package/engine/macros.mjs

@@ -295,6 +295,14 @@ export class Macros extends BasePackCompiler {
      */
     static convertsWikilinks = false;
 
+    /**
+     * A Macro carries an `img` — the tile art Foundry shows on the hotbar —
+     * defaulting to {@link DEFAULT_MACRO_IMG} where the note names none.
+     *
+     * @type {readonly string[]}
+     */
+    static emitsArt = Object.freeze(["img"]);
+
     /**
      * @param {object} fm - The note's frontmatter.
      * @returns {boolean} True for a `macro` note.

package/engine/map-notes.mjs

@@ -56,9 +56,9 @@ import { compendiumUuid, makeId, MAP_SUBTYPES, MAP_TYPES } from "./ids.mjs";
 // bridge (`SohlRegionTriggerBehavior`), so an event this build accepts is
 // exactly one the bridge forwards.
 import { CURATED_REGION_EVENTS, EXCLUDED_REGION_EVENTS } from "./region-events.mjs";
-// A map's background art is `img`, as every other note type's art is; `image`
-// is the retired spelling, still read through the retirement window (#142).
-import { readAliasedField } from "./retired-fields.mjs";
+// A map's background art is `img`, as every other note type's art is. `image`,
+// the spelling a map alone once used, is retired and gone (#149).
+import { sohlField } from "./frontmatter.mjs";
 
 /* -------------------------------------------------------------------- */
 /*  Note types and their canvas profiles                                */
@@ -907,7 +907,7 @@ export function buildScene(fm, ctx) {
     // Read from the note rather than from its `sohl:` block: art is not
     // system-specific, so `img` is authored at the top level like every other
     // type's, and `sohlField` honours the block for anything already there.
-    const img = readAliasedField(fm, "img");
+    const img = sohlField(fm, "img");
     if (!img) throw new Error("a map note needs an `img`");
 
     const warn = (message) => {
@@ -981,11 +981,11 @@ export function buildScene(fm, ctx) {
  * @param {string} sceneId - The owning scene's `_id`.
  * @param {string} [img] - The background art, already resolved from the note.
  *   Passed by {@link buildScene}, which reads it from the note rather than from
- *   the block; defaults to whichever spelling the block itself carries, so a
- *   direct two-argument call still works (#142).
+ *   the block; defaults to the block's own `img`, so a direct two-argument call
+ *   still works.
  * @returns {object} The Level document, keyed for the pack.
  */
-export function buildLevel(sohl, sceneId, img = readAliasedField({ sohl }, "img")) {
+export function buildLevel(sohl, sceneId, img = sohlField({ sohl }, "img")) {
     const level = {
         _id: DEFAULT_LEVEL_ID,
         name: sohl.levelName ?? "Ground",

package/engine/note-ids.mjs

@@ -44,6 +44,11 @@ import { documentId } from "./content-address.mjs";
 import { systemOf } from "./document-subtypes.mjs";
 import { contentPackage } from "./content-package.mjs";
 import { KNOWN_DOCUMENT_SUBTYPE_MAPS } from "./subtype-registry.mjs";
+// The folder id's derivation, taken from the pass that owns it rather than
+// restated here — see the `folder` branch below. `folder-notes.mjs` reaches
+// only `content-address`, `address-charset`, `ids` and `retired-fields`, none
+// of which reach this module, so the direction closes no cycle.
+import { FOLDER_TYPE, folderDocId } from "./folder-notes.mjs";
 
 /**
  * A frontmatter value read as a non-blank string, or `undefined`.
@@ -64,6 +69,20 @@ function text(value) {
 /**
  * The document id a note compiles under: its pin, or its address.
  *
+ * **One type hashes its address differently, and that is not an exception to
+ * the rule but an application of it.** A `Folder` is a document of its own
+ * class, and its id is hashed under the `folder` namespace so that a folder and
+ * an item sharing a shortcode cannot derive one id — a collision Foundry would
+ * not report, since it keys folders and documents in separate collections
+ * (#258). So the answer for a folder comes from
+ * {@link module:engine/folder-notes.folderDocId}, the pass that emits those
+ * documents, rather than from a second derivation here.
+ *
+ * That this function ever answered differently was invisible from inside a
+ * build — no pass reads a folder's id from here — and surfaced only in the
+ * content index, which is read from outside and had no way to be checked
+ * against what shipped (#310).
+ *
  * Returns `undefined` for a file with **no address** — no `type`, or no
  * `shortcode`. Such a file is not an addressable note, so it has no document
  * and inventing an id for one would file it under nothing. Every caller already
@@ -88,7 +107,12 @@ export function noteDocId(fm, { pkg, maps = KNOWN_DOCUMENT_SUBTYPE_MAPS } = {})
     const type = text(fm.type);
     const shortcode = text(fm.shortcode);
     if (!type || !shortcode) return undefined;
-    return documentId(pkg ?? contentPackage(), systemOf(type, maps), type, shortcode);
+    const owner = pkg ?? contentPackage();
+    // Lowercased because `collectFolderNotes` matches the type that way, and
+    // the two must answer alike about the same note or the divergence this
+    // branch closes reopens under a capitalised `type: Folder`.
+    if (type.toLowerCase() === FOLDER_TYPE) return folderDocId(owner, shortcode);
+    return documentId(owner, systemOf(type, maps), type, shortcode);
 }
 
 /**

package/engine/note-vocabulary.mjs

@@ -422,7 +422,14 @@ export const NOTE_VOCABULARY = Object.freeze({
         // values here would put a second, weaker answer beside the real one.
         subTypes: null,
         data: Object.freeze([
-            { name: "portrait", ...TEXT, describe: "Path to the portrait image." },
+            {
+                name: "portrait",
+                ...TEXT,
+                describe:
+                    "Path to the portrait image. Its first segment says which package owns " +
+                    "the file: `systems/…` and `modules/…` are emitted unchanged, anything " +
+                    "else is this package's own and is rooted under its assets.",
+            },
             TEMPLATE_PRIORITY,
             { name: "archetypes", ...LIST, describe: "Archetypal behaviours the being fits." },
             { name: "occupation", ...TEXT, describe: "What the being does for a living." },
@@ -466,7 +473,14 @@ export const NOTE_VOCABULARY = Object.freeze({
     vehicle: Object.freeze({
         subTypes: null,
         data: Object.freeze([
-            { name: "portrait", ...TEXT, describe: "Path to the portrait image." },
+            {
+                name: "portrait",
+                ...TEXT,
+                describe:
+                    "Path to the portrait image. Its first segment says which package owns " +
+                    "the file: `systems/…` and `modules/…` are emitted unchanged, anything " +
+                    "else is this package's own and is rooted under its assets.",
+            },
             TEMPLATE_PRIORITY,
         ]),
     }),
@@ -577,16 +591,31 @@ export const NOTE_VOCABULARY = Object.freeze({
                 ...TEXT,
                 describe: "Roll formula for the delay between contraction and onset.",
             },
+            {
+                name: "onsetDurationBase",
+                ...NUM,
+                describe: "That delay in seconds, stated outright instead of rolled.",
+            },
             {
                 name: "healingCheckDurationFormula",
                 ...TEXT,
                 describe: "Roll formula for the interval between healing checks.",
             },
+            {
+                name: "healingCheckDurationBase",
+                ...NUM,
+                describe: "That interval in seconds, stated outright instead of rolled.",
+            },
             {
                 name: "resolutionDurationFormula",
                 ...TEXT,
                 describe: "Roll formula for the time from onset to resolution.",
             },
+            {
+                name: "resolutionDurationBase",
+                ...NUM,
+                describe: "That time in seconds, stated outright instead of rolled.",
+            },
         ]),
     }),
 
@@ -719,7 +748,39 @@ export const NOTE_VOCABULARY = Object.freeze({
             "shock",
             "coma",
         ]),
-        data: Object.freeze([TEMPLATE_PRIORITY]),
+        data: Object.freeze([
+            TEMPLATE_PRIORITY,
+            {
+                name: "healingCheckDurationFormula",
+                ...TEXT,
+                describe: "Roll formula for the interval between healing checks.",
+            },
+            {
+                name: "healingCheckDurationBase",
+                ...NUM,
+                describe: "That interval in seconds, stated outright instead of rolled.",
+            },
+            {
+                name: "bloodLossAdvanceDurationFormula",
+                ...TEXT,
+                describe: "Roll formula for the interval between blood-loss advances.",
+            },
+            {
+                name: "bloodLossAdvanceDurationBase",
+                ...NUM,
+                describe: "That interval in seconds. Setting it is what makes the wound bleed.",
+            },
+            {
+                name: "courseDurationFormula",
+                ...TEXT,
+                describe: "Roll formula for the interval between course tests.",
+            },
+            {
+                name: "courseDurationBase",
+                ...NUM,
+                describe: "That interval in seconds, stated outright instead of rolled.",
+            },
+        ]),
     }),
 
     weapongear: Object.freeze({
@@ -809,6 +870,7 @@ export const NOTE_VOCABULARY = Object.freeze({
             "folk",
             "culture",
             "bestiary",
+            "gathering",
         ]),
         // Nothing of its own: a lore note is prose, and what it *is* about is
         // its subType. The specification declares an empty table for it, and
@@ -881,12 +943,17 @@ export const NOTE_VOCABULARY = Object.freeze({
         // derived for them, which is precisely what a subType decides (#174).
         subTypes: Object.freeze(["battlemap", "localmap", "regionalmap"]),
         data: Object.freeze([
-            // The specification spells this `img`, matching every other
-            // note type, while the map compiler reads `image` from
-            // `sohl:` today. It says outright that one of the two has
-            // to move; the container takes the specification's name,
-            // and moving the authored key is the migration's business.
-            { name: "img", ...TEXT, describe: "Path to the map art." },
+            // `img`, as every other note type spells its artwork. A map alone
+            // read `image` out of its `sohl:` block; that spelling is retired
+            // and gone (#149), so the two names are one again.
+            {
+                name: "img",
+                ...TEXT,
+                describe:
+                    "Path to the map art, owned by whichever package its first segment " +
+                    "names — `systems/…` and `modules/…` unchanged, anything else this " +
+                    "package's own.",
+            },
             {
                 name: "dimensions",
                 ...LIST,