@heroiclands/package-build 22.28.0 → 23.1.0

package/engine/journals.mjs

@@ -124,9 +124,15 @@ function namedBlockLines(markdown) {
  * calling that page "Introduction" would label the description as a preamble to
  * nothing.
  *
- * A figure fence carries its own record along onto the page it starts, as
- * `figure` — `null` for a page a heading started. {@link buildPages} reads it
- * to build the `image` or `text` page a fence begins; nothing else sets it.
+ * A captioned item's page holds the item alone, and carries the item's record
+ * as `figure` — `null` for every other page. {@link buildPages} reads it to
+ * build the `image` or `text` page; nothing else sets it. The page is named
+ * for the item's number, or else its caption's visible text.
+ *
+ * Body that follows an item, up to the next page opening, resumes in a
+ * **continuation** of the section the item interrupted: the section's name,
+ * level and classes, with `continues` naming the item it follows. A
+ * continuation holding nothing is not emitted.
  *
  * @param {string} body - Markdown body to split.
  * @param {string} [leadName] - Name of the page before the first heading.
@@ -135,8 +141,8 @@ function namedBlockLines(markdown) {
  *   name reads `Map 1` rather than `Figure 1` where it is due — see
  *   {@link module:engine/content-figures.scanFigures}.
  * @returns {Array<{name: string, anchorSlug: string|null, level: number,
- *   classes: string[], figure: object|null, markdown: string}>} Pages in
- *   document order.
+ *   classes: string[], figure: object|null, continues?: string,
+ *   markdown: string}>} Pages in document order.
  */
 export function splitPages(body, leadName = "Introduction", resolveRole) {
     const { markdown, definitions } = separateFootnotes(body);
@@ -150,16 +156,26 @@ export function splitPages(body, leadName = "Introduction", resolveRole) {
     const beforeFirstH1 = [];
     let current = null;
     let codeFence = null;
+    /** The page a heading last opened, which a captioned item interrupts. */
+    let section = { name: leadName, level: 1, classes: [] };
 
     const closeCurrent = () => {
         if (!current) return;
+        const markdown = current.lines.join("\n").trim();
+        // A continuation exists only to carry what follows its item; one
+        // holding nothing is not a page.
+        if (current.continues && !markdown) {
+            current = null;
+            return;
+        }
         pages.push({
             name: current.name,
             anchorSlug: current.anchorSlug,
             level: current.level,
             classes: current.classes,
             figure: current.figure ?? null,
-            markdown: current.lines.join("\n").trim(),
+            ...(current.continues ? { continues: current.continues } : {}),
+            markdown,
         });
         current = null;
     };
@@ -190,16 +206,32 @@ export function splitPages(body, leadName = "Introduction", resolveRole) {
         // lines it claims here are collected by `pageOpenings`, which also
         // skips a fence and a named block. A figure fence opens a page of its
         // own, named for the figure's label.
+        // A captioned item's page holds the item alone. The body after it
+        // resumes in a continuation of the section it interrupted, keyed on
+        // the item so its id holds still when pages move around it.
+        if (current?.figure && lineIndex > current.figure.close) {
+            const item = current.figure;
+            closeCurrent();
+            current = {
+                name: section.name,
+                anchorSlug: null,
+                level: section.level,
+                classes: section.classes,
+                continues: item.slug || item.label || captionPageName(item.caption),
+                lines: [],
+            };
+        }
+
         const opening = openings.get(lineIndex);
         const figure =
             !inCodeBlock && !blockLines.has(lineIndex) ? figureStarts.get(lineIndex) : null;
         if (figure) {
             closeCurrent();
             current = {
-                name: figure.label || figure.caption,
+                name: figure.label || captionPageName(figure.caption),
                 anchorSlug: figure.id || null,
                 level: 1,
-                classes: [],
+                classes: section.classes.includes(WITHHELD_CLASS) ? [WITHHELD_CLASS] : [],
                 figure,
                 lines: [line],
             };
@@ -214,6 +246,7 @@ export function splitPages(body, leadName = "Introduction", resolveRole) {
                 classes: opening.classes,
                 lines: [],
             };
+            section = current;
             continue;
         }
 
@@ -270,7 +303,18 @@ export function splitPages(body, leadName = "Introduction", resolveRole) {
 export function assertUniquePages(rawPages, noteName) {
     const anchors = new Set();
     const names = new Set();
+    const continuations = new Set();
     for (const page of rawPages) {
+        if (page.continues) {
+            const key = `${page.name}\u0000${page.continues}`;
+            if (continuations.has(key)) {
+                throw new Error(
+                    `note "${noteName}" has two captioned items both captioned "${page.continues}" in "${page.name}"; give one an {#anchor}`,
+                );
+            }
+            continuations.add(key);
+            continue;
+        }
         if (page.anchorSlug) {
             if (anchors.has(page.anchorSlug)) {
                 throw new Error(
@@ -321,16 +365,49 @@ export function assertUniqueAnchors(rawPages, noteName) {
  * a lint error. {@link assertUniquePages} states the same thing at compile
  * time, where the packer would otherwise report only an opaque duplicate key.
  *
+ * A continuation page shares its section's name, so it is keyed by that name
+ * and the captioned item it follows.
+ *
  * @param {string} entryId - The owning JournalEntry's `_id`.
- * @param {{anchorSlug: string|null, name: string}} page - From {@link splitPages}.
+ * @param {{anchorSlug: string|null, name: string, continues?: string}} page -
+ *   From {@link splitPages}.
  * @returns {string} A 16-character Foundry id.
  */
 export function journalPageId(entryId, page) {
-    return page.anchorSlug ?
-            anchorPageId(entryId, page.anchorSlug)
+    if (page.anchorSlug) return anchorPageId(entryId, page.anchorSlug);
+    return page.continues ?
+            makeId("journal-page", `${entryId}:${page.name}:after:${page.continues}`)
         :   makeId("journal-page", `${entryId}:${page.name}`);
 }
 
+/**
+ * The name of the page a caption begins: the caption's visible text.
+ *
+ * Foundry shows a page name as plain text, so a caption's markup — emphasis, a
+ * code span, a Markdown link, or the `@UUID[...]{label}` a resolved wikilink
+ * has already become, inside its wrapping `<span>` — reduces to the text a
+ * reader sees, the same text a reference to the caption displays. The markup
+ * itself stays in the page's content, where it renders.
+ *
+ * @param {string} caption - The figure's caption, as the journal pass sees it.
+ * @returns {string} Its visible text, whitespace collapsed.
+ */
+function captionPageName(caption) {
+    if (!caption) return "";
+    const [inline] = md.parseInline(caption, {});
+    const text = (inline?.children ?? [])
+        .map((token) =>
+            token.type === "text" || token.type === "code_inline" ? token.content
+            : token.type === "softbreak" || token.type === "hardbreak" ? " "
+            : "",
+        )
+        .join("");
+    return text
+        .replace(/@UUID\[[^\]]*\]\{([^}]*)\}/g, "$1")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+
 /**
  * Whether a caption carries markup an `image` page's `caption` field cannot
  * hold.
@@ -381,36 +458,13 @@ function soleFigurePicture(figure, page) {
     return IMAGE_EXTENSIONS.includes(extension) ? images[0].src : null;
 }
 
-/**
- * Whether a figure fence is the whole of the page {@link splitPages} gave it.
- *
- * A figure always starts a page of its own, but nothing closes one: trailing
- * prose before the next heading or figure stays on it, exactly as it would
- * behind an ordinary heading. An `image` page holds a `src` and a caption and
- * nowhere else to put that prose, so it is refused the type and kept a `text`
- * page, where the prose renders after the figure's own div as it always has.
- *
- * @param {object} figure - The figure record.
- * @param {object} page - From {@link splitPages}.
- * @returns {boolean} Whether nothing follows the fence's closing `:::`.
- */
-function figureIsWholePage(figure, page) {
-    const offset = figure.line - 1;
-    const after = page.markdown
-        .split("\n")
-        .slice(figure.close - offset + 1)
-        .join("\n");
-    return after.trim() === "";
-}
-
 /**
  * The fields particular to the Foundry page a captioned item begins.
  *
- * A fence holding exactly one picture, captioned with no inline markup, and
- * standing alone on its page becomes a page of type `image`: `src` the
- * picture, `image.caption` the caption text, the page named for the figure's
- * own number. Every other fence — grouped, an audio embed, a caption
- * `image.caption` cannot hold, or one trailing prose keeps company with —
+ * A captioned item holding exactly one picture, captioned with no inline
+ * markup, becomes a page of type `image`: `src` the picture, `image.caption`
+ * the caption text, the page named for the figure's own number. Every other
+ * item — grouped, an audio embed, or a caption `image.caption` cannot hold —
  * becomes a page of type `text`.
  *
  * The `text` page's content is rendered and then relabeled. The render sees
@@ -433,7 +487,7 @@ function figureIsWholePage(figure, page) {
  */
 function buildFigurePageFields(figure, page, pageId, footnoteNumbers, resolveRole) {
     const picture = soleFigurePicture(figure, page);
-    if (picture && figureIsWholePage(figure, page) && !captionCarriesMarkup(figure.caption)) {
+    if (picture && !captionCarriesMarkup(figure.caption)) {
         let src = picture;
         try {
             src = resolveImg(picture) ?? picture;
@@ -442,7 +496,7 @@ function buildFigurePageFields(figure, page, pageId, footnoteNumbers, resolveRol
             // image's own render takes when no configuration resolves it.
         }
         return {
-            name: figure.label || figure.caption,
+            name: figure.label || captionPageName(figure.caption),
             type: "image",
             src,
             image: figure.hasCaption ? { caption: figure.caption } : {},
@@ -460,7 +514,7 @@ function buildFigurePageFields(figure, page, pageId, footnoteNumbers, resolveRol
         resolveRole,
     );
     return {
-        name: figure.label || figure.caption,
+        name: figure.label || captionPageName(figure.caption),
         type: "text",
         text: {
             format: 1,
@@ -478,11 +532,12 @@ function buildFigurePageFields(figure, page, pageId, footnoteNumbers, resolveRol
  * @param {Array<object>} rawPages - From {@link splitPages}.
  * @param {string} entryId - The owning JournalEntry's `_id`.
  * @param {string} noteName - The note, for error messages.
- * A page whose heading carries `.secret` is given to the GM alone, by the one
- * ownership value Foundry reads as "nobody but a GM". Every other page states
- * no ownership and inherits the journal's. A figure-started page states none
- * either: {@link scanFigures} validates a figure's classes against its own
- * closed vocabulary, which carries no `.secret`.
+ * A page whose opening heading carries `.secret` is given to the GM alone, by
+ * the one ownership value Foundry reads as "nobody but a GM"; so is a captioned
+ * item's page and a continuation page inside such a section. Every other page
+ * states no ownership and inherits the journal's. A caption's own classes carry
+ * no `.secret`, because {@link scanFigures} validates them against a closed
+ * vocabulary without it.
  *
  * @param {Array<object>} figures - From {@link scanFigures}, numbered across
  *   the whole note. Read by a page a heading started; a page a figure started
@@ -536,7 +591,9 @@ export function buildPages(rawPages, entryId, noteName, figures, resolveRole) {
         return {
             _id: pageId,
             ...fields,
-            title: { show: true, level: page.level ?? 1 },
+            // A continuation resumes its section, whose title its first
+            // page already shows.
+            title: { show: !page.continues, level: page.level ?? 1 },
             ...(withheld ? { ownership: { default: WITHHELD_OWNERSHIP } } : {}),
             _key: `!journal.pages!${entryId}.${pageId}`,
         };

package/engine/literature-notes.mjs

@@ -0,0 +1,136 @@
+/*
+ * This file is part of the Song of Heroic Lands (SoHL) system for Foundry VTT.
+ * Copyright (c) 2024-2026 Tom Rodriguez ("Toasty") — <toasty@heroiclands.org>
+ *
+ * This work is licensed under the GNU General Public License v3.0 (GPLv3).
+ * You may copy, modify, and distribute it under the terms of that license.
+ *
+ * For full terms, see the LICENSE.md file in the project root or visit:
+ * https://www.gnu.org/licenses/gpl-3.0.html
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+/**
+ * A work a people tells, sings or writes: the `literature` lore subType and the
+ * four optional facts such a note may state about itself.
+ *
+ * `DataFieldSpec` declares the keys a type accepts, not the subType that may
+ * write them, so {@link checkLiteratureNote} scopes these keys to `literature`
+ * the way the calendar check scopes its own to `calendar`.
+ *
+ * @module
+ */
+
+import { isAddressTuple, parseAddress, renderAddress } from "./address.mjs";
+import { checkCultureChoice } from "./culture-choice.mjs";
+import { positionOfFrontmatterPath } from "./diagnostics.mjs";
+
+/** The `lore` subType whose notes are works of literature. */
+export const LITERATURE_SUBTYPE = "literature";
+
+/**
+ * Require `data.language` to address a `skill` note whose subType is
+ * `language`.
+ *
+ * An Address that does not resolve is the reference check's to report, so
+ * this speaks only about a target that exists and is the wrong kind.
+ *
+ * @param {object} note
+ * @param {{index?: object}} [options]
+ * @returns {object[]} The findings.
+ */
+export function checkLanguageChoice(note, { index } = {}) {
+    const value = note.fm?.data?.language;
+    if (value === undefined || value === null || !index?.addressHit) return [];
+    const tuple = parseAddress(value, {
+        package: index.contentPackage,
+        system: "note",
+        type: "skill",
+        types: index.types,
+        packages: index.packages,
+    });
+    if (tuple.reason) return [];
+    const target = index.addressHit(renderAddress(tuple));
+    if (!target) return [];
+    const fm = target.fm ?? target;
+    if (tuple.type === "skill" && fm.subType === "language") return [];
+    return [
+        {
+            file: note.file,
+            ...positionOfFrontmatterPath(note.raw ?? "", ["data", "language"]),
+            severity: "error",
+            message: `data.language ${isAddressTuple(value) ? renderAddress(value) : value} names a note that is not a skill whose subType is language`,
+        },
+    ];
+}
+
+/**
+ * The fields a `literature` note may state. Every one is optional.
+ *
+ * @type {ReadonlyArray<object>}
+ */
+export const LITERATURE_FIELDS = Object.freeze([
+    {
+        name: "culture",
+        shape: "an Address",
+        kind: "address",
+        ref: "lore",
+        accepts: ["lore"],
+        check: checkCultureChoice,
+        describe: "The people whose work this is, as a culture lore note.",
+    },
+    {
+        name: "form",
+        shape: "string",
+        kind: "string",
+        describe:
+            "The kind of work in its people's own terms — an epic, a saga, a " +
+            "praise-song, an elegy. Free text.",
+    },
+    {
+        name: "subjects",
+        shape: "list of Addresses",
+        kind: "list",
+        entryKind: "address",
+        anchors: Object.freeze(["event"]),
+        describe:
+            "The beings, places, gods and other notes the work concerns, and each " +
+            "event it concerns, named as `place-ironfells#sack`.",
+    },
+    {
+        name: "language",
+        shape: "an Address",
+        kind: "address",
+        ref: "skill",
+        accepts: ["skill"],
+        check: checkLanguageChoice,
+        describe: "The tongue the work is composed in, as a language skill note.",
+    },
+]);
+
+const LITERATURE_KEYS = Object.freeze(LITERATURE_FIELDS.map((field) => field.name));
+
+/**
+ * Refuse a literature field on a lore note of any other subType.
+ *
+ * @param {object} note
+ * @returns {object[]} One error per literature key written off `literature`.
+ */
+export function checkLiteratureNote(note) {
+    const type = String(note?.type ?? note?.fm?.type ?? "").toLowerCase();
+    const subType = String(note?.fm?.subType ?? "").toLowerCase();
+    if (type !== "lore" || subType === LITERATURE_SUBTYPE) return [];
+    const data = note?.fm?.data;
+    if (!data || typeof data !== "object" || Array.isArray(data)) return [];
+    return LITERATURE_KEYS.filter((key) => data[key] !== undefined && data[key] !== null).map(
+        (key) => ({
+            file: note.file,
+            ...positionOfFrontmatterPath(note.raw ?? "", ["data", key], { key: true }),
+            severity: "error",
+            message:
+                `\`data.${key}\` describes a work of literature, and this note's ` +
+                `\`subType\` is not \`literature\``,
+        }),
+    );
+}

package/engine/literature-works.mjs

@@ -0,0 +1,161 @@
+/*
+ * This file is part of the Song of Heroic Lands (SoHL) system for Foundry VTT.
+ * Copyright (c) 2024-2026 Tom Rodriguez ("Toasty") — <toasty@heroiclands.org>
+ *
+ * This work is licensed under the GNU General Public License v3.0 (GPLv3).
+ * You may copy, modify, and distribute it under the terms of that license.
+ *
+ * For full terms, see the LICENSE.md file in the project root or visit:
+ * https://www.gnu.org/licenses/gpl-3.0.html
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+/**
+ * The works of literature that concern each page, derived from what the works
+ * say. A `literature` lore note names its subjects in `data.subjects`; the build
+ * inverts that into the **In song and story** section of every subject — see
+ * {@link module:engine/derived-sections} — so a reader of a hero, a place or a
+ * god reaches the epics and legends about it. The subject note writes nothing.
+ *
+ * A subject naming an event lists the work on the page of the note holding
+ * that event. A work in a fetched index lists on this package's subject pages
+ * when that index carries its `subjects`. A subject in another package has no page here,
+ * so a local work naming one lists nowhere.
+ *
+ * @module
+ */
+
+import { parseAddress, renderAddress, splitAnchor } from "./address.mjs";
+import { AddressLink } from "./address-values.mjs";
+import { readCanonicalKey } from "./content-address.mjs";
+import { LITERATURE_SUBTYPE } from "./literature-notes.mjs";
+
+/** @typedef {{title: string, url?: string, address: string, form?: string}} WorkEntry */
+/**
+ * @typedef {object} WorksNode
+ * @property {string} key Own Address, normalized to the `note` system.
+ * @property {string} title
+ * @property {string} [url] Absent for a note that publishes no page.
+ * @property {string} [package] Owning content package.
+ * @property {string} [form] A work's `data.form`.
+ * @property {unknown[]} subjects A work's `data.subjects`; empty for any other note.
+ */
+
+/**
+ * The note-system key of one Address, or "" where it names nothing. A subject
+ * naming an event — `place-ironfells#sack`, or an {@link AddressLink} read
+ * from one — keys the note that holds the event.
+ */
+function addressKey(value, pkg, types) {
+    if (value == null) return "";
+    const note =
+        value instanceof AddressLink ? value.target
+        : typeof value === "string" ? splitAnchor(value).address
+        : value;
+    const tuple = parseAddress(note, { package: pkg ?? "local", system: "note", types });
+    if (tuple.reason) return "";
+    return renderAddress({ ...tuple, system: "note" }).toLowerCase();
+}
+
+/** Whether a note is a work of literature. */
+function isWork(type, subType) {
+    return type === "lore" && String(subType ?? "").toLowerCase() === LITERATURE_SUBTYPE;
+}
+
+/**
+ * One local page's node.
+ *
+ * @param {object} fm - The note's frontmatter.
+ * @param {{title: string, url?: string, package?: string}} page
+ * @returns {WorksNode|null} Null for a note with no type or shortcode.
+ */
+export function worksNode(fm, { title, url, package: pkg }) {
+    const type = String(fm?.type ?? "");
+    const shortcode = String(fm?.shortcode ?? "").toLowerCase();
+    if (!type || !shortcode) return null;
+    const data = fm.data && typeof fm.data === "object" && !Array.isArray(fm.data) ? fm.data : {};
+    const work = isWork(type, fm.subType);
+    return {
+        key: renderAddress({ package: pkg ?? "local", system: "note", type, shortcode }),
+        title,
+        ...(url ? { url } : {}),
+        ...(pkg ? { package: pkg } : {}),
+        ...(work && typeof data.form === "string" && data.form ? { form: data.form } : {}),
+        subjects:
+            !work ? []
+            : Array.isArray(data.subjects) ? data.subjects
+            : data.subjects ? [data.subjects]
+            : [],
+    };
+}
+
+/**
+ * The works a fetched index carries, as nodes. Only a work can list itself on
+ * a page, and only a page of this package can carry the list, so a foreign
+ * entry that is not a work is never needed here.
+ *
+ * @param {Map<string, object>|undefined} foreignIndex
+ * @returns {WorksNode[]}
+ */
+export function foreignWorksNodes(foreignIndex) {
+    const out = [];
+    for (const [canonical, entry] of foreignIndex ?? []) {
+        const tuple = readCanonicalKey(canonical);
+        if (!tuple || !isWork(entry?.type, entry?.subType)) continue;
+        if (!Array.isArray(entry.subjects) || !entry.subjects.length) continue;
+        out.push({
+            key: renderAddress({ ...tuple, system: "note" }),
+            title: String(entry.name ?? tuple.shortcode),
+            ...(entry.url ? { url: entry.url } : {}),
+            package: tuple.package,
+            ...(typeof entry.form === "string" && entry.form ? { form: entry.form } : {}),
+            subjects: entry.subjects,
+        });
+    }
+    return out;
+}
+
+/**
+ * Invert every work's subjects into the list each subject's page carries.
+ *
+ * A subject is resolved in its work's own package. A work naming one subject
+ * twice lists once; a work naming itself is not listed on its own page.
+ * Entries sort by title.
+ *
+ * @param {Iterable<WorksNode|null>} nodes - Every local page, then any foreign work.
+ * @param {object} options
+ * @param {ReadonlySet<string>} options.types - Note types an Address may name.
+ * @returns {Map<string, {works: WorkEntry[]}>} Keyed by the subject page's URL.
+ */
+export function worksPages(nodes, { types }) {
+    const all = [...nodes].filter(Boolean);
+    /** @type {Map<string, WorksNode>} */
+    const pages = new Map();
+    for (const node of all) {
+        if (!node.url) continue;
+        const key = node.key.toLowerCase();
+        if (!pages.has(key)) pages.set(key, node);
+    }
+    /** @type {Map<string, {works: WorkEntry[]}>} */
+    const lists = new Map();
+    for (const work of all) {
+        const seen = new Set();
+        for (const subject of work.subjects) {
+            const target = pages.get(addressKey(subject, work.package, types));
+            if (!target || target.key === work.key || seen.has(target.url)) continue;
+            seen.add(target.url);
+            let block = lists.get(target.url);
+            if (!block) lists.set(target.url, (block = { works: [] }));
+            block.works.push({
+                title: work.title,
+                ...(work.url ? { url: work.url } : {}),
+                address: work.key,
+                ...(work.form ? { form: work.form } : {}),
+            });
+        }
+    }
+    for (const block of lists.values())
+        block.works.sort((a, b) => a.title.localeCompare(b.title, "en"));
+    return lists;
+}

package/engine/map-graphviz.mjs

@@ -4,7 +4,6 @@
 
 import fs from "node:fs";
 import { instance } from "@viz-js/viz";
-import { Resvg } from "@resvg/resvg-js";
 
 /** The layout engines accepted by the map command. */
 export const GRAPHVIZ_ENGINES = Object.freeze(["dot", "twopi", "neato"]);
@@ -12,22 +11,16 @@ export const GRAPHVIZ_ENGINES = Object.freeze(["dot", "twopi", "neato"]);
 const graphviz = await instance();
 
 /**
- * Render a DOT source file to SVG, plain positions, or a PNG background.
- *
- * A PNG uses the same Graphviz SVG layout as the vector map. SVG dimensions
- * are in points; resvg starts at 96 pixels per inch, so the zoom converts
- * the requested DPI to the same physical size as Graphviz's PNG output.
+ * Render a DOT source file to SVG.
  *
  * @param {string} dotPath - The saved DOT source.
  * @param {string} outPath - The output file.
  * @param {object} opts
  * @param {"dot"|"twopi"|"neato"} opts.engine - Layout engine.
- * @param {"svg"|"plain"|"png"} [opts.format="svg"] - Output format.
  * @param {2} [opts.nop] - Preserve positioned nodes as `neato -n2` does.
- * @param {number} [opts.dpi=96] - PNG resolution.
  * @returns {{warnings: string}} Renderer warnings.
  */
-export function renderDot(dotPath, outPath, { engine, format = "svg", nop, dpi = 96 }) {
+export function renderDot(dotPath, outPath, { engine, nop }) {
     if (!GRAPHVIZ_ENGINES.includes(engine)) {
         throw new Error(`Unsupported Graphviz engine "${engine}" for ${dotPath}`);
     }
@@ -35,19 +28,12 @@ export function renderDot(dotPath, outPath, { engine, format = "svg", nop, dpi =
     try {
         const result = graphviz.render(dot, {
             engine: nop === 2 ? "nop2" : engine,
-            format: format === "png" ? "svg" : format,
+            format: "svg",
         });
         if (result.status !== "success" || !result.output) {
             throw new Error(result.errors.map((error) => error.message).join("; ") || "no output");
         }
-        if (format === "png") {
-            const image = new Resvg(result.output, {
-                fitTo: { mode: "zoom", value: dpi / 96 },
-            }).render();
-            fs.writeFileSync(outPath, image.asPng());
-        } else {
-            fs.writeFileSync(outPath, result.output);
-        }
+        fs.writeFileSync(outPath, result.output);
         // The embedded renderer uses Times metrics for the generated bold
         // headings; its warning repeats for every map and needs no action.
         return {