@heroiclands/package-build 21.0.0 → 21.2.0

package/engine/content-index.mjs

@@ -92,6 +92,7 @@ import path from "node:path";
 import unidecode from "unidecode";
 
 import { metadataFileName } from "./metadata-index.mjs";
+import { collectAssetRecords } from "./asset-index.mjs";
 import { addressSlug, canonicalKey } from "./content-address.mjs";
 // One reader for a note's anchors, shared with the link checker and with the
 // builds that emit a link. Re-exported because this is where callers
@@ -122,9 +123,25 @@ import { loadPackConfig } from "./pack-config.mjs";
 // The record accessors, which live apart so that a module the compilers load
 // can read a record without importing this one and closing a cycle.
 // Re-exported because this is where callers have always addressed them.
-import { authoredFrontmatter, DERIVED_KEYS, isNoteRecord, noteFile } from "./index-records.mjs";
+import {
+    authoredFrontmatter,
+    DERIVED_KEYS,
+    isAssetRecord,
+    isNoteRecord,
+    noteFile,
+    recordPath,
+    sortKeysDeep,
+} from "./index-records.mjs";
 
-export { authoredFrontmatter, DERIVED_KEYS, isNoteRecord, noteFile };
+export {
+    authoredFrontmatter,
+    DERIVED_KEYS,
+    isAssetRecord,
+    isNoteRecord,
+    noteFile,
+    recordPath,
+    sortKeysDeep,
+};
 
 /**
  * The address a wikilink writes to reach a note, or `null` when it has none.
@@ -176,27 +193,6 @@ export function noteAddress(frontmatter, contentPackage) {
     };
 }
 
-/**
- * Recursively sort an object's keys, so serialization is order-independent.
- *
- * Arrays keep their order — it is authored — but every object inside one is
- * sorted too. Anything that is not a plain object is returned as it is.
- *
- * @param {unknown} value - The value to normalize.
- * @returns {unknown} The value with every plain object's keys in sorted order.
- */
-export function sortKeysDeep(value) {
-    if (Array.isArray(value)) return value.map(sortKeysDeep);
-    if (value === null || typeof value !== "object") return value;
-    // A Date or any other exotic object would lose itself in a rebuild from
-    // entries, and YAML frontmatter can produce one.
-    if (Object.getPrototypeOf(value) !== Object.prototype) return value;
-    /** @type {Record<string, unknown>} */
-    const out = {};
-    for (const key of Object.keys(value).sort()) out[key] = sortKeysDeep(value[key]);
-    return out;
-}
-
 /**
  * A note's display name reduced to printable 7-bit ASCII.
  *
@@ -537,12 +533,22 @@ function buildDocRecord({ frontmatter, address, entry, file, contentPackage, anc
  * An item note yields two records — the item, and the documentation journal
  * that is a document in its own right.
  *
+ * **The asset roots are walked in the same pass.** A package's addressable files
+ * sit beside `content/` rather than inside it, and they publish into the same
+ * index under the same address grammar — so there is no second walk, no second
+ * artifact, and no notion of an "art module" anywhere in the toolchain. A
+ * package whose tree holds only assets is one by consequence.
+ *
  * @param {string} contentBase - The content tree to walk.
  * @param {object} options - Options.
  * @param {string} options.contentPackage - The package the tree compiles as.
  * @param {readonly string[]} options.skipDirectories - The walk's scope, stated
  *   by the caller. An absent one is the caller's omission, and
  *   {@link module:engine/helpers.walkMarkdownTree} throws on it.
+ * @param {string} [options.assetsBase] - The package's asset directory, holding
+ *   the three asset roots. Omitted, no asset is indexed — which is what a caller
+ *   walking a bare content fixture wants, and what an asset-free package gets
+ *   anyway.
  * @param {object} [options.manifest] - The package manifest, which the Foundry
  *   entries are derived against.
  * @param {object[]} [options.problems] - Supplied by a **reader**: a note that
@@ -554,7 +560,7 @@ function buildDocRecord({ frontmatter, address, entry, file, contentPackage, anc
  */
 export function collectContentIndex(
     contentBase,
-    { contentPackage, skipDirectories, manifest, problems },
+    { contentPackage, skipDirectories, assetsBase, manifest, problems },
 ) {
     const records = [];
     // Passed through rather than defaulted away: an absent scope is the
@@ -621,16 +627,31 @@ export function collectContentIndex(
         }
     }
 
-    // Content path, then the canonical address, then the note id. The walk
+    if (assetsBase) {
+        // Sorted at every depth like a note's record, and for the same reason:
+        // the declaration order of the `asset` fields is a fact about the
+        // emitter, not about the content, and the artifact is meant to be
+        // byte-identical across two runs over an unchanged tree.
+        for (const record of collectAssetRecords(assetsBase, { contentPackage, problems })) {
+            records.push(/** @type {Record<string, any>} */ (sortKeysDeep(record)));
+        }
+    }
+
+    // Source path, then the canonical address, then the note id. The walk
     // yields in directory-read order, which is not a fact about the content,
     // and a rebuild that reordered lines would make every regeneration look
     // like a change. The address comes before the id because an item note's two
     // records share a file and carry two different ids — ordering on the id
     // first would sort the documentation against the item it documents by a
     // pair of hashes, which is no order at all.
+    //
+    // The path is read through {@link recordPath} because the two record shapes
+    // state it differently — a note names the `.md` it was parsed from, an asset
+    // the file it *is* — and both are paths within the package, so one order
+    // covers them.
     records.sort(
         (a, b) =>
-            String(a.file.path).localeCompare(String(b.file.path), "en") ||
+            recordPath(a).localeCompare(recordPath(b), "en") ||
             String(a.address?.canonical ?? "").localeCompare(
                 String(b.address?.canonical ?? ""),
                 "en",
@@ -664,6 +685,10 @@ export function serializeContentIndex(records) {
  *
  * @param {object} [opts]
  * @param {string} [opts.contentBase] - The tree, defaulting to the configured one.
+ * @param {string} [opts.assetsBase] - The asset roots' parent, defaulting to
+ *   the configured one. Stated separately from `contentBase` because the two
+ *   move independently — a caller walking an assembled fixture tree says where
+ *   that fixture's files are.
  * @param {object} [opts.config] - Resolved configuration, defaulting to ambient.
  * @param {readonly string[]} [opts.skipDirectories] - The walk's scope, for a
  *   caller that resolved one of its own; defaults to the resolved
@@ -677,13 +702,20 @@ export function serializeContentIndex(records) {
  *   exist.
  * @returns {object[]} One record per note, plus one per documentation entry.
  */
-export function indexRecordsFor({ contentBase, config, skipDirectories, problems } = {}) {
+export function indexRecordsFor({
+    contentBase,
+    assetsBase,
+    config,
+    skipDirectories,
+    problems,
+} = {}) {
     const resolved = config ?? loadPackConfig();
     const tree = contentBase ?? resolved.paths.content;
     if (!fs.existsSync(tree)) throw new Error(`no content tree at ${tree}`);
     return collectContentIndex(tree, {
         contentPackage: resolved.contentPackage,
         skipDirectories: skipDirectories ?? resolved.skipDirectories,
+        assetsBase: assetsBase ?? resolved.paths.assets,
         // Only the identities a UUID is a function of — see emitContentIndex.
         manifest: foundryIdentities(resolved),
         problems,
@@ -699,8 +731,9 @@ export function indexRecordsFor({ contentBase, config, skipDirectories, problems
  * @param {string} [options.outDir] - Where to write; defaults to the configured
  *   `paths.contentIndex`.
  * @param {object} [options.config] - A resolved configuration; loaded when omitted.
- * @returns {{file: string, notes: number, bytes: number}} Where it was written,
- *   how many notes it holds, and its size.
+ * @returns {{file: string, notes: number, assets: number, records: number,
+ *   bytes: number}} Where it was written, how many notes and how many assets it
+ *   holds, how many records that is in all, and its size.
  * @throws {Error} When the content tree is absent, or when it yields no note at
  *   all — an empty index is indistinguishable from a mis-pointed tree, and a
  *   reader would take it as the authoritative statement that this package has
@@ -739,8 +772,10 @@ export function emitContentIndex({ contentBase, outDir, config } = {}) {
     fs.writeFileSync(file, text);
 
     // Counted separately because they are genuinely different numbers: an item
-    // note yields a second record for its documentation journal, so reporting
-    // records as notes would overstate how large the tree is.
-    const notes = records.filter((r) => !r.documents).length;
-    return { file, notes, records: records.length, bytes: Buffer.byteLength(text) };
+    // note yields a second record for its documentation journal and a file
+    // yields an asset record, so reporting records as notes would overstate how
+    // large the tree is.
+    const notes = records.filter(isNoteRecord).length;
+    const assets = records.filter(isAssetRecord).length;
+    return { file, notes, assets, records: records.length, bytes: Buffer.byteLength(text) };
 }

package/engine/content-links.mjs

@@ -64,7 +64,16 @@ import { collectAnchors } from "./anchors.mjs";
 // derives it. Nothing in the index's own import graph reaches this
 // module, so this is a plain static import rather than the deferred one
 // `sql-tables` needs to keep out of the compilers' cycle.
-import { authoredFrontmatter, indexRecordsFor, isNoteRecord, noteFile } from "./content-index.mjs";
+import {
+    authoredFrontmatter,
+    indexRecordsFor,
+    isAssetRecord,
+    isNoteRecord,
+    noteFile,
+} from "./content-index.mjs";
+import { ASSET_TYPE_NAMES } from "./asset-types.mjs";
+import { resolveEmbeds } from "./content-embeds.mjs";
+import { foundryAddressProblem, servesFoundry } from "./pathnames.mjs";
 import { hasDocEntry } from "./item-docs.mjs";
 import { NO_SYSTEM, systemOf } from "./document-subtypes.mjs";
 import { KNOWN_DOCUMENT_SUBTYPE_MAPS } from "./note-claims.mjs";
@@ -173,9 +182,20 @@ export function buildLinkIndex(
         records ?? indexRecordsFor({ contentBase, config: resolved, skipDirectories, problems });
 
     const byKey = new Map();
+    /** Canonical address to asset record, for the files this package ships. */
+    const byAssetKey = new Map();
     const anchors = new Map();
 
     for (const record of indexRecords) {
+        // An asset's record addresses a file rather than a note: there is no
+        // body to read links out of and no anchor to resolve one against, so it
+        // is keyed for resolution and nothing else. Keyed here rather than
+        // alongside the notes because `byKey` holds notes, and a caller that
+        // reaches for `.fm` or `.body` on one must not be handed a file.
+        if (isAssetRecord(record)) {
+            if (record.address?.canonical) byAssetKey.set(record.address.canonical, record);
+            continue;
+        }
         // A documentation journal has a record of its own but no file and no
         // authored frontmatter — it is a document this tree emits, not a note
         // in it. Its addresses are keyed below, from the note it documents.
@@ -228,7 +248,14 @@ export function buildLinkIndex(
     // documentation journal's `doc<type>` is deliberately not among them: it is
     // virtual, and `readQualifier` resolves it from the base type rather than
     // from a type any tree declares.
-    const types = new Set(notes.map((n) => n.type));
+    //
+    // The **asset** types join unconditionally, whether or not this tree holds
+    // a file of each. They are a closed vocabulary rather than a census of what
+    // was found, and the difference is the whole diagnostic: an unknown type
+    // does not parse, so a tree with no `audio/` directory would read
+    // `audio-swoosh` as prose and say nothing, where an address the vocabulary
+    // knows and nothing answers is reported as the dead reference it is.
+    const types = new Set([...notes.map((n) => n.type), ...ASSET_TYPE_NAMES]);
 
     // A foreign package may use a type this tree has never seen, so its types
     // join `types` — otherwise `readQualifier` reads the link as prose and it
@@ -242,6 +269,17 @@ export function buildLinkIndex(
 
     const packages = new Set([...(byKey.size ? [pkg] : []), ...foreign.packages]);
 
+    // The address space an `![[…]]` embed resolves against, shaped as every
+    // other asset resolver reads one so the checker cannot answer an authored
+    // embed differently from the builds that emit it.
+    const assetIndex = {
+        types,
+        packages,
+        contentPackage: pkg,
+        assets: byAssetKey,
+        foreign: foreign.index,
+    };
+
     /** The searchable universe a `dataview` table draws its rows from. */
     const tableDocs = notes.map((n) => ({
         // Package present for a `WHERE … package = "…"` clause, synthesised
@@ -252,9 +290,93 @@ export function buildLinkIndex(
         folder: path.dirname(n.rel).split("/").pop(),
     }));
 
+    /**
+     * One note's body with its `dataview` and `sql` tables expanded.
+     *
+     * The body every body-level check reads, so a link and an embed in one note
+     * are found in the same text — a generated table is as free to carry either
+     * as prose is.
+     *
+     * @param {object} note - A note from this index.
+     * @returns {string} The markdown.
+     */
+    function expandedBody(note) {
+        const body = note.body;
+        if (!/^[ \t]*(?:`{3,}|~{3,})[ \t]*(?:dataview|sql)\b/im.test(body)) return body;
+        return expandContentTables(body, {
+            // Unfiltered: every note in the tree is this package's, so
+            // there is no other package's note to exclude.
+            docs: tableDocs,
+            linkable: (d) => Boolean(d.fm.shortcode),
+            source: note.file,
+            // A `sql` table's links are checked like an authored one's, so
+            // its rows are prepared ahead of this walk — see
+            // {@link module:engine/sql-tables.prepareTreeSqlTables}.
+            sqlTables: sqlTables?.get(note.file),
+        }).markdown;
+    }
+
+    /**
+     * Every `![[…]]` embed in a note body, resolved against the files this tree
+     * and its dependencies ship.
+     *
+     * @param {object} note - A note from this index.
+     * @returns {Array<{text: string, occurrence: number, reason?: string,
+     *   target?: string, type?: string, message?: string}>} One entry per
+     *   defect, in the shape the finding reporter reads.
+     */
+    function embedsOf(note) {
+        const { unresolved, problems, images } = resolveEmbeds(expandedBody(note), {
+            index: assetIndex,
+        });
+        // **The address an embed resolved to, held to the Foundry surface.** An
+        // embed becomes the ordinary image every surface renders, so a file
+        // the website serves and the book stages can still be one no Foundry
+        // install carries — and the journal would take the pathname as
+        // authored. Reported against the embed the note actually wrote, which
+        // is what a reader can open and edit. A build that installs nothing in
+        // Foundry has no such surface and is not asked.
+        const dead =
+            servesFoundry(resolved) ?
+                images
+                    .map((image) => ({
+                        text: image.link,
+                        message: foundryAddressProblem(image.pathname, resolved),
+                    }))
+                    .filter((finding) => finding.message)
+            :   [];
+        const seen = new Map();
+        /**
+         * @param {string} text - The embed exactly as authored.
+         * @returns {number} Its nth appearance in the note.
+         */
+        const at = (text) => {
+            const occurrence = (seen.get(text) ?? 0) + 1;
+            seen.set(text, occurrence);
+            return occurrence;
+        };
+        return [
+            ...unresolved.map((u) => ({
+                text: u.link,
+                target: u.target,
+                reason: u.reason,
+                ...(u.type ? { type: u.type } : {}),
+            })),
+            ...problems.map((problem) => ({
+                text: problem.link,
+                message: problem.message,
+            })),
+            ...dead,
+        ].map((finding) => ({ ...finding, occurrence: at(finding.text) }));
+    }
+
     /**
      * Every wikilink in a note body, with its `dataview` tables expanded.
      *
+     * An `![[…]]` embed is not one: it names a file rather than a note, and
+     * {@link module:engine/wikilink-syntax.WIKILINK} excludes it so that no
+     * reader can take one for the other.
+     *
      * @param {object} note - A note from this index.
      * @returns {Array<{target: string, anchor: string, text: string,
      *   occurrence: number, labelled: boolean}>} `target` is `""` for a
@@ -262,26 +384,13 @@ export function buildLinkIndex(
      *   `|` every link must have.
      */
     function linksOf(note) {
-        let body = note.body;
-        if (/^[ \t]*(?:`{3,}|~{3,})[ \t]*(?:dataview|sql)\b/im.test(body)) {
-            body = expandContentTables(body, {
-                // Unfiltered: every note in the tree is this package's, so
-                // there is no other package's note to exclude.
-                docs: tableDocs,
-                linkable: (d) => Boolean(d.fm.shortcode),
-                source: note.file,
-                // A `sql` table's links are checked like an authored one's, so
-                // its rows are prepared ahead of this walk — see
-                // {@link module:engine/sql-tables.prepareTreeSqlTables}.
-                sqlTables: sqlTables?.get(note.file),
-            }).markdown;
-        }
+        const body = expandedBody(note);
         const out = [];
         // How many times each authored link has been seen, so two identical
         // links in one note are reported at their own positions.
         const seen = new Map();
-        // Code is verbatim, so a `[[…]]` inside a fence, an indented block or
-        // an inline span is not a link — the compilers make none of it either.
+        // Code is verbatim, so a `[[…]]` inside a fence, an indented block or an
+        // inline span is not a link — the compilers make none of it either.
         for (const [all, rawInner] of matchAllOutsideCode(body, new RegExp(WIKILINK.source, "g"))) {
             const parsed = parseWikilink(rawInner);
             const { target, anchor } = parsed;
@@ -366,7 +475,11 @@ export function buildLinkIndex(
         // plain `Map.set` — so two notes in one package sharing a
         // `(type, shortcode)` across systems silently overwrote each other, and
         // a bare link resolved to whichever was indexed second.
-        return byKey.get(expandAddress(qualified, { package: pkg, system: blockSystem(keyPath) }));
+        const canonical = expandAddress(qualified, { package: pkg, system: blockSystem(keyPath) });
+        // Assets are consulted after notes and never instead of them: the two
+        // namespaces cannot collide — an address carries its type — so the order
+        // is about which map holds the answer, not about precedence.
+        return byKey.get(canonical) ?? byAssetKey.get(canonical);
     }
 
     /**
@@ -431,13 +544,17 @@ export function buildLinkIndex(
      * to this one. That is the rule for a link, whose target is a document to
      * point at; a reference names an item to stand beside.
      *
+     * The files this package ships answer here too, and by the same rule: an
+     * asset's address is a `(type, shortcode)` pair like any other, so a field
+     * naming `icon-anvil` resolves to the record that carries the file's path.
+     *
      * @param {string} target - The reference as `type-shortcode`.
-     * @returns {object|null} The note or foreign entry declaring it.
+     * @returns {object|null} The note, asset record or foreign entry declaring it.
      */
     function referenceHit(target) {
         const q = readQualifier(target, types, packages);
         if (!q || q.reason) return null;
-        const local = matchAddress([...byKey], q);
+        const local = matchAddress([...byKey, ...byAssetKey], q);
         if (local.length) return local[0][1];
         const abroad = matchAddress([...foreign.index], q);
         return abroad.length ? abroad[0][1] : null;
@@ -449,6 +566,17 @@ export function buildLinkIndex(
         anchors,
         types,
         packages,
+        /**
+         * The files this package ships, by canonical address. Separate from the
+         * notes because the two record shapes are read differently, and exposed
+         * because a pass resolving art needs the address set without walking the
+         * index again.
+         */
+        assets: byAssetKey,
+        /**
+         * The address space an `![[…]]` embed resolves against.
+         */
+        assetIndex,
         /**
          * The one package this tree publishes. Distinct from `packages`, which
          * is the set an address may name and which a homepage-only tree leaves
@@ -457,6 +585,7 @@ export function buildLinkIndex(
         contentPackage: pkg,
         foreign,
         linksOf,
+        embedsOf,
         /**
          * Resolve a link target the way both builds do, or `undefined`. Every
          * link is an address, so this is {@link resolveAddress} under the name
@@ -797,7 +926,15 @@ export function auditHomepageLinks(index) {
  *   the three resolvers agree on severity for every class.
  */
 export function auditLinks(index) {
-    const { notes, anchors, linksOf, resolve, manifestHit, isAddress } = index;
+    const { notes, anchors, linksOf, embedsOf, resolve, manifestHit, isAddress } = index;
+
+    // An embed names a file, and is checked here rather than by the image pass
+    // because its grammar is the wikilink's: the same short-form ladder, the
+    // same package defaults and the same findings vocabulary.
+    const deadEmbeds = [];
+    for (const note of notes) {
+        for (const finding of embedsOf(note)) deadEmbeds.push({ note, ...finding });
+    }
 
     const deadAnchors = [];
     for (const note of notes) {
@@ -805,9 +942,11 @@ export function auditLinks(index) {
             if (!anchor || !labelled) continue;
             const dest = target ? resolve(target) : note;
             // An unresolvable target is reported by the pass below; its anchor
-            // has nothing to be checked against.
+            // has nothing to be checked against. Neither has a file: an asset
+            // resolves but has no body, so it declares the empty set of anchors
+            // and every `#section` on one is dead.
             if (!dest) continue;
-            if (!anchors.get(dest).has(slugify(anchor))) {
+            if (!(anchors.get(dest) ?? new Set()).has(slugify(anchor))) {
                 deadAnchors.push({
                     note,
                     link: `${target}#${anchor}`,
@@ -876,6 +1015,7 @@ export function auditLinks(index) {
     return {
         deadAnchors,
         deadAddresses,
+        deadEmbeds,
         unlabelledLinks,
         frontmatterLinks: index.frontmatterLinks,
         homepageLinks: auditHomepageLinks(index),

package/engine/frontmatter-lint.mjs

@@ -72,11 +72,14 @@ import { isAddressSegment } from "./address-charset.mjs";
 // reads is exactly the disagreement to avoid.
 import { DEFAULT_PARENT } from "./folder-notes.mjs";
 import {
+    dataFields,
     declaredTags,
     exclusiveTagGroups,
     subTypeCharsetMessage,
     typeCharsetMessage,
 } from "./note-vocabulary.mjs";
+// The art slots, declared once. The linter states no art key of its own.
+import { ART_SLOTS } from "./art-fields.mjs";
 import {
     RETIRED_FIELD_ALIASES,
     declaresRetiredAlias,
@@ -770,28 +773,25 @@ function checkExclusiveTags(note, { type }) {
 }
 
 /**
- * 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}[]}
+ * The frontmatter fields that name artwork.
+ *
+ * {@link module:engine/art-fields.ART_SLOTS} is the declaration; this is that
+ * list in the shape the checks below read, so the linter states no art key of
+ * its own and a slot added there is checked here with no second edit. All four
+ * are authored under `data:`, which is what `inData` records.
+ *
+ * `document` separates the three that reach a compiled document from `banner`,
+ * which reaches none by design. The inert-art check reads it: a key that is
+ * *meant* to reach no document is not an inert key, and reporting every note
+ * that names a hero image would bury the finding that matters.
+ *
+ * @type {readonly {key: string, inData: boolean, document: boolean}[]}
  */
-export const ART_FIELDS = Object.freeze([
-    Object.freeze({ key: "img", inData: false }),
-    Object.freeze({ key: "portrait", inData: true }),
-]);
+export const ART_FIELDS = Object.freeze(
+    ART_SLOTS.map((slot) =>
+        Object.freeze({ key: slot.key, inData: true, document: slot.document }),
+    ),
+);
 
 /**
  * The keys a field declaration is authored at **inside a system block**.
@@ -1159,7 +1159,11 @@ export function lintNote(
     const emitted = emittedArt ? emittedArt(currentType(type)) : null;
     /** The art fields this note's type reaches nothing through. */
     const inertArt = new Set(
-        emitted ? ART_FIELDS.filter(({ key }) => !emitted.art.includes(key)).map((f) => f.key) : [],
+        emitted ?
+            ART_FIELDS.filter(({ key, document }) => document && !emitted.art.includes(key)).map(
+                (f) => f.key,
+            )
+        :   [],
     );
     for (const { key, inData } of ART_FIELDS) {
         if (!inertArt.has(key)) continue;
@@ -1400,7 +1404,16 @@ export function lintNote(
     // to recognise it would be worse than not checking.
     const entry = vocabulary?.[current];
     if (entry) {
-        findings.push(...checkDataContainer(note, { type, fields: entry.data ?? [], packs }));
+        findings.push(
+            ...checkDataContainer(note, {
+                type,
+                // Read through `dataFields`, so the keys **every** type accepts
+                // are part of what this type declares rather than a second list
+                // the container check would have to be told about.
+                fields: dataFields(current, vocabulary) ?? [],
+                packs,
+            }),
+        );
         findings.push(...checkSubType(note, { type, entry }));
     }