@heroiclands/package-build 22.21.0 → 22.22.0

package/types/engine/page-lists.d.mts

@@ -0,0 +1,126 @@
+/**
+ * Every `pagelist` fence in a markdown body, with the position each occupies.
+ *
+ * Positions are 0-based lines into the body as given, which is what a
+ * diagnostic about a directive needs and what the expander uses to splice
+ * results back in.
+ *
+ * **A malformed directive is still a directive.** It is returned carrying its
+ * problems rather than skipped, so the expander finds a prepared answer at its
+ * ordinal and reports the fault where the fence sits. That includes a fence
+ * nobody closed, which the author meant as a directive and which would
+ * otherwise swallow the rest of the note into a code block.
+ *
+ * @param {string} markdown - The note body, frontmatter already stripped.
+ * @returns {Array<{line: number, close: number, indent: string, tag: string,
+ *   type: string, sort: string, descriptions: boolean, allowEmpty: boolean,
+ *   problems: string[], block: string}>} One entry per fence, in document order.
+ */
+export function findPageListBlocks(markdown: string): Array<{
+    line: number;
+    close: number;
+    indent: string;
+    tag: string;
+    type: string;
+    sort: string;
+    descriptions: boolean;
+    allowEmpty: boolean;
+    problems: string[];
+    block: string;
+}>;
+/**
+ * The pages a directive selects, as index records.
+ *
+ * A **stub** is left out: an empty body publishes no page, which the index says
+ * by holding no address, so there is nothing for the list to link to. A
+ * documentation journal and an asset are not pages an author tagged, which
+ * {@link module:engine/index-records.isNoteRecord} already answers.
+ *
+ * @param {object[]} records - Content-index records.
+ * @param {{tag: string, type: string}} directive - From {@link findPageListBlocks}.
+ * @returns {object[]} The selected records, unordered.
+ */
+export function pagesForList(records: object[], { tag, type }: {
+    tag: string;
+    type: string;
+}): object[];
+/**
+ * Render one directive's answer as markdown.
+ *
+ * **The emitted link is the page's `address.slug`** — the `type-shortcode`
+ * form a wikilink resolves — which is exactly what a table's `_ref` cell
+ * writes. A short form names the package the link is written in, so it is
+ * unambiguous for a list of this package's own pages, and it resolves to the
+ * note's **page** on each surface: a compendium journal in Foundry, a URL on
+ * the web and in the book. An item note's page is its documentation journal,
+ * and the short form reaches it the way prose does.
+ *
+ * @param {object[]} records - Content-index records.
+ * @param {object} directive - From {@link findPageListBlocks}.
+ * @returns {{markdown: string, pages: number}} The list, and how many pages
+ *   are in it.
+ */
+export function renderPageList(records: object[], directive: object): {
+    markdown: string;
+    pages: number;
+};
+/**
+ * Answer every `pagelist` directive in a set of note bodies, ahead of expansion.
+ *
+ * **Why a separate pass.** The same reason the SQL tables have one:
+ * {@link module:engine/content-tables.expandContentTables} is synchronous and
+ * exported, and the corpus is enumerated once by whoever already holds it
+ * rather than derived again inside a renderer. A page list needs no database —
+ * it is a filter over the records — so preparing one costs a walk of what the
+ * caller already has.
+ *
+ * **Keyed by note, then by the directive's ordinal within it**, not by its
+ * line: the passes do not agree on what a body is, and trim it differently,
+ * but a directive's position in the sequence of fences is the same in each.
+ *
+ * A malformed directive is recorded rather than thrown, so one bad fence costs
+ * its own list and not the whole build's report.
+ *
+ * @param {object[]} records - Content-index records, already narrowed to the
+ *   audience the surface publishes to.
+ * @param {Array<{source: string, markdown: string}>} sources - The bodies to scan.
+ * @returns {Map<string, Array<{markdown?: string, pages?: number, empty?: string,
+ *   reason?: string, allowEmpty: boolean}>>} Note to results, in document order.
+ */
+export function preparePageLists(records: object[], sources: Array<{
+    source: string;
+    markdown: string;
+}>): Map<string, Array<{
+    markdown?: string;
+    pages?: number;
+    empty?: string;
+    reason?: string;
+    allowEmpty: boolean;
+}>>;
+/** The fence language that opens a page list. */
+export const PAGE_LIST_LANGUAGE: "pagelist";
+/**
+ * The orders a page list may come out in.
+ *
+ * Ordering is about output rather than about the pages, so it is an attribute
+ * rather than something read off a note. `name` is alphabetical, case and
+ * accents folded; `type` groups the note types and orders by name inside each.
+ *
+ * @type {readonly string[]}
+ */
+export const PAGE_LIST_SORTS: readonly string[];
+/**
+ * The attributes a page-list fence takes, with what each one is for.
+ *
+ * **This is the one list.** The fence is validated against it, the authoring
+ * document's table is generated from it, and the reference is checked against
+ * it — so an attribute added here is one both documents describe, and anything
+ * else an author writes is reported by name.
+ *
+ * @type {Readonly<Record<string, Readonly<{value: string, default: string, summary: string}>>>}
+ */
+export const PAGE_LIST_ATTRIBUTES: Readonly<Record<string, Readonly<{
+    value: string;
+    default: string;
+    summary: string;
+}>>>;

package/types/engine/pdf-render.d.mts

@@ -37,6 +37,24 @@ export function labelFor(anchor: string): string;
  * @returns {object} A markdown-it instance.
  */
 export function createParser(registry?: object): object;
+/**
+ * A markdown body with its HTML comments taken out.
+ *
+ * A comment is an author's aside to the next author — a `markdownlint` pragma, a
+ * note recording why a notice is quoted verbatim — and no surface shows one: the
+ * packs and the website emit it into HTML, where it is a comment still. Typst
+ * has nowhere to put it, so markdown-it hands the delimiters over as prose and
+ * the aside is typeset. It comes out here instead, and a comment inside a fence
+ * or a code span stays, because there it is an example of a comment.
+ *
+ * **The line count is preserved.** Every finding this module reports is located
+ * in the markdown it was handed, so a pass that removed a line would move every
+ * position after it.
+ *
+ * @param {string} markdown - The body, as authored.
+ * @returns {string} The same body, its comments replaced by their own newlines.
+ */
+export function stripHtmlComments(markdown: string): string;
 /**
  * Render markdown as Typst content.
  *
@@ -55,8 +73,26 @@ export function createParser(registry?: object): object;
  *   note's own `##` nests beneath the entry heading the book gave it.
  * @param {string} [opts.anchorPrefix] - The entry's anchor, which namespaces
  *   every `{#slug}` the body declares.
- *   capital. Set for an entry, which begins a page; not for front matter or a
- *   prose file, which carry headings of their own.
+ * @param {object[]} [opts.findings] - Collected here rather than thrown. Every
+ *   construct this pass cannot render is reported into it — see
+ *   {@link reportUnrenderable} — and a caller that passes none renders the same
+ *   Typst and is told nothing.
+ * @param {string} [opts.file] - The file the markdown came from, named in every
+ *   finding.
+ * @param {number} [opts.bodyLine] - The 1-based file line the body starts on, so
+ *   a finding's line is the file's rather than the body's.
+ * @param {number} [opts.bodyColumn] - The 1-based column the body starts at.
+ * @param {Array<{line: number, generated: boolean}>} [opts.lineMap] - From
+ *   table expansion, mapping each line handed in back to the line an author
+ *   wrote.
+ * @param {boolean} [opts.prepared] - Whether this body has been through the
+ *   passes that resolve a wikilink, an embed and an inline expression. A note's
+ *   has; a front-matter file's and a prose file's have not, and markup of theirs
+ *   left in one is reported rather than typeset in silence.
+ * @param {string} [opts.url] - The absolute address this book's pages are served
+ *   at. Every link the book sets as a URL is resolved against it, because a
+ *   reader holding a PDF has no page to resolve a path against — see
+ *   {@link renderLink}.
  * @returns {string} Typst markup.
  */
 export function markdownToTypst(markdown: string, opts?: {
@@ -67,7 +103,41 @@ export function markdownToTypst(markdown: string, opts?: {
     images?: Map<string, string> | undefined;
     headingOffset?: number | undefined;
     anchorPrefix?: string | undefined;
+    findings?: object[] | undefined;
+    file?: string | undefined;
+    bodyLine?: number | undefined;
+    bodyColumn?: number | undefined;
+    lineMap?: {
+        line: number;
+        generated: boolean;
+    }[] | undefined;
+    prepared?: boolean | undefined;
+    url?: string | undefined;
 }): string;
+/**
+ * A page address as a reader of the book can follow it.
+ *
+ * **Every link the book sets as a URL is absolute.** A page's address is written
+ * from the root of the site that serves it — `/sohl/skill-guil/` — because on the
+ * website that is the shortest form that is right wherever the page is read
+ * from. A PDF is read from nowhere: a viewer handed a path has no document to
+ * resolve it against, so it either does nothing or looks for a file on the
+ * reader's own disk, and a book of a thousand pages carries a thousand links
+ * that do neither.
+ *
+ * So a root-relative address is resolved against the site's own, which is the
+ * one absolute address a build already holds. A **dependency's** page keeps its
+ * own package prefix, from the registry in
+ * {@link module:engine/content-address.PACKAGE_BASE}, so it resolves to the host
+ * serving that package — and where the registry names a host of its own the
+ * address is already absolute and is left exactly as it is.
+ *
+ * @param {string} url - The address, as the link pass resolved it.
+ * @param {string} [site] - The absolute address this book's pages are served at.
+ * @returns {string} An absolute URL, or the address unchanged when there is no
+ *   site to resolve it against or it is already absolute.
+ */
+export function absolutePageUrl(url: string, site?: string): string;
 /**
  * The Typst definitions the book's page furniture is drawn with.
  *

package/types/engine/rank-ladder.d.mts

@@ -0,0 +1,32 @@
+/**
+ * Check one affiliation's `data.governance.ranks` against the rung contract.
+ *
+ * Each problem is its own finding, so a rung missing all three of its required
+ * keys reports three rather than the first: a reader fixing a ladder wants the
+ * whole of it in one pass.
+ *
+ * **A finding is located by the node it is about**, through the frontmatter's
+ * own YAML tree — a present-but-wrong value points at that value, and an absent
+ * key points at the rung that should have carried it, since a key that was
+ * never written has no position of its own. Where even the rung cannot be
+ * located the position is dropped rather than guessed, and the finding names
+ * the file alone.
+ *
+ * @param {object} note - The note being checked.
+ * @param {string} note.file - Its path, as a diagnostic spells it.
+ * @param {string} [note.raw] - Its source, for the position.
+ * @param {object} [note.fm] - Its parsed frontmatter.
+ * @returns {Array<{file: string, line?: number, column?: number,
+ *   severity: string, message: string}>} The findings, in authored order.
+ */
+export function checkRankLadder(note: {
+    file: string;
+    raw?: string | undefined;
+    fm?: object | undefined;
+}): Array<{
+    file: string;
+    line?: number;
+    column?: number;
+    severity: string;
+    message: string;
+}>;

package/types/engine/retired-fields.d.mts

@@ -256,12 +256,10 @@ export function legacyKeyMessage(block: string, field: {
  * What a note writing a field at the **top-level key `data:` gathered it off**
  * is told.
  *
- * {@link legacyKeyMessage}'s counterpart for the other retiring position. The
- * sweep
- * did not invent the facts `data:` holds — it collected them out of the note's
- * open top level — so `portrait:` beside `img:` is the *pre-`data:`* spelling
- * of `data.portrait`, and both are read for the same reason both in-block
- * spellings are: a package moves its corpus when it is ready, not on a flag day.
+ * {@link legacyKeyMessage}'s counterpart for the other retiring position.
+ * `portrait:` beside `img:` is the bare spelling of `data.portrait`, and both
+ * are read for the same reason both in-block spellings are: a package moves its
+ * corpus when it is ready, not on a flag day.
  *
  * It says nothing about which value is emitted, because that is not what an
  * author needs from it. The value is the same either way; what the finding

package/types/engine/site-build.d.mts

@@ -249,7 +249,7 @@ export function renderSitePage(page: any, { index, foreign, universe, pass, deco
     artIndex: any;
 }): {
     page: any;
-    body: any;
+    body: string;
     data: object;
     resolved: any[];
     tableErrors: object[];
@@ -266,6 +266,18 @@ export function renderSitePage(page: any, { index, foreign, universe, pass, deco
         column: number;
         message: string;
     }[];
+    headingErrors: {
+        line: number;
+        column: number;
+        message: string;
+        file: any;
+    }[];
+    footnoteErrors: {
+        file: any;
+        line: number;
+        column: number;
+        message: string;
+    }[];
     wikiErrors: any[];
     imageErrors: any[];
 };

package/types/engine/site-config.d.mts

@@ -178,12 +178,21 @@ export const DISABLE_KINDS: readonly string[];
  * `<span>` marking an unresolved link — and Goldmark drops raw HTML unless
  * told otherwise. A theme cannot supply this: Hugo does not merge a theme's
  * `markup` block.
+ *
+ * `extensions.taskList` is off because the format has no checkbox: Goldmark
+ * enables it by default, which is the only reason a list item opened with
+ * `[ ]` renders a `<input type="checkbox">` here and the same two characters as
+ * plain text in the pack and the book. Off, a list item's text begins right
+ * after its marker on every surface.
  */
 export const MARKUP: Readonly<{
     goldmark: Readonly<{
         renderer: Readonly<{
             unsafe: true;
         }>;
+        extensions: Readonly<{
+            taskList: false;
+        }>;
     }>;
 }>;
 /** Where the navigation is published. */

package/types/engine/site-index.d.mts

@@ -106,6 +106,12 @@ export type SiteEntry = {
      * The page's published address.
      */
     url: string;
+    /**
+     * The note's markdown body, for its anchors. A
+     *  content entry always carries one; absent, the
+     *  page is indexed as declaring none.
+     */
+    body?: string | undefined;
 };
 /**
  * The resolved index and everything a wikilink resolver reads beside it.
@@ -114,12 +120,18 @@ export type SiteIndex = {
     /**
      *                                       Address → page. `draft` says the page
      *                                       carries the `draft` tag, which marks a
-     *                                       link *into* it.
+     *                                       link *into* it. `anchors` names the
+     *                                       `{#slug}` sections it declares — a
+     *                                       `Set` for a local page, or the
+     *                                       `{slug: uuid}` map a foreign manifest
+     *                                       publishes — and is absent where
+     *                                       neither build recorded one.
      */
     index: Map<string, {
         url: string;
         name?: string;
         draft?: boolean;
+        anchors?: Set<string> | Record<string, string>;
     }>;
     /**
      * Short addresses claimed by two

package/types/engine/site-preview.d.mts

@@ -24,7 +24,7 @@ export function prepareSitePreview({ config }?: {
         frontmatter?: undefined;
     } | {
         ok: boolean;
-        markdown: any;
+        markdown: string;
         frontmatter: any;
         findings: never[];
     }>;

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

@@ -142,6 +142,10 @@ export function renderSqlTable(result: {
  * @param {object} [opts]
  * @param {(ref: string) => boolean} [opts.linkable] - Passed to
  *   {@link renderSqlTable}.
+ * @param {object[]} [opts.records] - Content-index records, narrowed to the
+ *   audience this surface publishes to. Given them, the result also carries
+ *   `pageLists`, so one prepared object answers every corpus-reading directive
+ *   a body can hold and a caller looks results up in one place.
  * **Keyed by note, then by the directive's ordinal within it** — not by its
  * line. The passes do not agree on what a body is: `walkMarkdownTree` trims it,
  * while the link checker strips the frontmatter fence and leaves the newlines
@@ -154,8 +158,9 @@ export function renderSqlTable(result: {
 export function prepareSqlTables(db: object, sources: Array<{
     source: string;
     markdown: string;
-}>, { linkable }?: {
+}>, { linkable, records }?: {
     linkable?: ((ref: string) => boolean) | undefined;
+    records?: object[] | undefined;
 }): Promise<Map<string, object[]>>;
 /** Evaluate scalar SQL calls before synchronous Markdown renderers run. */
 export function prepareInlineSqlExpressions(db: any, sources: any): Promise<Map<any, any>>;
@@ -167,10 +172,14 @@ export function prepareInlineSqlExpressions(db: any, sources: any): Promise<Map<
  * shared index
  * describes, where N passes each derive the corpus their own way.
  *
- * **Nothing is opened for a tree with no `sql` directive.** The corpus is still
- * written entirely in the retiring language, so until a table is converted this
- * costs one walk and no database at all — which is what lets every pass call it
- * unconditionally.
+ * **Every corpus-reading directive is answered here**, which is why one call
+ * precedes every pass: the `sql` tables, the inline scalar queries, and the
+ * page lists, whose results ride on the same object as `pageLists`.
+ *
+ * **Nothing is opened for a tree that asks no query.** A tree with no `sql`
+ * directive costs one walk and no database at all, and so does one whose only
+ * directive is a page list — a page list is a filter over the records. That is
+ * what lets every pass call this unconditionally.
  *
  * @param {string} contentBase - Root of the content tree.
  * @param {object} [opts]
@@ -180,8 +189,9 @@ export function prepareInlineSqlExpressions(db: any, sources: any): Promise<Map<
  *   A command that also builds a link index holds them already, and deriving
  *   them twice is the duplicated-corpus failure this closes.
  * @param {"all"|"public"} [opts.audience] - Whether to exclude GM notes.
- * @returns {Promise<Map<string, object[]>|undefined>} Results by note path, or
- *   nothing when the tree has no such directive.
+ * @returns {Promise<Map<string, object[]>|undefined>} Results by note path,
+ *   carrying `inline` and `pageLists` beside them, or nothing when the tree
+ *   holds no such directive.
  */
 export function prepareTreeSqlTables(contentBase: string, { config, skipDirectories, records, audience }?: {
     config?: object | undefined;
@@ -200,3 +210,17 @@ export const RENDER_ALIASES: Readonly<{
     ref: "_ref";
     section: "_section";
 }>;
+/**
+ * The attributes an SQL fence takes, with what each one is for.
+ *
+ * **This is the one list.** The fence is validated against it and the authoring
+ * document is checked against it, so an attribute added here is one the document
+ * must describe, and anything else an author writes is reported by name.
+ *
+ * @type {Readonly<Record<string, Readonly<{value: string, default: string, summary: string}>>>}
+ */
+export const SQL_FENCE_ATTRIBUTES: Readonly<Record<string, Readonly<{
+    value: string;
+    default: string;
+    summary: string;
+}>>>;

package/types/engine/standings.d.mts

@@ -37,6 +37,10 @@ export function readStandings(value: unknown): {
  * than by its position in the list: a body may write its rungs in any order,
  * and several start at zero.
  *
+ * One title per level, which is what the rung check holds a ladder to: two
+ * rungs claiming one level is a finding on the second, so a ladder that reaches
+ * here carries at most one title for any number a member's `rank` can hold.
+ *
  * @param {unknown} ranks - An affiliation's `data.governance.ranks`.
  * @returns {Map<number, string>} Level → the title that level is called.
  */
@@ -66,6 +70,18 @@ export function officeRoster(offices: unknown): Map<string, string>;
  * @returns {string} The anchor, or `""` where the name carries nothing.
  */
 export function officeAnchor(office: string): string;
+/**
+ * The anchor a rung's row is addressed by.
+ *
+ * The ladder's parallel to {@link officeAnchor}, prefixed apart from it so a
+ * body naming an office the same word as one of its ranks still gets two
+ * destinations rather than one row answering for both.
+ *
+ * @param {string} title - The rung's title, as the body wrote it.
+ * @returns {string} The anchor, or `""` where the title carries nothing
+ *   URL-safe.
+ */
+export function rankAnchor(title: string): string;
 /**
  * What an affiliation lends to a reference to it.
  *
@@ -106,12 +122,14 @@ export function standingPhrase(standing: object, body: string, digest?: {
 /**
  * Validate a being's memberships and the standing it holds in each.
  *
- * Four questions, and the last two are what keying the entry by its body buys:
+ * Five questions, and the last three are what keying the entry by its body
+ * buys:
  *
  * 1. the value is a map keyed by Address (or the list this window still takes);
  * 2. every key names an affiliation that resolves, once;
- * 3. a `rank` is a level the named body's `governance.ranks` declares;
- * 4. an `office` is a key of that body's `governance.offices`.
+ * 3. the entry states a `rank`;
+ * 4. a `rank` is a level the named body's `governance.ranks` declares;
+ * 5. an `office` is a key of that body's `governance.offices`.
  *
  * Both of the last two are read from the named body's own frontmatter as the
  * lint runs, so a renamed rung or a renamed post fails on every being pointing

package/types/engine/system-block.d.mts

@@ -79,17 +79,18 @@ export function blockField(fm: object, block: string, key: string, defaultValue?
  */
 export function sharedProperty(fm: object, source: string, defaultValue?: any): any;
 /**
- * A property a system block may override, else the shared top-level one.
+ * A property a system block declares, else the default.
  *
- * This is what gives `pack`, `effects`, `flags` and `img` their per-system form
- * without inventing a mechanism for each: a note that wants one value for both
- * systems says it once at the top, and a note that needs them to differ says so
- * in the block that differs.
+ * This is what gives `effects` and `flags` their per-system form without
+ * inventing a mechanism for each: a note states them inside the block whose
+ * document carries them, which is the only position the format accepts for
+ * either. A note needing one value for both systems writes it in both blocks —
+ * they are properties of a document, and there are two documents.
  *
  * @param {object} fm - The note's frontmatter.
  * @param {string} block - The block key.
  * @param {string} key - The property.
- * @param {any} [defaultValue] - Returned when neither declares it.
+ * @param {any} [defaultValue] - Returned when the block does not declare it.
  * @returns {any} The value.
  */
 export function blockProperty(fm: object, block: string, key: string, defaultValue?: any): any;
@@ -128,12 +129,10 @@ export function legacyKeyOf(field: {
 /**
  * The bare top-level key a `data:`-sourced field is being swept off — step 3b.
  *
- * `data:` did not invent the facts it holds; it *gathered* them, out of
- * the note's open top level where each was a sibling of `img` and `shortcode`.
- * So the retiring spelling of `data.portrait` is not a second declaration
- * anyone has to write — it is `portrait`, mechanically, and the same holds for
- * every other key that move relocated. Deriving it is what keeps the two
- * spellings of one field from disagreeing the way two declarations would.
+ * The retiring spelling of `data.portrait` is not a second declaration anyone
+ * has to write — it is `portrait`, mechanically, and the same holds for every
+ * other key the container gathered. Deriving it is what keeps the two spellings
+ * of one field from disagreeing the way two declarations would.
  *
  * **Only a `data.` source has one.** `protection.blunt` and `impact.die` are
  * paths into containers a note has always written at the top level; they were

package/types/engine/web-wikilinks.d.mts

@@ -97,7 +97,9 @@ export function frontmatterWikilinks(fm: unknown): Array<{
  *   resolves against. `src` is the page's display
  *   path and `file` the source file a diagnostic should name — absent, `src`
  *   stands in. `resolved`, when supplied, is the array every resolved
- *   target's index entry is appended to.
+ *   target's index entry is appended to. `anchors` is the `{#slug}` set
+ *   *this* page declares, which a `[[#slug]]` self-link is checked against;
+ *   absent, a self-link is not checked, exactly as before this existed.
  * @returns {string} The body with embeds and wikilinks rewritten.
  */
 export function resolveWebWikilinks(body: string, ctx: object): string;

package/types/hm3/actors.d.mts

@@ -27,9 +27,9 @@ export class Hm3Actors extends SystemActorCompiler {
     /**
      * Build every embedded item an HM3 actor carries, from `hm3.items`.
      *
-     * One list, not two: HM3 keeps a character's abilities in `system.abilities`
-     * rather than as embedded documents, so there is no attributes map to
-     * expand the way SoHL's pass expands `sohl.attributes`.
+     * HM3 keeps a character's abilities in `system.abilities` rather than as
+     * embedded documents, so an ability reaches the document through the
+     * `hm3.system` passthrough and never through this list.
      *
      * @param {Map<string, object>} itemsMap - The predefined items, by address.
      * @param {string} actorId - The owning actor's id, seeding embedded ids.

package/types/sohl/actors.d.mts

@@ -2,9 +2,8 @@
  * SoHL's Actor compile pass.
  *
  * Declares SoHL's note-type → document-subtype map and builds a `being` note's
- * document: the body structure and its movement profiles, the embedded
- * attribute and item documents the frontmatter names, and the `system` block.
- * Everything else is {@link module:engine/actor-compiler}'s.
+ * document: the embedded item documents the frontmatter names, and the `system`
+ * block. Everything else is {@link module:engine/actor-compiler}'s.
  */
 export class Actors extends SystemActorCompiler {
     /**
@@ -17,8 +16,8 @@ export class Actors extends SystemActorCompiler {
      */
     static documentSubtypes: import("../engine/document-subtypes.mjs").DocumentSubtypeMap;
     /**
-     * Build all embedded items for an actor: one per `sohl.attributes`
-     * entry plus one per `sohl.items` entry. `sohl.skills` is ignored.
+     * Build all embedded items for an actor: one per `sohl.items` entry, plus
+     * one per body the being belongs to.
      */
     buildEmbeddedItems(itemsMap: any, actorId: any, fm: any, ctx: any): object[];
     /**
@@ -57,8 +56,8 @@ export class Actors extends SystemActorCompiler {
      *
      * **The scores used are the ones just written.** `SkillLogic` resolves
      * `attr.<code>` to an attribute's *effective* score, after active effects;
-     * all this pass has is the `scoreBase` it set from `sohl.attributes`. For a
-     * compiled being carrying no attribute-altering effects the two agree,
+     * all this pass has is the `scoreBase` on each embedded attribute item. For
+     * a compiled being carrying no attribute-altering effects the two agree,
      * which is every being in content today. One that did carry such an effect
      * would bake a Skill Base its client then disagrees with — that is the
      * limit of doing this at build time, and the point to revisit if it bites.