@heroiclands/package-build 20.5.0 → 20.7.0

package/CHANGELOG.md

@@ -1,5 +1,39 @@
 # @heroiclands/package-build
 
+## 20.7.0
+
+### Minor Changes
+
+- 6c10f17: **A `trees` entry's pages stay where their tree mounts them** — declaring
+  `subType` on a note inside `site.trees` no longer moves its published address.
+  A `subType` classifies a page for the site index; it never routed a tree
+  page's URL to begin with for a note that left it unset, and now it does not
+  for one that sets it either. A site that already worked around this by
+  avoiding `subType` on its tree notes can declare it again: those pages move
+  back under the tree's own section on upgrade.
+
+### Patch Changes
+
+- 72daae4: **A being that declares no `sohl:` block no longer takes the site build down.**
+  `content-build site` failed with `unacceptable kind of an object to dump [object
+  Undefined]` for any `type: being` note whose front matter carried no `sohl:` key
+  at all, and the throw aborted the entire run rather than the one page. A note
+  carrying `sohl: null` had always been fine, so the failure only appeared once a
+  tree removed the empty key rather than emptying it. Both shapes now publish the
+  same page. Fixes HeroicLands/package-build#478.
+
+## 20.6.0
+
+### Minor Changes
+
+- a2742cc: **PDF book outline** — a book's printed table of contents now lists only the
+  sections its document tree declares; every note stays reachable from the PDF
+  bookmarks panel, titled from its own name, without also cluttering the printed
+  contents. A note's own body headings never surface on either surface, so a note
+  opening with a heading that repeats its own title no longer shows a duplicate
+  entry in the sidebar. Every heading — printed, bookmarked or neither — is still
+  a working link target, including one an author never gave an explicit anchor.
+
 ## 20.5.0
 
 ### Minor Changes

package/docs/api.md

@@ -714,16 +714,16 @@ The document tree a PDF is built from, and the plan it resolves to (#316). The p
 
 A note's markdown, and a document plan, rendered as Typst source. **This module emits text and reads nothing.** It takes markdown and a plan and returns a `.typ` document; the filesystem, the note bodies and the compiler that turns the result into a PDF all live in {@link module:engine/pdf-build}. That split is what lets the outline, the table of contents, every anchor and every link destination be asserted in a unit test with no renderer installed — which is most of what a book has to get right, and all of what a test can check without eyes.
 
-| Export                  | Signature                                                                        | Returns                                                      | Use it when                                                              |
-| ----------------------- | -------------------------------------------------------------------------------- | ------------------------------------------------------------ | ------------------------------------------------------------------------ |
-| `escapeTypst`           | `function escapeTypst(text)`                                                     | {string} The same text, inert.                               | Escape literal text for Typst markup.                                    |
-| `escapeTypstString`     | `function escapeTypstString(text)`                                               | {string} The same value, quotable.                           | Escape a string going inside Typst string quotes, as a `#link` URL does. |
-| `labelFor`              | `function labelFor(anchor)`                                                      | {string} A Typst label name.                                 | A Typst label, from a plan anchor.                                       |
-| `createParser`          | `function createParser(registry)`                                                | {object} A markdown-it instance.                             | A markdown-it configured to parse, not to render.                        |
-| `markdownToTypst`       | `function markdownToTypst(markdown, opts`                                        | {string} Typst markup.                                       | Render markdown as Typst content.                                        |
-| `renderBook`            | `renderBook({ plan, bodies, title, subtitle, front, fonts, tocDepth, version })` | {string} A complete `.typ` document.                         | The whole book, as one Typst document.                                   |
-| `resolveDanglingLabels` | `function resolveDanglingLabels(source, findings`                                | {string} The same document, with no reference left dangling. | Point every internal link at a label the document actually declares.     |
-| `iconNamesIn`           | `function iconNamesIn(markdown)`                                                 | {string[]} The names, in order of appearance, with repeats.  | Every icon name a body uses, so a build can resolve them once.           |
+| Export                  | Signature                                                              | Returns                                                      | Use it when                                                              |
+| ----------------------- | ---------------------------------------------------------------------- | ------------------------------------------------------------ | ------------------------------------------------------------------------ |
+| `escapeTypst`           | `function escapeTypst(text)`                                           | {string} The same text, inert.                               | Escape literal text for Typst markup.                                    |
+| `escapeTypstString`     | `function escapeTypstString(text)`                                     | {string} The same value, quotable.                           | Escape a string going inside Typst string quotes, as a `#link` URL does. |
+| `labelFor`              | `function labelFor(anchor)`                                            | {string} A Typst label name.                                 | A Typst label, from a plan anchor.                                       |
+| `createParser`          | `function createParser(registry)`                                      | {object} A markdown-it instance.                             | A markdown-it configured to parse, not to render.                        |
+| `markdownToTypst`       | `function markdownToTypst(markdown, opts`                              | {string} Typst markup.                                       | Render markdown as Typst content.                                        |
+| `renderBook`            | `renderBook({ plan, bodies, title, subtitle, front, fonts, version })` | {string} A complete `.typ` document.                         | The whole book, as one Typst document.                                   |
+| `resolveDanglingLabels` | `function resolveDanglingLabels(source, findings`                      | {string} The same document, with no reference left dangling. | Point every internal link at a label the document actually declares.     |
+| `iconNamesIn`           | `function iconNamesIn(markdown)`                                       | {string[]} The names, in order of appearance, with repeats.  | Every icon name a body uses, so a build can resolve them once.           |
 
 ### `engine.pdfFonts`
 

package/engine/pdf-render.mjs

@@ -64,6 +64,7 @@
 import MarkdownIt from "markdown-it";
 
 import { iconPlugin, ICON_PATTERN } from "./content-icons.mjs";
+import { slugify } from "./content-slug.mjs";
 
 /**
  * Characters that mean something to Typst's markup parser.
@@ -170,7 +171,11 @@ export function markdownToTypst(markdown, opts = {}) {
         anchorPrefix = "",
     } = opts;
     const tokens = md.parse(String(markdown ?? ""), {});
-    return renderTokens(tokens, { links, glyphs, headingOffset, anchorPrefix });
+    // One map for the whole body, not one per block: a heading inside a
+    // blockquote or a list item shares the entry's anchor namespace with every
+    // other heading in the same body, because `sectionLabel` scopes by entry
+    // rather than by container.
+    return renderTokens(tokens, { links, glyphs, headingOffset, anchorPrefix, seen: new Map() });
 }
 
 /**
@@ -209,15 +214,26 @@ function renderBlock(tokens, i, out, ctx) {
             // Typst caps headings at a depth no book reaches by accident; going
             // past it would be a compile error in the middle of a 2,500-entry
             // run, so it clamps and keeps setting.
-            const level = Math.min(6, Number(token.tag.slice(1)) + ctx.headingOffset);
+            const level = Math.max(1, Math.min(6, Number(token.tag.slice(1)) + ctx.headingOffset));
             const inline = tokens[i + 1];
             // `## Appearance {#appearance}` declares an addressable section. The
             // journals compiler strips the suffix and surfaces it as an anchor;
             // so does this, because a book that printed the braces would show
             // every reader the markup that makes a link work.
             const { text, anchor } = splitHeadingAnchor(inline, ctx);
-            const label = anchor ? ` <${sectionLabel(ctx.anchorPrefix, anchor)}>` : "";
-            out.push(`\n${"=".repeat(Math.max(1, level))} ${text}${label}\n\n`);
+            // A heading with no authored anchor still needs a link target, so one
+            // is derived from its own text. `anchorFor` keeps it from colliding
+            // with an authored anchor, or with another derived one, that lands on
+            // the same words later in the same entry.
+            const base = anchor || slugify(plainHeadingText(inline)) || "heading";
+            const unique = anchorFor(base, ctx.seen);
+            const label = ` <${sectionLabel(ctx.anchorPrefix, unique)}>`;
+            // A body heading is never printed and never bookmarked — it is
+            // structure a reader reaches only by following a link, not a
+            // destination either outline offers on its own.
+            out.push(
+                `\n#heading(level: ${level}, outlined: false, bookmarked: false)[${text}]${label}\n\n`,
+            );
             return 3;
         }
         case "paragraph_open": {
@@ -285,6 +301,44 @@ function splitHeadingAnchor(inline, ctx) {
     return { text: renderInline({ ...inline, children }, ctx), anchor: match[2] };
 }
 
+/**
+ * A heading's text, unescaped and with any `{#anchor}` suffix still attached.
+ *
+ * Used only to derive an anchor when the author wrote none, so it wants the
+ * words as typed rather than the Typst-escaped, suffix-stripped text
+ * {@link splitHeadingAnchor} renders — {@link module:engine/content-slug.slugify}
+ * normalises punctuation and case itself and has no use for an escape
+ * backslash.
+ *
+ * @param {object} inline - The heading's `inline` token.
+ * @returns {string} The heading's raw text.
+ */
+function plainHeadingText(inline) {
+    const children = inline?.children ?? [];
+    return children.map((child) => child.content ?? "").join("");
+}
+
+/**
+ * A unique anchor within one render pass, suffixed when the base repeats.
+ *
+ * A derived anchor is only as good as its uniqueness: two headings reading
+ * "Notes" in one entry, or a derived "description" landing on an author's own
+ * `{#description}`, would otherwise give one label two meanings. First use of
+ * a base anchor keeps it exactly as written or slugified; every later use in
+ * the same body is suffixed, in the order headings are walked — which is
+ * stable across rebuilds because the body's markdown is.
+ *
+ * @param {string} base - The preferred anchor.
+ * @param {Map<string, number>} seen - How many times each base has been used,
+ *   scoped to one call to {@link markdownToTypst}.
+ * @returns {string} The anchor.
+ */
+function anchorFor(base, seen) {
+    const n = (seen.get(base) ?? 0) + 1;
+    seen.set(base, n);
+    return n === 1 ? base : `${base}-${n}`;
+}
+
 /**
  * A label for an anchor declared inside a note.
  *
@@ -612,25 +666,39 @@ function renderIcon(token, ctx) {
  * with no filesystem and no compiler. {@link module:engine/pdf-build} supplies
  * both and runs Typst over the result.
  *
- * ## Two outlines, and why they are not the same outline
+ * ## Three surfaces, one heading tree
  *
  * A roster of 2,500 entries wants every entry reachable from a viewer's
  * sidebar, and emphatically does not want all 2,500 printed in the front
- * matter: that is forty pages of contents before the book starts.
- *
- * Typst separates the two for us. **The PDF bookmark outline is built from
- * every heading**, so each entry gets its own node at its own depth for free
- * and the sidebar is the navigational interface the issue asks for.
- * **`#outline()` prints only to `tocDepth`**, so the paper table of contents
- * stays the sections. Both are page-numbered and both are links.
+ * matter: that is forty pages of contents before the book starts. It also
+ * wants every heading in a note's own body to keep working as a link target,
+ * without appearing on either surface — the anchor an author writes for
+ * `[[note#appearance]]` is structure, not a destination either outline offers
+ * on its own.
+ *
+ * `heading` carries `outlined` and `bookmarked` independently, so the three
+ * wants are three settings rather than three passes:
+ *
+ * - A **section** — `outlined: true, bookmarked: true` — prints in the paper
+ *   contents and the PDF sidebar alike.
+ * - A **note leaf**, titled from `name.full`, is `outlined: false,
+ *   bookmarked: true`: reachable from the sidebar, absent from the printed
+ *   contents.
+ * - A **body heading**, inside a note's own markdown, is `outlined: false,
+ *   bookmarked: false`: a real heading with a label, so it still supplies a
+ *   link target, a running head and a page break, but neither outline lists
+ *   it. {@link markdownToTypst} emits these.
+ *
+ * `#outline()` needs no depth limit under this model: what prints is decided
+ * per heading, not by how deep the tree happens to go.
  *
  * ## Headings carry the structure, so nothing else has to
  *
  * Every section, every prose file and every entry is a real Typst heading at
- * its plan depth. That single decision supplies the bookmarks, the printed
- * contents, the running heads and the page breaks at once — where drawing
- * titles as styled text would have meant building all four by hand and keeping
- * them agreeing with each other.
+ * its plan depth. That single decision supplies both outlines, the running
+ * heads and the page breaks at once — where drawing titles as styled text
+ * would have meant building all four by hand and keeping them agreeing with
+ * each other.
  *
  * @param {object} opts - Options.
  * @param {object} opts.plan - From {@link module:engine/pdf-toc.planDocument}.
@@ -640,7 +708,6 @@ function renderIcon(token, ctx) {
  * @param {string} [opts.subtitle] - Shown under it on the title page.
  * @param {string[]} [opts.front] - Rendered Typst for each front-matter file.
  * @param {object} [opts.fonts] - `{ serif, sans, mono }` family names.
- * @param {number} [opts.tocDepth] - How deep the *printed* contents go.
  * @param {string} [opts.version] - Stamped on the title page when given.
  * @returns {string} A complete `.typ` document.
  */
@@ -651,7 +718,6 @@ export function renderBook({
     subtitle = "",
     front = [],
     fonts = {},
-    tocDepth = 2,
     version = "",
 } = {}) {
     const serif = fonts.serif || "Libertinus Serif";
@@ -700,7 +766,9 @@ export function renderBook({
         out.push("");
     }
 
-    out.push(`#outline(title: [Contents], depth: ${Math.max(1, Number(tocDepth) || 2)})`);
+    // No `depth:` limit: what prints is decided per heading by `outlined`,
+    // below, not by how deep the plan's tree happens to go.
+    out.push("#outline(title: [Contents])");
     out.push("#pagebreak()");
     out.push("");
 
@@ -708,7 +776,12 @@ export function renderBook({
         const label = labelFor(entry.anchor);
         const depth = Math.min(6, Math.max(1, Number(entry.depth) || 1));
         if (entry.kind === "section") {
-            out.push(`${"=".repeat(depth)} ${escapeTypst(entry.title)} <${label}>`);
+            // A declared `sectionName:` — the structure the printed contents
+            // shows and the bookmarks panel shows alongside it.
+            out.push(
+                `#heading(level: ${depth}, outlined: true, bookmarked: true)` +
+                    `[${escapeTypst(entry.title)}] <${label}>`,
+            );
             out.push("");
             continue;
         }
@@ -721,8 +794,13 @@ export function renderBook({
             out.push("");
             continue;
         }
+        // A note leaf: reachable from the bookmarks panel, titled from
+        // `name.full`, and never printed in the paper contents.
         const name = entry.record?.name?.full ?? entry.record?.address?.slug ?? "(untitled)";
-        out.push(`${"=".repeat(Math.min(6, depth + 1))} ${escapeTypst(name)} <${label}>`);
+        out.push(
+            `#heading(level: ${Math.min(6, depth + 1)}, outlined: false, bookmarked: true)` +
+                `[${escapeTypst(name)}] <${label}>`,
+        );
         out.push("");
         const body = bodies.get(entry.anchor);
         if (body) {

package/engine/site-build.mjs

@@ -267,6 +267,14 @@ export function collectContentPages(contentBase, ctx) {
  * addressed by type and slug: they are a book with chapters, and a reader
  * follows their paths. A `README` is its directory's landing.
  *
+ * **The section is the tree's, never the note's.** `tree.section` is the
+ * mount point a `trees` entry configures — fixed, physical, and the same
+ * value `site-index.mjs` indexes a tree page's address under. A note's own
+ * `subType` is a genre and reaches no address, the same contract
+ * `packageAddress()` holds for a content page: reading it here would move a
+ * page's URL, its file destination (`pageDestination`) and the address a
+ * wikilink cites it by, every time an author classified it.
+ *
  * @param {object} tree - `{ from, rel, section, route }`.
  * @param {object} ctx - `{ mount }`.
  * @returns {{pages: object[], fmLinkFindings: object[]}}
@@ -287,7 +295,7 @@ export function collectTreePages(tree, ctx) {
         const rel = path.relative(tree.from, file).replace(/\\/g, "/");
         const base = path.basename(rel);
         const isReadme = base.toLowerCase() === "readme.md";
-        const sec = fm.subType ?? tree.section;
+        const sec = tree.section;
         const h1 = /^#\s+(.+?)\s*$/m.exec(body);
         const h1Title = h1 ? h1[1].replace(/\{@link\s+[^}]*\}/g, "").trim() : null;
         const name = fm.name?.full ?? fm.title ?? h1Title ?? path.basename(base, ".md");

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@heroiclands/package-build",
-    "version": "20.5.0",
+    "version": "20.7.0",
     "description": "Shared toolchain for building and shipping a HeroicLands Foundry VTT package — content compilation, manifest, localization, staging, bundle, release and deployment.",
     "license": "GPL-3.0-or-later",
     "type": "module",
@@ -154,6 +154,7 @@
     "devDependencies": {
         "@changesets/cli": "^3.0.0",
         "@types/node": "^26.2.0",
+        "npm-run-all": "^4.1.5",
         "vitest": "^5.0.0"
     },
     "scripts": {
@@ -163,7 +164,7 @@
         "build:types": "tsc -p tsconfig.dts.json",
         "format": "prettier --write .",
         "format:check": "prettier --check .",
-        "lint": "npm run format:check && npm run lint:markdown && npm run lint:yaml && npm run lint:labels && npm run lint:content-format",
+        "lint": "run-p --aggregate-output -c --max-parallel 4 format:check lint:markdown lint:yaml lint:labels lint:content-format",
         "lint:markdown": "node bin/content-build.mjs markdown",
         "lint:yaml": "node bin/package-build.mjs yaml",
         "lint:labels": "node bin/package-build.mjs labels check",

package/sohl/being-info.mjs

@@ -108,11 +108,17 @@ const nonEmpty = (v) => Array.isArray(v) && v.length > 0;
  * @param {object|null|undefined} sohl - The note's `sohl` frontmatter block.
  * @param {Map<string, {name?: string, url?: string}>} index - Content index,
  *   `"<type>:<shortcode>"` → the item's page.
- * @returns {object|null|undefined} The block with its info-block fields filled
- *   in, or the input unchanged when there is nothing to derive from.
+ * @returns {object|null} The block with its info-block fields filled in, or the
+ *   input unchanged when there is nothing to derive from — with an absent block
+ *   reported as `null`, the value an empty one already carries.
  */
 export function deriveBeingInfo(sohl, index) {
-    if (!isMap(sohl)) return sohl;
+    // A note declaring no `sohl:` key at all arrives as `undefined`, and the
+    // site emitter assigns this result straight into a page's front matter.
+    // js-yaml refuses to dump a property whose value is `undefined`, and the
+    // throw aborts the whole build rather than the one page — so "no block"
+    // is answered with the same `null` an empty block gets.
+    if (!isMap(sohl)) return sohl ?? null;
     const out = { ...sohl };
     const items = Array.isArray(out.items) ? out.items : [];
     if (items.length === 0) return out;

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

@@ -70,25 +70,39 @@ export function markdownToTypst(markdown: string, opts?: {
  * with no filesystem and no compiler. {@link module:engine/pdf-build} supplies
  * both and runs Typst over the result.
  *
- * ## Two outlines, and why they are not the same outline
+ * ## Three surfaces, one heading tree
  *
  * A roster of 2,500 entries wants every entry reachable from a viewer's
  * sidebar, and emphatically does not want all 2,500 printed in the front
- * matter: that is forty pages of contents before the book starts.
- *
- * Typst separates the two for us. **The PDF bookmark outline is built from
- * every heading**, so each entry gets its own node at its own depth for free
- * and the sidebar is the navigational interface the issue asks for.
- * **`#outline()` prints only to `tocDepth`**, so the paper table of contents
- * stays the sections. Both are page-numbered and both are links.
+ * matter: that is forty pages of contents before the book starts. It also
+ * wants every heading in a note's own body to keep working as a link target,
+ * without appearing on either surface — the anchor an author writes for
+ * `[[note#appearance]]` is structure, not a destination either outline offers
+ * on its own.
+ *
+ * `heading` carries `outlined` and `bookmarked` independently, so the three
+ * wants are three settings rather than three passes:
+ *
+ * - A **section** — `outlined: true, bookmarked: true` — prints in the paper
+ *   contents and the PDF sidebar alike.
+ * - A **note leaf**, titled from `name.full`, is `outlined: false,
+ *   bookmarked: true`: reachable from the sidebar, absent from the printed
+ *   contents.
+ * - A **body heading**, inside a note's own markdown, is `outlined: false,
+ *   bookmarked: false`: a real heading with a label, so it still supplies a
+ *   link target, a running head and a page break, but neither outline lists
+ *   it. {@link markdownToTypst} emits these.
+ *
+ * `#outline()` needs no depth limit under this model: what prints is decided
+ * per heading, not by how deep the tree happens to go.
  *
  * ## Headings carry the structure, so nothing else has to
  *
  * Every section, every prose file and every entry is a real Typst heading at
- * its plan depth. That single decision supplies the bookmarks, the printed
- * contents, the running heads and the page breaks at once — where drawing
- * titles as styled text would have meant building all four by hand and keeping
- * them agreeing with each other.
+ * its plan depth. That single decision supplies both outlines, the running
+ * heads and the page breaks at once — where drawing titles as styled text
+ * would have meant building all four by hand and keeping them agreeing with
+ * each other.
  *
  * @param {object} opts - Options.
  * @param {object} opts.plan - From {@link module:engine/pdf-toc.planDocument}.
@@ -98,18 +112,16 @@ export function markdownToTypst(markdown: string, opts?: {
  * @param {string} [opts.subtitle] - Shown under it on the title page.
  * @param {string[]} [opts.front] - Rendered Typst for each front-matter file.
  * @param {object} [opts.fonts] - `{ serif, sans, mono }` family names.
- * @param {number} [opts.tocDepth] - How deep the *printed* contents go.
  * @param {string} [opts.version] - Stamped on the title page when given.
  * @returns {string} A complete `.typ` document.
  */
-export function renderBook({ plan, bodies, title, subtitle, front, fonts, tocDepth, version, }?: {
+export function renderBook({ plan, bodies, title, subtitle, front, fonts, version, }?: {
     plan: object;
     bodies: Map<string, string>;
     title: string;
     subtitle?: string | undefined;
     front?: string[] | undefined;
     fonts?: object | undefined;
-    tocDepth?: number | undefined;
     version?: string | undefined;
 }): string;
 /**

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

@@ -36,6 +36,14 @@ export function collectContentPages(contentBase: string, ctx: object): {
  * addressed by type and slug: they are a book with chapters, and a reader
  * follows their paths. A `README` is its directory's landing.
  *
+ * **The section is the tree's, never the note's.** `tree.section` is the
+ * mount point a `trees` entry configures — fixed, physical, and the same
+ * value `site-index.mjs` indexes a tree page's address under. A note's own
+ * `subType` is a genre and reaches no address, the same contract
+ * `packageAddress()` holds for a content page: reading it here would move a
+ * page's URL, its file destination (`pageDestination`) and the address a
+ * wikilink cites it by, every time an author classified it.
+ *
  * @param {object} tree - `{ from, rel, section, route }`.
  * @param {object} ctx - `{ mount }`.
  * @returns {{pages: object[], fmLinkFindings: object[]}}

package/types/sohl/being-info.d.mts

@@ -26,13 +26,14 @@ export function isBeing(fm: {
  * @param {object|null|undefined} sohl - The note's `sohl` frontmatter block.
  * @param {Map<string, {name?: string, url?: string}>} index - Content index,
  *   `"<type>:<shortcode>"` → the item's page.
- * @returns {object|null|undefined} The block with its info-block fields filled
- *   in, or the input unchanged when there is nothing to derive from.
+ * @returns {object|null} The block with its info-block fields filled in, or the
+ *   input unchanged when there is nothing to derive from — with an absent block
+ *   reported as `null`, the value an empty one already carries.
  */
 export function deriveBeingInfo(sohl: object | null | undefined, index: Map<string, {
     name?: string;
     url?: string;
-}>): object | null | undefined;
+}>): object | null;
 /**
  * The note `type` whose pages carry a being info block.
  *