@heroiclands/package-build 22.20.0 → 22.22.0

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/standing-terms.d.mts

@@ -0,0 +1,16 @@
+/**
+ * The note type a standing is held in.
+ *
+ * A standing is always held in a body: the entry is keyed by that body's
+ * Address, which is what lets the rung and the post be checked against what
+ * the body itself declares.
+ */
+export const STANDING_BODY_TYPES: readonly string[];
+/**
+ * The two keys one standing carries.
+ *
+ * `rank` is the level on the body's own `governance.ranks` ladder, as a number.
+ * `office` is a key of its `governance.offices` map, as a string. Both are
+ * optional — a membership with neither is the ordinary shape.
+ */
+export const STANDING_KEYS: readonly string[];

package/types/engine/standings.d.mts

@@ -0,0 +1,147 @@
+/**
+ * The standings a being authored, in one shape whichever shape it wrote.
+ *
+ * The list form names bodies and no standings; the map form names both. Three
+ * spellings reach here and every reader downstream takes the same entries, so
+ * none of them asks which it was handed:
+ *
+ * - an **{@link AddressEntries}** — the map after the note boundary decoded its
+ *   keys into typed Addresses, which is the shape every compile sees;
+ * - a **plain map**, which is the shape a checker reading raw YAML sees;
+ * - a **list**, which names bodies and says nothing about standing in them.
+ *
+ * An emptied map arrives from the property editor as `[]` and means what `{}`
+ * means — this being authors no membership — so both read as no entries.
+ *
+ * Each entry carries `body` for a message and `sourceKey` for a position: the
+ * authored key is what a reader has to find in the file, and the decoded
+ * Address is what a finding should name.
+ *
+ * @param {unknown} value - The authored `data.affiliations`.
+ * @returns {{form: "absent"|"list"|"map"|"malformed",
+ *   entries: Array<{body: unknown, sourceKey: string|number, standing: unknown}>}}
+ *   The form it was written in, and its entries.
+ */
+export function readStandings(value: unknown): {
+    form: "absent" | "list" | "map" | "malformed";
+    entries: Array<{
+        body: unknown;
+        sourceKey: string | number;
+        standing: unknown;
+    }>;
+};
+/**
+ * The rungs an affiliation's ladder declares, as level → title.
+ *
+ * A rung states its own `level`, so the ladder is read by that number rather
+ * 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.
+ */
+export function rankLadder(ranks: unknown): Map<number, string>;
+/**
+ * The offices an affiliation names, as key → description.
+ *
+ * An office is authored either as a bare description or as a `{description,
+ * holders}` map, and a reader of the post's name wants the same string from
+ * both.
+ *
+ * @param {unknown} offices - An affiliation's `data.governance.offices`.
+ * @returns {Map<string, string>} Office key → its description.
+ */
+export function officeRoster(offices: unknown): Map<string, string>;
+/**
+ * The anchor an office's row is addressed by.
+ *
+ * Declared once, because the row that carries the anchor and the link that
+ * reaches it are drawn by different passes: two spellings of the same
+ * derivation is a link into a page that offers no such destination.
+ *
+ * An office whose name reduces to nothing URL-safe has no anchor, and the
+ * caller is the one that can say what to do without one.
+ *
+ * @param {string} office - The office's key, as the body wrote it.
+ * @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.
+ *
+ * A reference's value answers what was found as well as where it is — the same
+ * reason a target's `subType` travels with it. A standing is read on the
+ * *being*, and what it is called is declared on the *body*, so the ladder and
+ * the office roster ride along to the one place that needs them.
+ *
+ * Nothing rides for a note that declares neither.
+ *
+ * @param {object} fm - The affiliation note's frontmatter.
+ * @returns {{ranks?: Record<string, string>, offices?: Record<string, string>}|undefined}
+ *   What a reference carries, or nothing.
+ */
+export function standingsDigest(fm: object): {
+    ranks?: Record<string, string>;
+    offices?: Record<string, string>;
+} | undefined;
+/**
+ * How a standing reads beside the body that confers it.
+ *
+ * The office leads, because it is the more particular of the two: a reader
+ * meeting "War Chief" has been told the rung as well. The body closes the
+ * phrase, which is the whole point of keying the entry by it — a standing with
+ * no body named is the lossy form.
+ *
+ * No article is supplied. One body's name reads with a "the" in front of it and
+ * the next does not, and inventing one is this build editing the corpus.
+ *
+ * @param {object} standing - `{rank, office}`, either or both absent.
+ * @param {string} body - What the body is called.
+ * @param {{ranks?: Record<string, string>}} [digest] - The body's ladder.
+ * @returns {string} The phrase, or the body's name where no standing is held.
+ */
+export function standingPhrase(standing: object, body: string, digest?: {
+    ranks?: Record<string, string>;
+}): string;
+/**
+ * Validate a being's memberships and the standing it holds in each.
+ *
+ * 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. 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
+ * at it rather than on a list somebody has to remember to edit.
+ *
+ * @param {object} note - The note.
+ * @param {{index?: object}} [options] - The lint's options.
+ * @returns {object[]} Located findings.
+ */
+export function checkStandings(note: object, { index }?: {
+    index?: object;
+}): object[];
+import { STANDING_BODY_TYPES } from "./standing-terms.mjs";
+import { STANDING_KEYS } from "./standing-terms.mjs";
+export { STANDING_BODY_TYPES, STANDING_KEYS };

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/engine/wikilinks.d.mts

@@ -133,7 +133,7 @@ export function convertWikilinks(markdown: string, { type, id, pack, docPack, in
  * @param {object} index - From {@link buildWikilinkIndex}.
  * @param {unknown} ref - The reference, as authored.
  * @param {object} [hint] - `{type}`, where the caller knows what it expects.
- * @returns {{name?: string, uuid?: string, address?: import("./address.mjs").AddressTuple, subType?: string}|undefined}
+ * @returns {{name?: string, uuid?: string, address?: import("./address.mjs").AddressTuple, subType?: string, standings?: object}|undefined}
  *   The target, or `undefined` where nothing answers.
  */
 export function resolveReference(index: object, ref: unknown, hint?: object): {
@@ -141,6 +141,7 @@ export function resolveReference(index: object, ref: unknown, hint?: object): {
     uuid?: string;
     address?: import("./address.mjs").AddressTuple;
     subType?: string;
+    standings?: object;
 } | undefined;
 import { ITEM_PACK } from "./ids.mjs";
 import { PACK_BY_TYPE } from "./ids.mjs";

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,10 +16,29 @@ 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[];
+    /**
+     * One embedded affiliation item per body the being belongs to.
+     *
+     * The body's own compiled item is the model, so a membership carries
+     * whatever that body declares — its subtype, its common skills, its
+     * standings toward others — and the being adds only what is true of *this*
+     * membership: the rung it stands on and the post it holds.
+     *
+     * A being naming a body that compiles to no item is a finding rather than a
+     * silently dropped membership: the note says the being belongs somewhere,
+     * and a sheet that shows nothing says it does not.
+     *
+     * @param {Map<string, object>} itemsMap - The predefined-item catalogue.
+     * @param {string} actorId - The owning actor's id.
+     * @param {object} fm - The note's frontmatter.
+     * @param {string} ctx - Diagnostic context.
+     * @returns {object[]} The embedded items, in the order the note names them.
+     */
+    buildMemberships(itemsMap: Map<string, object>, actorId: string, fm: object, ctx: string): object[];
     /**
      * Bake each unopened skill's opening mastery level into the document.
      *
@@ -38,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.

package/engine/content-admonitions.mjs

@@ -1,114 +0,0 @@
-/* SPDX-License-Identifier: GPL-3.0-or-later */
-
-import MarkdownIt from "markdown-it";
-import footnotePlugin from "markdown-it-footnote";
-import deflistPlugin from "markdown-it-deflist";
-import { parseExtensionAttributes } from "./extension-attributes.mjs";
-
-const parser = new MarkdownIt({ html: true }).use(footnotePlugin).use(deflistPlugin);
-const OPEN = /^:::(info|warn)(?:\s+(.*))?\s*$/;
-const CLOSE = /^:::\s*$/;
-const STYLES = Object.freeze({
-    info: { label: "Info", icon: "ℹ", color: "#2f6f9f", background: "#eef6fb" },
-    warn: { label: "Warning", icon: "⚠", color: "#9a6700", background: "#fff5db" },
-});
-
-/** Find inline info and warning blocks without interpreting code examples. */
-export function scanAdmonitions(source) {
-    const lines = String(source ?? "").split("\n");
-    const blocks = [];
-    const errors = [];
-    let opening = null;
-    let codeFence = null;
-    for (let i = 0; i < lines.length; i++) {
-        const line = lines[i];
-        const fence = /^ {0,3}(`{3,}|~{3,})/.exec(line);
-        if (codeFence) {
-            if (fence && fence[1][0] === codeFence[0] && fence[1].length >= codeFence.length)
-                codeFence = null;
-            continue;
-        }
-        if (fence) {
-            codeFence = fence[1];
-            continue;
-        }
-        const open = OPEN.exec(line);
-        if (open) {
-            if (opening) {
-                errors.push({
-                    line: i + 1,
-                    column: 1,
-                    message: "nested info and warning blocks are not supported",
-                });
-                continue;
-            }
-            const raw = open[2]?.trim() ?? "";
-            let id = "";
-            if (raw) {
-                if (!/^\{[^}\n]*\}$/.test(raw))
-                    errors.push({
-                        line: i + 1,
-                        column: 1,
-                        message: "block attributes need {#id} syntax",
-                    });
-                else {
-                    const attrs = parseExtensionAttributes(raw.slice(1, -1));
-                    id = attrs.id;
-                    for (const message of attrs.problems)
-                        errors.push({ line: i + 1, column: 1, message });
-                    if (attrs.classes.length || Object.keys(attrs.values).length)
-                        errors.push({
-                            line: i + 1,
-                            column: 1,
-                            message: "info and warn accept only an id",
-                        });
-                }
-            }
-            opening = { start: i, kind: open[1], id };
-            continue;
-        }
-        if (CLOSE.test(line) && opening) {
-            const body = lines
-                .slice(opening.start + 1, i)
-                .join("\n")
-                .trim();
-            if (!body)
-                errors.push({
-                    line: opening.start + 1,
-                    column: 1,
-                    message: `${opening.kind} block is empty`,
-                });
-            blocks.push({ ...opening, end: i, body });
-            opening = null;
-        }
-    }
-    if (opening)
-        errors.push({
-            line: opening.start + 1,
-            column: 1,
-            message: `${opening.kind} block needs a closing ::: line`,
-        });
-    return { blocks, errors };
-}
-
-/** Render info and warning blocks as styled, labelled HTML. */
-export function renderAdmonitions(source, renderMarkdown = parser.render.bind(parser)) {
-    const { blocks, errors } = scanAdmonitions(source);
-    if (errors.length) return { markdown: source, errors };
-    const lines = String(source ?? "").split("\n");
-    const output = [];
-    let cursor = 0;
-    for (const block of blocks) {
-        const style = STYLES[block.kind];
-        output.push(...lines.slice(cursor, block.start));
-        output.push(
-            `<aside${block.id ? ` id="${block.id}"` : ""} class="sohl-admonition sohl-admonition-${block.kind}" style="border-left: 3px solid ${style.color}; background: ${style.background}; padding: 0.5em 0.8em; margin: 0.75em 0;">`,
-            `<p><strong><span aria-hidden="true">${style.icon}</span> ${style.label}</strong></p>`,
-            renderMarkdown(block.body).trim(),
-            "</aside>",
-        );
-        cursor = block.end + 1;
-    }
-    output.push(...lines.slice(cursor));
-    return { markdown: output.join("\n"), errors: [] };
-}

package/engine/content-secrets.mjs

@@ -1,112 +0,0 @@
-/*
- * SPDX-License-Identifier: GPL-3.0-or-later
- */
-
-import crypto from "node:crypto";
-import markdownit from "markdown-it";
-import footnotePlugin from "markdown-it-footnote";
-import deflistPlugin from "markdown-it-deflist";
-
-const webMarkdown = markdownit({ html: true }).use(footnotePlugin).use(deflistPlugin);
-
-/**
- * Render whole-line `:::secret` blocks for one publishing surface.
- * The source line of each syntax error is relative to the supplied body.
- *
- * @param {string} source - Markdown containing secret blocks.
- * @param {"foundry"|"web"|"book"} target - Publishing surface.
- * @param {(markdown: string) => string} [renderMarkdown] - Foundry's configured renderer.
- * @returns {{markdown: string, errors: Array<{line: number, column: number, message: string}>}}
- */
-export function renderSecretBlocks(
-    source,
-    target,
-    renderMarkdown = webMarkdown.render.bind(webMarkdown),
-) {
-    const lines = String(source ?? "").split("\n");
-    const result = [];
-    const errors = [];
-    let opening = -1;
-    let body = [];
-    let codeFence = null;
-
-    for (let index = 0; index < lines.length; index++) {
-        const line = lines[index];
-        const fence = line.match(/^ {0,3}(`{3,}|~{3,})/);
-        if (codeFence) {
-            if (fence && fence[1][0] === codeFence[0] && fence[1].length >= codeFence.length) {
-                codeFence = null;
-            }
-            if (opening >= 0) body.push(line);
-            else result.push(line);
-            continue;
-        }
-        if (fence) {
-            codeFence = fence[1];
-            if (opening >= 0) body.push(line);
-            else result.push(line);
-            continue;
-        }
-        if (/^:::secret[ \t]*$/.test(line)) {
-            if (opening >= 0) {
-                errors.push({
-                    line: index + 1,
-                    column: 1,
-                    message: "nested secret blocks are not supported",
-                });
-                body.push(line);
-            } else {
-                opening = index;
-                body = [];
-            }
-            continue;
-        }
-        if (/^:::[ \t]*$/.test(line)) {
-            if (opening < 0) {
-                errors.push({
-                    line: index + 1,
-                    column: 1,
-                    message: "secret block has no opening :::secret line",
-                });
-                result.push(line);
-                continue;
-            }
-            const inner = body.join("\n").trim();
-            if (target === "book") {
-                result.push("", "**GM note**", "", inner, "");
-            } else {
-                const html = renderMarkdown(inner).trim();
-                if (target === "foundry") {
-                    const id = crypto
-                        .createHash("sha256")
-                        .update(`${opening}:${inner}`)
-                        .digest("hex")
-                        .slice(0, 12);
-                    result.push(
-                        "",
-                        `<section class="secret" id="secret-${id}">`,
-                        html,
-                        "</section>",
-                        "",
-                    );
-                } else {
-                    result.push("", "<details><summary>Spoiler</summary>", html, "</details>", "");
-                }
-            }
-            opening = -1;
-            body = [];
-            continue;
-        }
-        if (opening >= 0) body.push(line);
-        else result.push(line);
-    }
-    if (opening >= 0) {
-        errors.push({
-            line: opening + 1,
-            column: 1,
-            message: "secret block needs a closing ::: line",
-        });
-        result.push(":::secret", ...body);
-    }
-    return { markdown: result.join("\n"), errors };
-}