@heroiclands/package-build 22.2.0 → 22.3.0

package/engine/wikilinks.mjs

@@ -353,12 +353,14 @@ export function anchorPageId(noteId, anchorSlug) {
  * Builds the link-resolution tables for a content tree.
  *
  * @param {Array<{type: string, id: string, shortcode?: string|null,
- *   name?: string, pack?: string, docPack?: string,
+ *   name?: string, pack?: string, docPack?: string, none?: boolean,
  *   draft?: boolean}>} docs -
  *   One entry per content note. `pack` / `docPack` name the packs the note's
  *   document and its documentation entry landed in; omitted, the conventional
- *   one-pack-per-type names stand in. `draft` says the note carries the `draft`
- *   tag, which marks links *into* it and changes nothing else.
+ *   one-pack-per-type names stand in. `none` says the note declares
+ *   `pack: none` and compiles into no document, so it has no UUID to link to.
+ *   `draft` says the note carries the `draft` tag, which marks links *into* it
+ *   and changes nothing else.
  * @param {string} packageId - The Foundry package shipping the packs; the first
  *   segment of every emitted UUID.
  * @param {Map<string, object>} [foreign] - Canonically keyed entries from
@@ -408,17 +410,29 @@ export function buildWikilinkIndex(
         if (!d.id || !d.type) continue;
         types.add(norm(d.type));
 
-        uuidByDoc.set(d, {
-            // `d.pack` is where this note's document actually landed, resolved
-            // by the pack router when the index was collected. A repository may
-            // ship several packs of one type and a UUID carries the
-            // pack name, so the address cannot be derived from the type alone.
-            uuid: compendiumUuid(packageId, d.type, d.id, d.pack),
-            // An item's prose compiles into a separate JournalEntry, addressed
-            // by the virtual `doc<type>` qualifier. Its id is derived from the
-            // item's, so its address is knowable here too.
-            docUuid: compendiumUuid(packageId, "doc", itemDocEntryId(d.id), d.docPack),
-        });
+        uuidByDoc.set(
+            d,
+            // A note declaring `pack: none` compiles into no document, so it
+            // has no address in any compendium: a link to it is a page on the
+            // web and prose in a journal. Recorded as an entry with no UUIDs
+            // rather than left out, so the address still resolves and a link
+            // to it is never reported as dead.
+            d.none ?
+                { uuid: undefined, docUuid: undefined }
+            :   {
+                    // `d.pack` is where this note's document actually landed,
+                    // resolved by the pack router when the index was
+                    // collected. A repository may ship several packs of one
+                    // type and a UUID carries the pack name, so the address
+                    // cannot be derived from the type alone.
+                    uuid: compendiumUuid(packageId, d.type, d.id, d.pack),
+                    // An item's prose compiles into a separate JournalEntry,
+                    // addressed by the virtual `doc<type>` qualifier. Its id
+                    // is derived from the item's, so its address is knowable
+                    // here too.
+                    docUuid: compendiumUuid(packageId, "doc", itemDocEntryId(d.id), d.docPack),
+                },
+        );
 
         if (d.shortcode) byShortcode.set(`${norm(d.type)}/${norm(d.shortcode)}`, d);
     }
@@ -783,6 +797,13 @@ export function convertWikilinks(markdown, { type, id, pack, docPack, index }) {
             docUuid: compendiumUuid(index.packageId, "doc", itemDocEntryId(doc.id), doc.docPack),
         };
         const entryUuid = itemDoc ? addresses.docUuid : addresses.uuid;
+        // The target is a note that compiles into no document — `pack: none`.
+        // The address is real and the page exists on the web, so this is not
+        // a dead link and must not fail the build; but a compendium has
+        // nothing to open, so the reader gets the prose and no `@UUID`. The
+        // mirror of what the website does for an address that publishes a
+        // document and no page.
+        if (entryUuid === undefined) return text;
         const entryId = itemDoc ? itemDocEntryId(doc.id) : doc.id;
         const isJournal = itemDoc || packForType(doc.type).docType === "JournalEntry";
         // A JournalEntry link opens a journal — at its first page, or at the

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@heroiclands/package-build",
-    "version": "22.2.0",
+    "version": "22.3.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",

package/sohl/kb-passes.mjs

@@ -12,25 +12,23 @@
  */
 
 /**
- * The `sohl` knowledgebase's own body passes.
+ * The `sohl` knowledgebase's own body pass.
  *
  * `content-build site` publishes a content tree as a website, and almost all of
- * that job is the same for every package. These two rewrites are not: they are
- * driven by a TypeDoc symbol map and a repository layout only this package has,
- * and they are ruled explicitly per-consumer.
+ * that job is the same for every package. This rewrite is not: it is driven by
+ * a TypeDoc symbol map only this package has, and it is ruled explicitly
+ * per-consumer.
  *
- * They live here rather than in a script in the consuming repository for the
+ * It lives here rather than in a script in the consuming repository for the
  * same reason `sohl/item-builders.mjs` and `sohl/being-info.mjs` do: a
  * configuration is data and cannot hold a function, so a package-specific table
  * of code is **named** from configuration and resolved from a registry. What is
  * package-specific is the code; what is repository-specific — where the symbol
- * map sits, what the API is served at, which GitHub tree to link into — is
- * options, supplied beside the name.
+ * map sits, what the API is served at — is options, supplied beside the name.
  *
- * Neither *rewrite* ever fails a build. A `{@link}` the map does not know
- * degrades to a code span, and a relative link that resolves outside the
- * documentation tree becomes a GitHub blob URL. Both are legible to a reader; a
- * broken link or a failed build for a syntax example in prose would not be.
+ * The *rewrite* never fails a build. A `{@link}` the map does not know
+ * degrades to a code span, which is legible to a reader; a failed build for a
+ * syntax example in prose would not be.
  *
  * Building the bundle is a different matter: a `symbolMap` that is configured
  * and cannot be used fails, loudly, before a page is rendered. Degrading
@@ -168,80 +166,21 @@ export function resolveApiLinks(body, symbols, apiBase) {
     });
 }
 
-/**
- * Rewrites the relative links in a developer-doc body so they resolve on the
- * published site.
- *
- * Developer docs are authored to link one another and the source tree with
- * repository-relative paths, and neither target exists at the same path once
- * rendered. Each link is resolved against the doc's own location:
- *
- * - a `*.md` link landing inside the documentation tree becomes the published
- *   route, preserving any `#anchor`; a `README` is its directory's landing, so
- *   that segment is dropped.
- * - anything else — source, templates, a repository-root `*.md` — becomes its
- *   GitHub blob URL.
- *
- * Absolute URLs, anchor-only links, `mailto:` and site-root links are untouched.
- *
- * @param {string} body - The markdown body.
- * @param {string} docRel - The doc's path relative to the documentation tree.
- * @param {object} options - `{ repoRoot, docsSrc, docsRel, route, blob }`.
- * @returns {string} The body with every relative link rewritten.
- */
-export function rewriteRepoLinks(body, docRel, options) {
-    const { repoRoot, docsSrc, docsRel, route, blob } = options;
-    const docDir = path.dirname(docRel);
-    return body.replace(/\]\(([^)]+)\)/g, (whole, raw) => {
-        // Peel an optional link title: [text](url "title").
-        const sp = raw.search(/\s/);
-        const href = sp === -1 ? raw : raw.slice(0, sp);
-        const title = sp === -1 ? "" : raw.slice(sp);
-        if (/^(https?:|mailto:|tel:|#|\/)/.test(href)) return whole;
-
-        const hash = href.indexOf("#");
-        const filePart = hash === -1 ? href : href.slice(0, hash);
-        const anchor = hash === -1 ? "" : href.slice(hash);
-        if (!filePart) return whole;
-
-        const repoRel = path
-            .relative(repoRoot, path.resolve(docsSrc, docDir, filePart))
-            .replace(/\\/g, "/");
-
-        let out;
-        if (repoRel.startsWith(`${docsRel}/`) && repoRel.endsWith(".md")) {
-            const rel2 = repoRel.slice(docsRel.length + 1, -3).toLowerCase();
-            const devPath = path.basename(rel2) === "readme" ? path.posix.dirname(rel2) : rel2;
-            out = `${route}${devPath === "." ? "" : `${devPath}/`}${anchor}`;
-        } else {
-            out = `${blob}${repoRel}${anchor}`;
-        }
-        return `](${out}${title})`;
-    });
-}
-
 /**
  * The `sohl` knowledgebase pass bundle, built from its options.
  *
- * A pass bundle is two optional hooks the page renderer calls around wikilink
- * resolution, and the order matters:
- *
- * - `beforeLinks` runs on every page, before wikilinks resolve, because a
- *   `{@link}` tag may sit inside prose a wikilink also touches.
- * - `afterLinks` runs only on pages from an **extra tree** — the documentation
- *   tree — because repository-relative links are a property of how those pages
- *   are authored, not of content notes.
- *
- * Both run inside code-fence protection, so neither can rewrite a fenced example.
+ * A pass bundle is the hook the page renderer calls before wikilink
+ * resolution: `beforeLinks` runs on every page, before wikilinks resolve,
+ * because a `{@link}` tag may sit inside prose a wikilink also touches. It
+ * runs inside code-fence protection, so it cannot rewrite a fenced example.
  *
  * @param {object} options - Resolved from `site.passOptions`.
  * @param {string} [options.symbolMap] - Path to the TypeDoc symbol map,
  *   relative to `repoRoot`. Absent means no API links; present and unusable is
  *   a build failure.
  * @param {string} [options.apiBase] - Where the API documentation is served.
- * @param {string} [options.blob] - GitHub blob base for repository files.
  * @param {string} options.repoRoot - The repository root, for relative paths.
- * @returns {{beforeLinks: Function, afterLinks: Function}} The bundle.
+ * @returns {{beforeLinks: Function}} The bundle.
  * @throws {Error} When a configured `symbolMap` cannot be resolved, read,
  *   parsed, or is not a name → page object.
  */
@@ -250,15 +189,5 @@ export function sohlKbPass(options) {
     const apiBase = options.apiBase ?? "";
     return {
         beforeLinks: (text) => resolveApiLinks(text, symbols, apiBase),
-        afterLinks: (text, page) =>
-            page.tree ?
-                rewriteRepoLinks(text, page.rel, {
-                    repoRoot: options.repoRoot,
-                    docsSrc: page.tree.from,
-                    docsRel: page.tree.rel,
-                    route: page.tree.route,
-                    blob: options.blob ?? "",
-                })
-            :   text,
     };
 }

package/types/content-config.d.mts

@@ -133,10 +133,10 @@ export const DEFAULT_ADDRESS_SCHEME: Readonly<{
  * and the default.
  *
  * - `homepage` — the authored homepage, and **no other page**. The content tree
- *   is not walked for pages, `site.sections` / `site.trees` / `site.landing`
- *   emit nothing, and nothing serves a page for its addresses.
+ *   is not walked for pages, `site.sections` / `site.landing` emit nothing,
+ *   and nothing serves a page for its addresses.
  * - `content` — the homepage *plus* every page the content tree publishes: the
- *   knowledgebase, the extra trees, the section landings.
+ *   knowledgebase and the section landings.
  *
  * **Homepage-only is a first-class mode, not an accommodation.**
  * `sohl-kethira-basic` (unofficial Hârn fan material under Keléstia Productions'
@@ -200,10 +200,10 @@ export const DERIVED_HUGO_KEYS: Readonly<Record<string, string>>;
  * and the default.
  *
  * - `homepage` — the authored homepage, and **no other page**. The content tree
- *   is not walked for pages, `site.sections` / `site.trees` / `site.landing`
- *   emit nothing, and nothing serves a page for its addresses.
+ *   is not walked for pages, `site.sections` / `site.landing` emit nothing,
+ *   and nothing serves a page for its addresses.
  * - `content` — the homepage *plus* every page the content tree publishes: the
- *   knowledgebase, the extra trees, the section landings.
+ *   knowledgebase and the section landings.
  *
  * **Homepage-only is a first-class mode, not an accommodation.**
  * `sohl-kethira-basic` (unofficial Hârn fan material under Keléstia Productions'

package/types/engine/ids.d.mts

@@ -148,6 +148,17 @@ export const MAP_SUBTYPES: readonly string[];
  * @type {ReadonlySet<string>}
  */
 export const JOURNAL_TYPES: ReadonlySet<string>;
+/**
+ * The `pack:` value that routes a note's document into no compendium.
+ *
+ * One reading, on the key that already decides which compendium receives a
+ * note: the note publishes to the site and compiles into nothing. Declared
+ * here, beside the pack table, so the configuration can refuse a pack of this
+ * name and the router can read the value from one spelling.
+ *
+ * @type {string}
+ */
+export const NO_PACK: string;
 /**
  * Content type → the pack its documents compile into, and the document type
  * that pack holds.

package/types/engine/pack-router.d.mts

@@ -1,3 +1,19 @@
+/**
+ * Whether a note declares `pack: none` for one system's document.
+ *
+ * The same reading {@link createPackRouter}'s `resolve` applies: the system's
+ * block wins where it declares a pack, and the shared top-level value stands
+ * otherwise. Asked with no system, it reads the shared value alone, which is
+ * what every single-system build and the content index read.
+ *
+ * Pure, so the readers that never route — the Foundry-address pass, the link
+ * index, the unclaimed-type check — can ask it without a router.
+ *
+ * @param {object} fm - The note's frontmatter.
+ * @param {string} [system] - The system whose document is asked about.
+ * @returns {boolean} True when the answer for that document is `none`.
+ */
+export function declaresNoPack(fm: object, system?: string): boolean;
 /**
  * Build the router for one configured pack list.
  *
@@ -6,13 +22,13 @@
  *
  * @param {readonly object[]} packs - The resolved `packs` list from
  *   `defineConfig`.
- * @returns {{resolve: (fm: object, docType: string, system?: string) => string,
+ * @returns {{resolve: (fm: object, docType: string, system?: string) => string|undefined,
  *   resolveOrNull: (fm: object, docType: string, system?: string) => string|undefined,
  *   packsOfType: (docType: string) => string[],
  *   defaultOf: (docType: string) => string|undefined}} The router.
  */
 export function createPackRouter(packs: readonly object[]): {
-    resolve: (fm: object, docType: string, system?: string) => string;
+    resolve: (fm: object, docType: string, system?: string) => string | undefined;
     resolveOrNull: (fm: object, docType: string, system?: string) => string | undefined;
     packsOfType: (docType: string) => string[];
     defaultOf: (docType: string) => string | undefined;
@@ -52,3 +68,5 @@ export class PackRoutingError extends Error {
  * says which *compendium* receives its document.
  */
 export const PACK_FIELD: "pack";
+export { NO_PACK };
+import { NO_PACK } from "./ids.mjs";

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

@@ -1,19 +1,3 @@
-/**
- * Every `.md` file under `dir`, depth-first in directory order.
- *
- * Deliberately *not* {@link walkMarkdownTree}, whose stack-based walk yields a
- * tree in reverse. Order was load-bearing here when the address index carried
- * first-writer-wins fallbacks for a page's name, filename and slug — reversing
- * the walk silently changed which page an ambiguous name resolved to. Those
- * fallbacks are gone with the bare `[[Name]]` form, so this is now
- * ordinary reading order rather than a dependency; it is kept because a site's
- * emitted pages should not reorder for no reason.
- *
- * @param {string} dir - Directory to walk.
- * @param {readonly string[]} skip - Directory names to ignore at any depth.
- * @returns {string[]} Absolute paths.
- */
-export function walkSiteTree(dir: string, skip?: readonly string[]): string[];
 /**
  * The content tree's pages, and what could not be addressed.
  *
@@ -29,29 +13,6 @@ export function collectContentPages(contentBase: string, ctx: object): {
     addressFindings: object[];
     fmLinkFindings: object[];
 };
-/**
- * An extra tree's pages — a documentation tree published alongside the content.
- *
- * These preserve their **source layout** below the section rather than being
- * 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[]}}
- */
-export function collectTreePages(tree: object, ctx: object): {
-    pages: object[];
-    fmLinkFindings: object[];
-};
 /**
  * The package's homepage notes — the authored page at `/<contentPackage>/`.
  *
@@ -226,15 +187,8 @@ export function sectionFrontmatter(meta: object): object;
  * self-describing and makes sweeping the field out of a content tree
  * output-preserving for a site as it already is for the packs.
  *
- * A **tree** page is the one that still reads `readmeSections`: a `trees` entry
- * keeps its source layout below a named section, so its own `README` is that
- * section's landing and takes the title and hero the section declares.
- *
  * @param {object} page - The page.
  * @param {object} options
- * @param {Record<string, object>} [options.readmeSections] - The sections a
- *   published tree declares, which a tree page's own `README` is the landing
- *   for.
  * @param {(data: object, page: object) => void} [options.decorate] - Called
  *   with each page's frontmatter, for whatever a consumer's own pass adds.
  * @param {(value: unknown, type: string) => string|null} [options.artSrc] -
@@ -246,8 +200,7 @@ export function sectionFrontmatter(meta: object): object;
  *   same way.
  * @returns {object} The frontmatter to write.
  */
-export function pageFrontmatter(page: object, { readmeSections, decorate, webSrc, artSrc }: {
-    readmeSections?: Record<string, object> | undefined;
+export function pageFrontmatter(page: object, { decorate, webSrc, artSrc }: {
     decorate?: ((data: object, page: object) => void) | undefined;
     artSrc?: ((value: unknown, type: string) => string | null) | undefined;
     webSrc?: ((src: string) => string) | undefined;
@@ -267,12 +220,10 @@ export function pageFrontmatter(page: object, { readmeSections, decorate, webSrc
  * the same as another note's `type`, and `doc-gear.md` and `weapongear-gear.md`
  * are distinct whatever the sections.
  *
- * **A `trees` entry is the exception, and always was.** Those pages preserve
- * their source layout below a named section — they are a book with chapters,
- * addressed by their path — so a `README` there is still its directory's
- * `_index.md`.
+ * @param {object} page - The page.
+ * @returns {string} The file, relative to the mount.
  */
-export function pageDestination(page: any): string;
+export function pageDestination(page: object): string;
 /**
  * Renders and writes every page.
  *
@@ -283,10 +234,10 @@ export function pageDestination(page: any): string;
  *    authored as a fenced `dataview` block, which `protectCode` would otherwise
  *    stash away before the expander saw it. Expanding first leaves an ordinary
  *    markdown table to walk, with every other fence still protected.
- * 2. **Then, inside protection**: the consumer's `beforeLinks` pass, wikilink
- *    resolution, and the consumer's `afterLinks` pass. A `{@link}` tag may sit
- *    in prose a wikilink also touches, so the repository's own rewrites bracket
- *    the shared one rather than replacing it.
+ * 2. **Then, inside protection**: the consumer's `beforeLinks` pass, then
+ *    wikilink resolution. A `{@link}` tag may sit in prose a wikilink also
+ *    touches, so the repository's own rewrite runs before the shared one
+ *    rather than replacing it.
  *
  * @param {object[]} pages - Every page.
  * @param {object} options - Everything the render needs.
@@ -324,9 +275,9 @@ export function renderPages(pages: object[], options: object): {
  *   or its own address publishes nothing. Hugo generates a section page
  *   automatically only for a *top-level* content directory; below that, a
  *   directory without an `_index.md` is not a section, so its URL 404s while its
- *   children publish normally. With content pages flat, what that reaches is a
- *   `trees` entry's directory — the one thing left below the mount that a note
- *   creates.
+ *   children publish normally. With content pages flat, no note creates a
+ *   directory below the mount, so this reaches only what something else
+ *   placed there.
  *
  * **A section listing is not a page listing any more.** A layout that reads
  * `.Pages` off a section it declares here will find nothing, because no file is
@@ -373,11 +324,10 @@ export function pluralTitle(name: string): string;
  *
  * @param {string|undefined} name - The configured name.
  * @param {object} options - The configured options, plus `repoRoot`.
- * @returns {{beforeLinks?: Function, afterLinks?: Function}} The bundle.
+ * @returns {{beforeLinks?: Function}} The bundle.
  */
 export function resolveSitePass(name: string | undefined, options: object): {
     beforeLinks?: Function;
-    afterLinks?: Function;
 };
 /**
  * Builds a Hugo content tree from a content tree, and reports what it found.

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

@@ -94,9 +94,9 @@ export function resolveInfoboxRef(siteIndex: SiteIndex, ref: unknown, hint?: obj
 export type SiteEntry = {
     /**
      * `"content"` for a note compiled from the content
-     * tree, anything else for a page that carries no
-     * `type`/`shortcode` (a developer doc, say). Only
-     * content entries take part in type-scoped indexing.
+     * tree. Only content entries take part in
+     * type-scoped indexing; anything else is carried
+     * through unindexed.
      */
     kind: string;
     /**
@@ -111,13 +111,6 @@ export type SiteEntry = {
      * URL segment.
      */
     slug: string;
-    /**
-     * The Hugo section a **tree** page is filed under, and
-     *   the first segment of the `<sec>/<slug>` address it
-     *   is reachable by. A content page has none: it is
-     *   addressed by `(type, shortcode)` and emitted flat.
-     */
-    sec?: string | undefined;
     /**
      * Source file's basename, e.g. `Climbing.md`.
      */
@@ -126,11 +119,6 @@ export type SiteEntry = {
      * The page's published address.
      */
     url: string;
-    /**
-     * Whether a tree page is its directory's
-     * landing.
-     */
-    isReadme?: boolean | undefined;
 };
 /**
  * The resolved index and everything a wikilink resolver reads beside it.
@@ -157,10 +145,6 @@ export type SiteIndex = {
      * an address qualifier, local and foreign.
      */
     contentTypes: Set<string>;
-    /**
-     * Section names, lowercased.
-     */
-    sections: Set<string>;
     /**
      *                                       `type:shortcode` → page, for callers
      *                                       resolving embedded references (a
@@ -171,13 +155,4 @@ export type SiteIndex = {
         url: string;
         subType?: string;
     }>;
-    /**
-     * Addresses claimed by
-     * more than one package. Non-empty is a
-     * build failure; the caller reports it.
-     */
-    conflicts: {
-        key: string;
-        package: string;
-    }[];
 };

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

@@ -77,7 +77,7 @@ export function frontmatterWikilinks(fm: unknown): Array<{
  * for the website, and what the book reads its staging list out of.
  *
  * @param {string} body - The markdown body.
- * @param {object} ctx - `{ index, assets, collide, sections, contentTypes,
+ * @param {object} ctx - `{ index, assets, collide, contentTypes,
  *   packages, noIndexPackages, foreign, type, errors, src, file }`.
  *   `packages` is every package an address may name, without which the leading
  *   package segment of a canonical address reads as an unknown type;

package/types/engine/wikilinks.d.mts

@@ -122,12 +122,14 @@ export function anchorPageId(noteId: string, anchorSlug: string): string;
  * Builds the link-resolution tables for a content tree.
  *
  * @param {Array<{type: string, id: string, shortcode?: string|null,
- *   name?: string, pack?: string, docPack?: string,
+ *   name?: string, pack?: string, docPack?: string, none?: boolean,
  *   draft?: boolean}>} docs -
  *   One entry per content note. `pack` / `docPack` name the packs the note's
  *   document and its documentation entry landed in; omitted, the conventional
- *   one-pack-per-type names stand in. `draft` says the note carries the `draft`
- *   tag, which marks links *into* it and changes nothing else.
+ *   one-pack-per-type names stand in. `none` says the note declares
+ *   `pack: none` and compiles into no document, so it has no UUID to link to.
+ *   `draft` says the note carries the `draft` tag, which marks links *into* it
+ *   and changes nothing else.
  * @param {string} packageId - The Foundry package shipping the packs; the first
  *   segment of every emitted UUID.
  * @param {Map<string, object>} [foreign] - Canonically keyed entries from
@@ -153,6 +155,7 @@ export function buildWikilinkIndex(docs: Array<{
     name?: string;
     pack?: string;
     docPack?: string;
+    none?: boolean;
     draft?: boolean;
 }>, packageId: string, foreign?: Map<string, object>, contentPackage?: string, { assets, noIndexPackages }?: {
     assets?: Map<string, object> | undefined;

package/types/sohl/kb-passes.d.mts

@@ -17,59 +17,28 @@
  * @returns {string} The body with every tag resolved.
  */
 export function resolveApiLinks(body: string, symbols: Record<string, string>, apiBase: string): string;
-/**
- * Rewrites the relative links in a developer-doc body so they resolve on the
- * published site.
- *
- * Developer docs are authored to link one another and the source tree with
- * repository-relative paths, and neither target exists at the same path once
- * rendered. Each link is resolved against the doc's own location:
- *
- * - a `*.md` link landing inside the documentation tree becomes the published
- *   route, preserving any `#anchor`; a `README` is its directory's landing, so
- *   that segment is dropped.
- * - anything else — source, templates, a repository-root `*.md` — becomes its
- *   GitHub blob URL.
- *
- * Absolute URLs, anchor-only links, `mailto:` and site-root links are untouched.
- *
- * @param {string} body - The markdown body.
- * @param {string} docRel - The doc's path relative to the documentation tree.
- * @param {object} options - `{ repoRoot, docsSrc, docsRel, route, blob }`.
- * @returns {string} The body with every relative link rewritten.
- */
-export function rewriteRepoLinks(body: string, docRel: string, options: object): string;
 /**
  * The `sohl` knowledgebase pass bundle, built from its options.
  *
- * A pass bundle is two optional hooks the page renderer calls around wikilink
- * resolution, and the order matters:
- *
- * - `beforeLinks` runs on every page, before wikilinks resolve, because a
- *   `{@link}` tag may sit inside prose a wikilink also touches.
- * - `afterLinks` runs only on pages from an **extra tree** — the documentation
- *   tree — because repository-relative links are a property of how those pages
- *   are authored, not of content notes.
- *
- * Both run inside code-fence protection, so neither can rewrite a fenced example.
+ * A pass bundle is the hook the page renderer calls before wikilink
+ * resolution: `beforeLinks` runs on every page, before wikilinks resolve,
+ * because a `{@link}` tag may sit inside prose a wikilink also touches. It
+ * runs inside code-fence protection, so it cannot rewrite a fenced example.
  *
  * @param {object} options - Resolved from `site.passOptions`.
  * @param {string} [options.symbolMap] - Path to the TypeDoc symbol map,
  *   relative to `repoRoot`. Absent means no API links; present and unusable is
  *   a build failure.
  * @param {string} [options.apiBase] - Where the API documentation is served.
- * @param {string} [options.blob] - GitHub blob base for repository files.
  * @param {string} options.repoRoot - The repository root, for relative paths.
- * @returns {{beforeLinks: Function, afterLinks: Function}} The bundle.
+ * @returns {{beforeLinks: Function}} The bundle.
  * @throws {Error} When a configured `symbolMap` cannot be resolved, read,
  *   parsed, or is not a name → page object.
  */
 export function sohlKbPass(options: {
     symbolMap?: string | undefined;
     apiBase?: string | undefined;
-    blob?: string | undefined;
     repoRoot: string;
 }): {
     beforeLinks: Function;
-    afterLinks: Function;
 };