@heroiclands/package-build 22.14.1 → 22.14.3

package/engine/site-build.mjs

@@ -133,8 +133,8 @@ function siteCorpusFiles(contentBase, ctx) {
  * Reads a note, returning `null` for one that cannot be parsed.
  *
  * A file that is not front-mattered markdown is skipped rather than reported: a
- * content tree is edited in Obsidian, which leaves files of its own about, and
- * failing on one would make the build hostage to the editor.
+ * content tree may contain editor or working files, and failing on one would
+ * make the build depend on unrelated local files.
  *
  * @param {string} file - Absolute path.
  * @returns {{fm: object, body: string}|null}
@@ -510,9 +510,8 @@ export function tableUniverse(pages) {
  * The frontmatter a page publishes with.
  *
  * An authored `aliases` is retired and refused before a build reaches
- * here, which makes this a guard rather than a working path. It was Obsidian's
- * — a list of *names* a reader might call
- * the note, which is vault addressing and stays in the vault. Hugo reads
+ * here, which makes this a guard rather than a working path. It is a list of
+ * names a reader might call the note. Hugo reads
  * `aliases` as **URL redirects**, so passing them through would publish a
  * redirect stub at each name. They are dropped, and this build emits no
  * redirects of its own.
@@ -567,6 +566,7 @@ export function pageFrontmatter(page, { decorate, webSrc, artSrc }) {
     const { fm, slug } = page;
     const data = {
         ...fm,
+        ...(isPlainObject(fm.data) ? { data: { ...fm.data } } : {}),
         // Spread after the note's own frontmatter. Guarded because
         // `package: undefined` is not a value YAML can carry.
         ...(page.pkg ? { package: page.pkg } : {}),
@@ -675,6 +675,96 @@ export function pageDestination(page, { bundle = false } = {}) {
     return bundle ? `${page.slug}/index.md` : `${page.slug}.md`;
 }
 
+/** Transform one content page without writing the site mount. */
+export function renderSitePage(
+    page,
+    {
+        index,
+        foreign,
+        universe,
+        pass = {},
+        decorate,
+        linkable = (d) => Boolean(d.fm.shortcode),
+        sqlTables,
+        config,
+        artIndex,
+    },
+) {
+    const tableErrors = [];
+    const secretErrors = [];
+    const wikiErrors = [];
+    const imageErrors = [];
+    const resolved = [];
+    const src = page.relPath ?? page.base;
+    const ctx = wikiContext(index, {
+        src,
+        file: page.file,
+        type: page.fm.type ?? null,
+        errors: wikiErrors,
+        foreignIndex: foreign.index,
+        assets: artIndex,
+        resolved,
+    });
+
+    const seenImages = new Map();
+    const webSrc = (src) => {
+        const occurrence = (seenImages.get(src) ?? 0) + 1;
+        seenImages.set(src, occurrence);
+        const problem = pathnameProblem(src);
+        if (problem) {
+            imageErrors.push({ file: page.file, src, occurrence, message: problem });
+            return src;
+        }
+        const forms = resolvePathname(src, config);
+        if (!forms || forms.web !== null) return forms?.web ?? src;
+        imageErrors.push({
+            file: page.file,
+            src,
+            occurrence,
+            message:
+                `\`${src}\` names a file the \`${forms.package}\` package ships, and ` +
+                "no asset host is configured to serve it from — set `site.assets` in " +
+                "package-build.config.yaml. Emitted as authored, the address resolves " +
+                "against the page's own URL, which is nowhere",
+        });
+        return src;
+    };
+    const artSrc = (value, type, accepts) => artPathname(artIndex, value, type, accepts).pathname;
+    const resolve = (text) => {
+        let transformed = pass.beforeLinks ? pass.beforeLinks(text, page) : text;
+        transformed = resolveWebWikilinks(transformed, ctx);
+        return renderImageFigures(transformed, webSrc);
+    };
+
+    const { markdown, errors } = expandContentTables(page.body, {
+        docs: universe.get(page.pkg) ?? [],
+        linkable,
+        source: src,
+        sqlTables: sqlTables?.get(page.file),
+        self: { fm: searchableFrontmatter(page.fm, page.pkg), path: page.relPath },
+    });
+    tableErrors.push(...errors);
+    const data = pageFrontmatter(page, { decorate, webSrc, artSrc });
+    const secrets = renderSecretBlocks(protectCode(markdown, resolve), "web");
+    for (const error of renderSecretBlocks(page.body, "book").errors)
+        secretErrors.push({
+            file: page.file,
+            line: (page.bodyLine ?? 1) + error.line - 1,
+            column: error.column,
+            message: error.message,
+        });
+    return {
+        page,
+        body: secrets.markdown,
+        data,
+        resolved,
+        tableErrors,
+        secretErrors,
+        wikiErrors,
+        imageErrors,
+    };
+}
+
 /**
  * Renders and writes every page.
  *
@@ -731,6 +821,8 @@ export function renderPages(pages, options) {
         records = [],
         homepages = [],
         maps = new Map(),
+        write = true,
+        capture = false,
     } = options;
 
     // The address space the art slots and the body's embeds resolve against:
@@ -770,108 +862,24 @@ export function renderPages(pages, options) {
     /** @type {Array<{page: object, body: string, data: object}>} */
     const rendered = [];
 
-    /**
-     * The address the website serves for one authored pathname.
-     *
-     * A pathname the rule refuses, and a package-owned one with no asset host
-     * to resolve against, are both reported and emitted as authored: a page
-     * still publishes, with a picture the reader can see is missing, and the
-     * build exits non-zero. The occurrence count is what lets the command find
-     * the literal in the note and report a line and a column, the way a
-     * wikilink finding is located.
-     *
-     * @param {string} file - The note, for the finding.
-     * @returns {(src: string) => string} The resolver for that note's images.
-     */
-    const webAddresses = (file) => {
-        /** @type {Map<string, number>} */
-        const seen = new Map();
-        return (src) => {
-            const occurrence = (seen.get(src) ?? 0) + 1;
-            seen.set(src, occurrence);
-            const problem = pathnameProblem(src);
-            if (problem) {
-                imageErrors.push({ file, src, occurrence, message: problem });
-                return src;
-            }
-            const forms = resolvePathname(src, config);
-            if (!forms || forms.web !== null) return forms?.web ?? src;
-            imageErrors.push({
-                file,
-                src,
-                occurrence,
-                message:
-                    `\`${src}\` names a file the \`${forms.package}\` package ships, and ` +
-                    "no asset host is configured to serve it from — set `site.assets` in " +
-                    "package-build.config.yaml. Emitted as authored, the address resolves " +
-                    "against the page's own URL, which is nowhere",
-            });
-            return src;
-        };
-    };
-
     for (const page of pages) {
-        // The page's path in the tree an author edits, below the content
-        // root.
-        const src = page.relPath ?? page.base;
-        // Every index entry a link on this page resolved to.
-        const resolved = [];
-        const ctx = wikiContext(index, {
-            src,
-            file: page.file,
-            type: page.fm.type ?? null,
-            errors: wikiErrors,
-            foreignIndex: foreign.index,
-            assets: artIndex,
-            resolved,
-        });
-
-        const webSrc = webAddresses(page.file);
-        const artSrc = (value, type, accepts) =>
-            artPathname(artIndex, value, type, accepts).pathname;
-        const resolve = (text) => {
-            let t = text;
-            if (pass.beforeLinks) t = pass.beforeLinks(t, page);
-            t = resolveWebWikilinks(t, ctx);
-            // Last, so a consumer's own rewrites see the image as the note
-            // wrote it rather than as a figure. Hugo is handed markdown, not a
-            // rendered page, so a `{…}` directive left in the body would reach
-            // the reader as its own literal braces.
-            return renderImageFigures(t, webSrc);
-        };
-
-        const { markdown: body, errors } = expandContentTables(page.body, {
-            docs: universe.get(page.pkg) ?? [],
+        const result = renderSitePage(page, {
+            index,
+            foreign,
+            universe,
+            pass,
+            decorate,
             linkable,
-            source: src,
-            // Prepared before this render began — DuckDB is async and this
-            // is not. Keyed by the note's own file, absolute here as in
-            // every other pass, so the three cannot disagree about a note.
-            sqlTables: sqlTables?.get(page.file),
-            self: {
-                fm: searchableFrontmatter(page.fm, page.pkg),
-                path: page.relPath,
-            },
+            sqlTables,
+            config,
+            artIndex,
         });
-        tableErrors.push(...errors);
-
-        const data = pageFrontmatter(page, { decorate, webSrc, artSrc });
-        const resolvedBody = protectCode(body, resolve);
-        const secrets = renderSecretBlocks(resolvedBody, "web");
-        for (const error of renderSecretBlocks(page.body, "book").errors) {
-            secretErrors.push({
-                file: page.file,
-                line: (page.bodyLine ?? 1) + error.line - 1,
-                column: error.column,
-                message: error.message,
-            });
-        }
-        rendered.push({ page, body: secrets.markdown, data });
-        // A resolved target with no URL is a pack-only package's address:
-        // real, and nowhere on the web, so not an edge.
-        for (const hit of resolved) {
-            if (hit.url) edges.push([page.url, hit.url]);
-        }
+        tableErrors.push(...result.tableErrors);
+        secretErrors.push(...result.secretErrors);
+        wikiErrors.push(...result.wikiErrors);
+        imageErrors.push(...result.imageErrors);
+        rendered.push({ page, body: result.body, data: result.data });
+        for (const hit of result.resolved) if (hit.url) edges.push([page.url, hit.url]);
     }
 
     const related = relatedPages(edges, entries);
@@ -884,19 +892,23 @@ export function renderPages(pages, options) {
     ]);
 
     let withMap = 0;
+    const outputs = capture === true ? new Map() : null;
     for (const { page, body, data } of rendered) {
         const block = related.get(page.url);
         if (block) data.related = block;
         Object.assign(data, holdings.get(page.url));
         const map = maps.get(page.url);
-        const dest = path.join(outRoot, pageDestination(page, { bundle: Boolean(map) }));
-        fs.mkdirSync(path.dirname(dest), { recursive: true });
         if (map) {
-            fs.copyFileSync(map.file, path.join(path.dirname(dest), map.name));
             data.map = map.name;
             withMap += 1;
         }
-        fs.writeFileSync(dest, matter.stringify(body, encodeAddresses(data)));
+        if (write) {
+            const dest = path.join(outRoot, pageDestination(page, { bundle: Boolean(map) }));
+            fs.mkdirSync(path.dirname(dest), { recursive: true });
+            if (map) fs.copyFileSync(map.file, path.join(path.dirname(dest), map.name));
+            fs.writeFileSync(dest, matter.stringify(body, encodeAddresses(data)));
+        }
+        if (outputs) outputs.set(page.file, { markdown: body, frontmatter: data });
         byKind[page.kind] = (byKind[page.kind] ?? 0) + 1;
     }
 
@@ -909,6 +921,7 @@ export function renderPages(pages, options) {
         imageErrors,
         related,
         maps: withMap,
+        ...(capture ? { ...(outputs ? { outputs } : {}), edges, entries } : {}),
     };
 }
 
@@ -946,6 +959,18 @@ export function resolveSitePass(name, options) {
     return factory()(options);
 }
 
+/** The site frontmatter decoration shared by the site writer and page preview. */
+export function sitePageDecorator(config, index) {
+    const router = routerFor(config);
+    return (data, page) => {
+        if (isBeing(page.fm)) data.sohl = deriveBeingInfo(page.fm.sohl, index.refIndex);
+        data.infoboxes = noteInfoboxes(page.fm, {
+            resolve: (ref, hint) => resolveInfoboxRef(index, ref, hint),
+            router,
+        });
+    };
+}
+
 /**
  * Builds a Hugo content tree from a content tree, and reports what it found.
  *
@@ -1173,19 +1198,7 @@ export function buildSite({ config, sqlTables, locate } = {}) {
         // Asking in a consumer's script is how one came to still be checking
         // `character` and `creature` months after they were retired, and to
         // publish 95 pages with empty sidebars for months without noticing.
-        decorate: (data, page) => {
-            if (isBeing(page.fm)) {
-                data.sohl = deriveBeingInfo(page.fm.sohl, gates.index.refIndex);
-            }
-            // The declared infobox, travelling in the page's own front matter.
-            // The site theme draws it; what it holds is settled here, so the
-            // same panel reaches the website, a compendium journal and the
-            // book from one definition.
-            data.infoboxes = noteInfoboxes(page.fm, {
-                resolve: (ref, hint) => resolveInfoboxRef(gates.index, ref, hint),
-                router: routerFor(resolved),
-            });
-        },
+        decorate: sitePageDecorator(resolved, gates.index),
     });
 
     // Last, and outside the mount: the package's front page is not part of the

package/engine/site-preview.mjs

@@ -0,0 +1,293 @@
+/*
+ * 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>
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+/** A private, reusable site renderer for an editor's active note. @module */
+
+import path from "node:path";
+import matter from "gray-matter";
+import { indexRecordsFor, indexRecordsForNote } from "./content-index.mjs";
+import { noteAddressContext, decodeNoteAddresses, encodeAddresses } from "./note-addresses.mjs";
+import { noteFile } from "./index-records.mjs";
+import { foundryIdentities } from "./foundry-entries.mjs";
+import { applyComputedBeingAge, presentAmongRecords } from "./being-age.mjs";
+import { cachedMetadataIndexes, noContentIndexPackages } from "./metadata-index.mjs";
+import { buildSiteIndex } from "./site-index.mjs";
+import { openNotesDatabase, prepareSqlTables, findSqlBlocks } from "./sql-tables.mjs";
+import { relatedPages } from "./related-pages.mjs";
+import { holdingsNode, holdingsPages, foreignHoldingsNodes } from "./holdings.mjs";
+import { assetAddressIndex } from "./art-fields.mjs";
+import { frontmatterWikilinks } from "./web-wikilinks.mjs";
+import { positionOfLiteral } from "./diagnostics.mjs";
+import { addressSlug } from "./content-address.mjs";
+import { homepageTitle } from "./homepage.mjs";
+import { loadPackConfig } from "./pack-config.mjs";
+import {
+    collectContentPages,
+    collectHomepages,
+    gatesFailed,
+    renderPages,
+    renderSitePage,
+    resolveSitePass,
+    siteGates,
+    sitePageDecorator,
+    tableUniverse,
+} from "./site-build.mjs";
+
+/** Prepare saved project state once, then render live text without writing a site. */
+export async function prepareSitePreview({ config = loadPackConfig() } = {}) {
+    const contentBase = config.paths.content;
+    const base = config.site.base || `/${config.contentPackage}/`;
+    const dependencies = cachedMetadataIndexes(config);
+    const pass = resolveSitePass(config.site.pass, {
+        ...config.site.passOptions,
+        repoRoot: config.rootDir,
+    });
+    const context = {
+        config,
+        packages: new Set(
+            config.site.packages.length ? config.site.packages : [config.contentPackage],
+        ),
+        contentPackage: config.contentPackage,
+        skipDirectories: config.skipDirectories,
+        base,
+        mount: `${base}${config.publish.address.prefix}`,
+        scheme: config.publish.address,
+    };
+    let snapshot;
+
+    async function load() {
+        const records = indexRecordsFor({ config });
+        const ctx = { ...context, records };
+        const { pages, ...findings } = collectContentPages(contentBase, ctx);
+        const homepages = collectHomepages(contentBase, ctx).pages;
+        const homeEntries = homepages.map((home) => ({
+            kind: "content",
+            fm: home.fm,
+            body: home.body,
+            pkg: config.contentPackage,
+            name: home.fm.name?.full ?? homepageTitle(home.fm, config),
+            title: homepageTitle(home.fm, config),
+            slug: addressSlug(home.fm),
+            base: path.basename(home.file),
+            url: base,
+        }));
+        const gates = siteGates([...pages, ...homeEntries], findings, { config, records });
+        if (gatesFailed(gates))
+            throw new Error("site preview cannot prepare: site integrity gates failed");
+        const db = await openNotesDatabase(records, {
+            dependencies,
+            addressContext: noteAddressContext(config),
+        });
+        try {
+            const sources = pages
+                .filter((page) => findSqlBlocks(page.body).length)
+                .map((page) => ({ source: page.file, markdown: page.body }));
+            const sqlTables = await prepareSqlTables(db, sources);
+            const rendered = renderPages(pages, {
+                index: gates.index,
+                foreign: gates.foreign,
+                universe: tableUniverse(pages),
+                pass,
+                decorate: sitePageDecorator(config, gates.index),
+                sqlTables,
+                config,
+                records,
+                homepages: homeEntries,
+                write: false,
+                capture: "graph",
+            });
+            return { records, pages, homeEntries, gates, db, rendered };
+        } catch (error) {
+            await db.close();
+            throw error;
+        }
+    }
+
+    snapshot = await load();
+
+    return {
+        /** Render the active buffer. Other local and foreign notes remain saved. */
+        async render(file, text) {
+            const absolute = path.resolve(file);
+            const original = snapshot.pages.find((page) => page.file === absolute);
+            if (!original)
+                return {
+                    ok: false,
+                    findings: [
+                        {
+                            file: absolute,
+                            severity: "error",
+                            message: "note is not a published site page",
+                        },
+                    ],
+                };
+            let fm;
+            let parsed;
+            try {
+                parsed = matter(text);
+                fm = decodeNoteAddresses(parsed.data, {
+                    ...noteAddressContext(config),
+                    package: config.contentPackage,
+                });
+                applyComputedBeingAge(fm, presentAmongRecords(snapshot.records));
+            } catch (error) {
+                return {
+                    ok: false,
+                    findings: [
+                        { file: absolute, severity: "error", message: String(error.message) },
+                    ],
+                };
+            }
+            const body = parsed.content;
+            const bodyLine = text.slice(0, text.length - body.length).split("\n").length;
+            const findings = frontmatterWikilinks(fm).map((hit) => ({
+                file: absolute,
+                severity: "error",
+                ...hit,
+            }));
+            let slug;
+            try {
+                slug = addressSlug(fm);
+            } catch (error) {
+                findings.push({ file: absolute, severity: "error", message: error.message });
+            }
+            if (findings.length) return { ok: false, findings };
+            const page = {
+                ...original,
+                fm,
+                body,
+                bodyLine,
+                name: fm.name?.full ?? path.basename(absolute, ".md"),
+                slug,
+                url: `${base}${slug}/`,
+            };
+            const changedMetadata = JSON.stringify(fm) !== JSON.stringify(original.fm);
+            let records = snapshot.records;
+            let db = snapshot.db;
+            let index = snapshot.gates.index;
+            try {
+                if (changedMetadata) {
+                    const overlayRecords = indexRecordsForNote({
+                        frontmatter: fm,
+                        relPath: original.relPath,
+                        absPath: absolute,
+                        contentPackage: config.contentPackage,
+                        body,
+                        bodyLine,
+                        manifest: foundryIdentities(config),
+                        addressContext: noteAddressContext(config),
+                    });
+                    records = snapshot.records.filter(
+                        (entry) => noteFile(contentBase, entry) !== absolute,
+                    );
+                    records.push(...overlayRecords);
+                    const allPages = snapshot.pages.map((item) =>
+                        item.file === absolute ? page : item,
+                    );
+                    index = buildSiteIndex([...allPages, ...snapshot.homeEntries], {
+                        package: config.contentPackage,
+                        foreignIndex: snapshot.gates.foreign.index,
+                        foreignReferences: snapshot.gates.foreign.references,
+                        records,
+                        noIndexPackages: noContentIndexPackages(config),
+                    });
+                    db = await openNotesDatabase(records, {
+                        dependencies,
+                        addressContext: noteAddressContext(config),
+                    });
+                }
+                const sqlTables = await prepareSqlTables(db, [
+                    { source: absolute, markdown: body },
+                ]);
+                const allPages = snapshot.pages.map((item) =>
+                    item.file === absolute ? page : item,
+                );
+                const result = renderSitePage(page, {
+                    index,
+                    foreign: snapshot.gates.foreign,
+                    universe: tableUniverse(allPages),
+                    pass,
+                    decorate: sitePageDecorator(config, index),
+                    sqlTables,
+                    config,
+                    artIndex: assetAddressIndex(records, {
+                        config,
+                        foreign: snapshot.gates.foreign,
+                        types: index.contentTypes,
+                    }),
+                });
+                for (const error of result.tableErrors)
+                    findings.push({
+                        file: absolute,
+                        line: bodyLine + error.line,
+                        column: 1,
+                        severity: "error",
+                        message: error.reason ?? error.message,
+                    });
+                for (const error of result.secretErrors)
+                    findings.push({ ...error, severity: "error" });
+                for (const error of result.wikiErrors) {
+                    const pos = positionOfLiteral(text, error.link, error.occurrence);
+                    findings.push({
+                        ...error,
+                        ...pos,
+                        severity: "error",
+                        message: error.message ?? error.reason ?? "unresolved wikilink",
+                    });
+                }
+                for (const error of result.imageErrors) {
+                    const pos = positionOfLiteral(text, error.src, error.occurrence);
+                    findings.push({ ...error, ...pos, severity: "error" });
+                }
+                if (findings.length) return { ok: false, findings };
+                const edges = snapshot.rendered.edges.filter(([source]) => source !== original.url);
+                for (const hit of result.resolved) if (hit.url) edges.push([page.url, hit.url]);
+                const entries = new Map(snapshot.rendered.entries);
+                entries.delete(original.url);
+                entries.set(page.url, {
+                    title: fm.title ?? page.name,
+                    url: page.url,
+                    type: String(fm.type),
+                });
+                const related = relatedPages(edges, entries).get(page.url);
+                if (related) result.data.related = related;
+                const holdings = holdingsPages([
+                    ...allPages.map((item) =>
+                        holdingsNode(item.fm, { title: item.fm.title ?? item.name, url: item.url }),
+                    ),
+                    ...foreignHoldingsNodes(snapshot.gates.foreign.index),
+                ]);
+                Object.assign(result.data, holdings.get(page.url));
+                return {
+                    ok: true,
+                    markdown: result.body,
+                    frontmatter: encodeAddresses(result.data),
+                    findings: [],
+                };
+            } catch (error) {
+                return {
+                    ok: false,
+                    findings: [
+                        { file: absolute, severity: "error", message: String(error.message) },
+                    ],
+                };
+            } finally {
+                if (db !== snapshot.db) await db.close();
+            }
+        },
+        /** Re-read saved notes and dependency indexes after a save. */
+        async refresh() {
+            const next = await load();
+            const previous = snapshot;
+            snapshot = next;
+            await previous.db.close();
+        },
+        async close() {
+            await snapshot.db.close();
+        },
+    };
+}

package/engine/site-root.mjs

@@ -44,6 +44,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import * as pagefind from "pagefind";
+import { gunzipSync } from "node:zlib";
 
 import { formatDiagnostic } from "./diagnostics.mjs";
 
@@ -174,19 +175,36 @@ export async function indexSite({ site, output }) {
         }
         throw err;
     }
+    let pages;
     try {
         const added = await index.addDirectory({ path: site });
         if (added.errors.length) throw new Error(added.errors.join("; "));
-        const pages = added.page_count;
+        pages = added.page_count;
         if (!pages) {
             throw new Error(`no page under ${site} was indexed — the site holds no HTML`);
         }
         const written = await index.writeFiles({ outputPath: output });
         if (written.errors.length) throw new Error(written.errors.join("; "));
-        return { pages };
     } finally {
         await pagefind.close();
     }
+    // Pagefind may finish its API call while fragment writes are still visible
+    // as incomplete gzip streams under heavy parallel load. A successful site
+    // build must hand deployment complete fragments.
+    const fragmentDir = path.join(output, "fragment");
+    const deadline = Date.now() + 5000;
+    for (;;) {
+        try {
+            const fragments = fs.readdirSync(fragmentDir);
+            if (!fragments.length) throw new Error("no search fragments were written");
+            for (const name of fragments) gunzipSync(fs.readFileSync(path.join(fragmentDir, name)));
+            break;
+        } catch (error) {
+            if (Date.now() >= deadline) throw error;
+            await new Promise((resolve) => setTimeout(resolve, 25));
+        }
+    }
+    return { pages };
 }
 
 /**

package/engine/social-tie-terms.mjs

@@ -0,0 +1,11 @@
+/* SPDX-License-Identifier: GPL-3.0-or-later */
+
+/** Relationships a being states from its own point of view. */
+export const SOCIAL_TIES = Object.freeze([
+    { term: "patron", meaning: "Supports the subject from greater power, wealth, or status." },
+    { term: "friend", meaning: "Supports the subject out of goodwill." },
+    { term: "dependent", meaning: "Relies on the subject's support or protection." },
+    { term: "acquaintance", meaning: "Knows the subject without a strong disposition." },
+    { term: "rival", meaning: "Opposes the subject without implacable hostility." },
+    { term: "nemesis", meaning: "Opposes the subject personally and implacably." },
+]);