@heroiclands/package-build 22.1.0 → 22.1.1

package/engine/note-vocabulary.mjs

@@ -496,6 +496,26 @@ export function hasTag(fm, tag) {
     return false;
 }
 
+/**
+ * Whether a note carries any `tags:` at all, however authored.
+ *
+ * The one question the site build asks of tags in aggregate — whether the
+ * tree publishes taxonomy pages — rather than about a particular tag. Reads
+ * `tags` and `tag` exactly as {@link hasTag} does, and treats an empty list
+ * or a blank string as carrying none.
+ *
+ * @param {object|null|undefined} fm - Parsed frontmatter.
+ * @returns {boolean} Whether the note carries at least one tag.
+ */
+export function hasAnyTag(fm) {
+    const raw = fm?.tags ?? fm?.tag;
+    if (raw == null) return false;
+    for (const entry of Array.isArray(raw) ? raw : [raw]) {
+        if (typeof entry === "string" && entry.trim() !== "") return true;
+    }
+    return false;
+}
+
 /**
  * Whether a note is tagged as an unfinished **draft**.
  *

package/engine/site-build.mjs

@@ -57,13 +57,14 @@ import { renderImageFigures } from "./content-images.mjs";
 import { pathnameProblem, resolvePathname } from "./pathnames.mjs";
 import { buildSiteIndex, resolveInfoboxRef, wikiContext } from "./site-index.mjs";
 import { frontmatterWikilinks, resolveWebWikilinks } from "./web-wikilinks.mjs";
-import { loadForeignIndexes } from "./metadata-index.mjs";
+import { loadForeignIndexes, noContentIndexPackages } from "./metadata-index.mjs";
 import { noteInfoboxes } from "./infobox-registry.mjs";
 import { formatUnaddressableFinding, unaddressableForeignPackages } from "./metadata-index.mjs";
 import { deriveBeingInfo, isBeing } from "../sohl/being-info.mjs";
 import { loadPackConfig } from "./pack-config.mjs";
 import { routerFor } from "./pack-router.mjs";
 import { searchableFrontmatter } from "./note-package.mjs";
+import { hasAnyTag } from "./note-vocabulary.mjs";
 // The corpus, from the one pass that derives it.
 import { indexRecordsFor } from "./content-index.mjs";
 import { isNoteRecord, noteFile } from "./index-records.mjs";
@@ -476,7 +477,10 @@ export function siteGates(pages, findings, { config }) {
     out.unaddressable = unaddressableForeignPackages(foreign.index);
     if (out.unaddressable.length) return out;
 
-    const index = buildSiteIndex(pages, { foreignIndex: foreign.index });
+    const index = buildSiteIndex(pages, {
+        foreignIndex: foreign.index,
+        noIndexPackages: noContentIndexPackages(config),
+    });
     out.conflicts = index.conflicts;
     if (out.conflicts.length) return out;
 
@@ -1043,7 +1047,10 @@ export function resolveSitePass(name, options) {
  *   `sql` directive with none prepared is a table error: nothing here runs a
  *   query.
  * @returns {{gates: object, stats: object|null, tableErrors: object[],
- *   wikiErrors: object[], imageErrors: object[], manifests: object|null}}
+ *   wikiErrors: object[], imageErrors: object[], manifests: object|null,
+ *   hasTags: boolean}} `hasTags` is whether any note the walk read carries
+ *   `tags:` — what {@link module:engine/site-config.hugoConfig} reads to
+ *   decide whether the site emits taxonomy pages.
  */
 export function buildSite({ config, sqlTables } = {}) {
     const resolved = config ?? loadPackConfig();
@@ -1142,6 +1149,7 @@ export function buildSite({ config, sqlTables } = {}) {
             wikiErrors: [],
             imageErrors: [],
             stats: null,
+            hasTags: homepages.some((p) => hasAnyTag(p.fm)),
         };
     }
 
@@ -1164,6 +1172,7 @@ export function buildSite({ config, sqlTables } = {}) {
                 landings: 0,
                 out: homeRoot,
             },
+            hasTags: homepages.some((p) => hasAnyTag(p.fm)),
         };
     }
 
@@ -1211,6 +1220,7 @@ export function buildSite({ config, sqlTables } = {}) {
             tableErrors: [],
             wikiErrors: [],
             imageErrors: [],
+            hasTags: [...pages, ...homepageEntries].some((p) => hasAnyTag(p.fm)),
         };
     }
 
@@ -1269,6 +1279,7 @@ export function buildSite({ config, sqlTables } = {}) {
             landings,
             out,
         },
+        hasTags: [...pages, ...homepageEntries].some((p) => hasAnyTag(p.fm)),
     };
 }
 

package/engine/site-config.mjs

@@ -83,14 +83,39 @@ export const BRAND = Object.freeze({
 });
 
 /**
- * The kinds no site renders.
+ * The kinds a site with no tagged notes renders.
  *
  * A section exists only where `site.sections` declares one, so a tree holding
- * only the homepage emits nothing beyond it; taxonomies and feeds would be
- * empty shells on every site.
+ * only the homepage emits nothing beyond it; a taxonomy nobody's notes fill
+ * and a feed would be empty shells. A site whose notes carry `tags:` emits
+ * `taxonomy` and `term` after all — see {@link hugoConfig} — but `RSS` is
+ * disabled either way: nothing here publishes a feed.
  */
 export const DISABLE_KINDS = Object.freeze(["taxonomy", "term", "RSS"]);
 
+/**
+ * The kinds a site with at least one tagged note renders — everything but
+ * `RSS`.
+ */
+const DISABLE_KINDS_TAGGED = Object.freeze(["RSS"]);
+
+/**
+ * The single taxonomy a tagged site declares.
+ *
+ * Only `tag` — Hugo's default pair also declares `category`, which nothing
+ * here authors and which would publish an empty `/categories/`.
+ */
+const TAXONOMIES = Object.freeze({ tag: "tags" });
+
+/**
+ * The taxonomy output formats a tagged site declares — `HTML` only, so no
+ * feed is produced for `/tags/` or a single tag.
+ */
+const TAXONOMY_OUTPUTS = Object.freeze({
+    taxonomy: Object.freeze(["HTML"]),
+    term: Object.freeze(["HTML"]),
+});
+
 /**
  * The markup settings the toolchain's own output requires.
  *
@@ -359,11 +384,14 @@ function deepMerge(base, overrides) {
  * @param {string} [options.description] - `package.json`'s `description`.
  * @param {readonly NavigationEntry[]} options.navigation - The navigation.
  * @param {string} options.themesDir - From {@link resolveThemesDir}.
+ * @param {boolean} [options.hasTags] - Whether any note the site build walked
+ *   carries `tags:`, from {@link module:engine/site-build.buildSite}'s
+ *   `hasTags`. Defaults to `false` — no tagged note, no taxonomy pages.
  * @returns {Record<string, any>} The configuration Hugo reads.
  * @throws {TypeError} When `homepage` fails `checkHomepage`, or the
  *   configuration declares no `packageBuild.manifest.title`.
  */
-export function hugoConfig({ config, description, navigation, themesDir }) {
+export function hugoConfig({ config, description, navigation, themesDir, hasTags = false }) {
     checkHomepage(config.homepage, config.contentPackage);
 
     const title = config.packageBuild?.manifest?.title;
@@ -391,11 +419,18 @@ export function hugoConfig({ config, description, navigation, themesDir }) {
         themesDir,
         theme: THEME,
         contentDir: path.posix.relative(HUGO_SOURCE, HUGO_CONTENT),
-        disableKinds: [...DISABLE_KINDS],
+        disableKinds: hasTags ? [...DISABLE_KINDS_TAGGED] : [...DISABLE_KINDS],
         params,
         markup: structuredClone(MARKUP),
         menu: { main: menuEntries(navigation) },
     };
+    if (hasTags) {
+        generated.taxonomies = { ...TAXONOMIES };
+        generated.outputs = {
+            taxonomy: [...TAXONOMY_OUTPUTS.taxonomy],
+            term: [...TAXONOMY_OUTPUTS.term],
+        };
+    }
     return deepMerge(generated, config.site.hugo);
 }
 
@@ -434,15 +469,21 @@ function packageDescription(rootDir) {
  * intact.
  *
  * @param {object} config - The resolved build configuration.
+ * @param {object} [options] - Options.
+ * @param {boolean} [options.hasTags] - Whether any note the site build walked
+ *   carries `tags:`. Defaults to `false`, so a caller generating the
+ *   configuration before the walk (to fail fast on a missing source) gets the
+ *   untagged shape; pass the site build's own `hasTags` once it is known.
  * @returns {Record<string, any>} The configuration Hugo reads.
  * @throws {Error} When any source is missing or wrong.
  */
-export function generateHugoConfig(config) {
+export function generateHugoConfig(config, { hasTags = false } = {}) {
     return hugoConfig({
         config,
         description: packageDescription(config.rootDir),
         navigation: readCachedNavigation(config),
         themesDir: resolveThemesDir(config.rootDir),
+        hasTags,
     });
 }
 

package/engine/site-index.mjs

@@ -166,9 +166,16 @@ function mergeForeign(index, foreignIndex) {
  * @param {Map<string, {package: string, type?: string}>} [options.foreignIndex]
  *   The merged index from `loadForeignIndexes`. Omit when the build publishes
  *   no cross-package links.
+ * @param {Set<string>} [options.noIndexPackages] - Packages declared
+ *   `contentIndex: false` — a Foundry dependency only, with no fetched index.
+ *   A link naming one fails naming the key, rather than reading as prose or an
+ *   ordinary dead address.
  * @returns {SiteIndex} The index, and what could not be addressed unambiguously.
  */
-export function buildSiteIndex(entries, { foreignIndex = new Map() } = {}) {
+export function buildSiteIndex(
+    entries,
+    { foreignIndex = new Map(), noIndexPackages = new Set() } = {},
+) {
     const index = new Map();
     const contentTypes = new Set();
     const sections = new Set();
@@ -298,6 +305,7 @@ export function buildSiteIndex(entries, { foreignIndex = new Map() } = {}) {
         contentTypes,
         sections,
         packages,
+        noIndexPackages,
         refIndex,
         conflicts,
     };
@@ -347,6 +355,7 @@ export function wikiContext(
         sections: built.sections,
         contentTypes: built.contentTypes,
         packages: built.packages,
+        noIndexPackages: built.noIndexPackages,
         // The package a link written on this page defaults to when it names
         // none. Taken from the resolved configuration, the same source
         // the index's own addresses are built from, so a bare link cannot

package/engine/web-wikilinks.mjs

@@ -279,9 +279,10 @@ function isPlainMap(value) {
  *
  * **Every target that resolves nowhere fails the build**, and is
  * classified into the vocabulary all three resolvers share — `unlabelled`,
- * `not-an-address`, `unknown-type`, `ambiguous`, `unresolved`. Failures are
- * collected in `ctx.errors`, each carrying the authored `link` and its
- * `occurrence` so a caller can report the line and column it sits on.
+ * `not-an-address`, `unknown-type`, `ambiguous`, `unresolved`,
+ * `no-content-index`. Failures are collected in `ctx.errors`, each carrying
+ * the authored `link` and its `occurrence` so a caller can report the line and
+ * column it sits on.
  *
  * There is deliberately no exception letting a hyphen-form address through while
  * any linkable package had no vendored manifest, since a real cross-package
@@ -312,9 +313,12 @@ function isPlainMap(value) {
  *
  * @param {string} body - The markdown body.
  * @param {object} ctx - `{ index, assets, collide, sections, contentTypes,
- *   packages, foreign, type, errors, src, file }`.
+ *   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; `foreign`
+ *   package segment of a canonical address reads as an unknown type;
+ *   `noIndexPackages` is every package declared `contentIndex: false`, so a
+ *   qualified address naming one fails with `no-content-index` rather than
+ *   `not-an-address`; `foreign`
  *   is the cross-package manifest index; `assets` is the address space an embed
  *   resolves against. `src` is the page's display
  *   path and `file` the source file a diagnostic should name — absent, `src`
@@ -402,7 +406,12 @@ export function resolveWebWikilinks(body, ctx) {
         // The canonical separator has to be resolved, not merely
         // recognised. `null` here means the target is not an address at all,
         // which is a defect: there is no other namespace to try.
-        const read = readQualifier(target, ctx.contentTypes ?? new Set(), ctx.packages);
+        const read = readQualifier(
+            target,
+            ctx.contentTypes ?? new Set(),
+            ctx.packages,
+            ctx.noIndexPackages,
+        );
         const rawKey = target.toLowerCase();
         const hit =
             lookupRead(ctx.index, read, ctx.contentPackage) ??
@@ -478,6 +487,7 @@ export function resolveWebWikilinks(body, ctx) {
                 // a key: a partial address has no single key to be non-null.
             : (read && !read.reason) || siteAddress ? "unresolved"
             : read?.reason === "unknown-type" ? "unknown-type"
+            : read?.reason === "no-content-index" ? "no-content-index"
                 // Every link is an address, and this is not one. Distinct from
                 // a dead address, because the fix is different: a name has to
                 // become an address, not be corrected.

package/engine/wikilink-syntax.mjs

@@ -184,6 +184,9 @@ export function unlabelledLinkMessage(target) {
  * - `unresolved` — parses as an address, and nothing publishes it.
  * - `ambiguous` — more than one package publishes the short address.
  * - `unknown-anchor` — the address resolved, the `#section` it names did not.
+ * - `no-content-index` — the address names a package declared
+ *   `contentIndex: false`, a Foundry dependency only, so no index was fetched
+ *   for it to resolve against.
  *
  * @type {ReadonlySet<string>}
  */
@@ -197,6 +200,7 @@ export const LINK_FINDING_REASONS = Object.freeze(
         "unresolved",
         "ambiguous",
         "unknown-anchor",
+        "no-content-index",
     ]),
 );
 
@@ -312,6 +316,12 @@ export function linkFindingMessage({ reason, target, packages, anchor, type }) {
             );
         case "unresolved":
             return unresolvedAddressMessage(target);
+        case "no-content-index":
+            return (
+                `address [[${target}]] names a package declared \`contentIndex: false\` — ` +
+                `it is a Foundry dependency only, and no content index was fetched for it, ` +
+                `so nothing it publishes can be cited`
+            );
         default:
             throw new Error(
                 `linkFindingMessage: "${reason}" is not one of ` +

package/engine/wikilinks.mjs

@@ -203,13 +203,18 @@ export function resolveItemDocType(qualifier, types) {
  * @param {Set<string>} types - Every type the content tree contains.
  * @param {Set<string>} [packages] - Every package an address may name. Omitted
  *   by callers that resolve within one package, where the form cannot occur.
+ * @param {Set<string>} [noIndexPackages] - Packages declared `contentIndex:
+ *   false` — a Foundry dependency only, with no fetched index. A fully
+ *   qualified target naming one is refused with `no-content-index` before its
+ *   type is even considered, since there is no index to resolve it against.
  * @returns {{type: string, shortcode: string, itemDoc: boolean,
  *   package?: string, system?: string, reason?: undefined}
- *   | {reason: "unknown-type"} | null}
+ *   | {reason: "unknown-type"|"no-content-index", package?: string} | null}
  *   The resolved qualifier; a `reason` when the target is definitely qualified
- *   but names no known type; or `null` when it is not an address at all.
+ *   but names no known type or no fetched index; or `null` when it is not an
+ *   address at all.
  */
-export function readQualifier(target, types, packages) {
+export function readQualifier(target, types, packages, noIndexPackages) {
     // **Package, system and type are lowercase; the shortcode is not.** A
     // shortcode is case-sensitive and routinely mixed — `Clb`, `LtShoe`,
     // `HsTunic` — so it is written as the note declares it. The three segments
@@ -221,7 +226,7 @@ export function readQualifier(target, types, packages) {
     // (`[[Shock State]]`), and calling that a badly-cased address rather than
     // not an address would name the wrong mistake. Neither tree carries a
     // violation — 10,538 authored targets — so this pins a rule already kept.
-    const read = readQualifierCased(target, types, packages);
+    const read = readQualifierCased(target, types, packages, noIndexPackages);
     if (read && !read.reason && qualifyingSegments(target).some((s) => /[A-Z]/.test(s))) {
         return { reason: "not-lowercase" };
     }
@@ -249,9 +254,10 @@ function qualifyingSegments(target) {
  * @param {string} target
  * @param {Set<string>} types
  * @param {Set<string>} [packages]
+ * @param {Set<string>} [noIndexPackages]
  * @returns {object|null}
  */
-function readQualifierCased(target, types, packages) {
+function readQualifierCased(target, types, packages, noIndexPackages) {
     // The slash form is legacy and states neither package nor system, so it is
     // read first and separately. A slash is unconditionally a qualifier —
     // nothing else uses one — which is why an unknown type before it is
@@ -281,6 +287,10 @@ function readQualifierCased(target, types, packages) {
         // qualified.
         case 4: {
             const pkg = norm(parts[0]);
+            // Checked before the type: a package with no fetched index has no
+            // vocabulary to resolve the rest of the target against, and the
+            // fix is the config declaration, not the shortcode.
+            if (noIndexPackages?.has(pkg)) return { reason: "no-content-index", package: pkg };
             if (!packages?.has(pkg)) return null;
             const system = norm(parts[1]);
             if (!isSystemSegment(system)) return null;
@@ -359,11 +369,21 @@ export function anchorPageId(noteId, anchorSlug) {
  * @param {Map<string, object>} [opts.assets] - The files this package ships, by
  *   canonical address. They resolve no link — an asset is not a document — and
  *   answer only the art fields, which name a file and never a document.
+ * @param {Set<string>} [opts.noIndexPackages] - Packages declared
+ *   `contentIndex: false` — a Foundry dependency only. A link naming one fails
+ *   with `no-content-index` rather than resolving, ambiguously, as either a
+ *   typo or an undeclared package.
  * @returns {{byShortcode: Map<string, object>, types: Set<string>}} `types` is
  *   every type the tree actually contains, so a qualifier naming no real type
  *   can be told apart from a missing target.
  */
-export function buildWikilinkIndex(docs, packageId, foreign, contentPackage, { assets } = {}) {
+export function buildWikilinkIndex(
+    docs,
+    packageId,
+    foreign,
+    contentPackage,
+    { assets, noIndexPackages } = {},
+) {
     if (!packageId) {
         throw new Error(
             "buildWikilinkIndex: packageId is required — it is the first " +
@@ -454,6 +474,8 @@ export function buildWikilinkIndex(docs, packageId, foreign, contentPackage, { a
         foreign: foreignByKey,
         /** The files this package ships, by canonical address. */
         assets: assets ?? new Map(),
+        /** Packages declared `contentIndex: false`, a Foundry dependency only. */
+        noIndexPackages: noIndexPackages ?? new Set(),
     };
 }
 
@@ -656,7 +678,12 @@ export function convertWikilinks(markdown, { type, id, pack, docPack, index }) {
         if (target === "" && slug) {
             doc = { type, id, pack, docPack };
         } else {
-            const qualified = readQualifier(target, index.types, index.packages);
+            const qualified = readQualifier(
+                target,
+                index.types,
+                index.packages,
+                index.noIndexPackages,
+            );
             qualifiedRead = qualified;
             // A target that does not parse as an address is a defect: there is
             // no second namespace left to fall through to.

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@heroiclands/package-build",
-    "version": "22.1.0",
+    "version": "22.1.1",
     "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/types/content-config.d.mts

@@ -505,6 +505,17 @@ export type RelationshipSpec = {
      * `_stats.systemVersion` is stamped from.
      */
     compatibility?: CompatibilitySpec | undefined;
+    /**
+     * Whether `deps fetch` fetches this
+     * dependency's content index. Default
+     * `true`. `false` declares the dependency
+     * for the Foundry manifest only — nothing
+     * this tree cites by wikilink — and refuses
+     * `itemCatalog: true` on the same entry,
+     * since a catalogue is fetched from the same
+     * index.
+     */
+    contentIndex?: boolean | undefined;
 };
 /**
  * How a generated documentation page is framed in the repository publishing it.

package/types/engine/content-links.d.mts

@@ -144,8 +144,9 @@ export function auditHomepageLinks(index: ReturnType<typeof buildLinkIndex>): Ar
  *   which addresses a foreign manifest answered. Each `deadAddresses` entry
  *   carries a `reason` from {@link LINK_FINDING_REASONS} —
  *   `"not-an-address"`, `"unknown-type"`, `"ambiguous"` (with the claiming
- *   `packages`), or `"unresolved"` — and every one of them is an **error**:
- *   the three resolvers agree on severity for every class.
+ *   `packages`), `"no-content-index"`, or `"unresolved"` — and every one of
+ *   them is an **error**: the three resolvers agree on severity for every
+ *   class.
  */
 export function auditLinks(index: ReturnType<typeof buildLinkIndex>): {
     deadAnchors: object[];

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

@@ -9,6 +9,11 @@
  * and needing no items is the mirror of it. Gating the index on the catalogue
  * flag would serve neither.
  *
+ * **Excludes a relationship declaring `contentIndex: false`.** That opts a
+ * dependency out of both edges at once: it is a Foundry dependency only, cited
+ * by neither a wikilink nor an item reference, so there is nothing here for
+ * `deps fetch` to fill and no cache this build will ever read.
+ *
  * The declaration is the one already in the emitted `system.json` /
  * `module.json`, so it cannot drift from what Foundry itself installs, and
  * there is no new configuration key to keep in step. Each entry carries the
@@ -25,6 +30,23 @@ export function metadataRelationships(config: object): Array<{
     kind: string;
     verified: string | undefined;
 }>;
+/**
+ * Every package a relationship declares `contentIndex: false` on, keyed by
+ * the content package name a link into it would use.
+ *
+ * A separate set from {@link metadataRelationships}, which answers "what does
+ * `deps fetch` fill" — this answers "what does the link resolver recognise as
+ * a package with no fetched index", which a wikilink checker or pack compiler
+ * needs to tell that case apart from a package nobody declared at all.
+ *
+ * Walked across every relationship kind, not only the citable ones: the
+ * config validation refuses the flag nowhere by kind, so a resolver reading it
+ * back should not assume one either.
+ *
+ * @param {object} config - The resolved build configuration.
+ * @returns {ReadonlySet<string>} The content package names.
+ */
+export function noContentIndexPackages(config: object): ReadonlySet<string>;
 /**
  * The cache directory for one dependency's index at one version.
  *

package/types/engine/note-vocabulary.d.mts

@@ -50,6 +50,18 @@ export function exclusiveTagGroups(type: string, groups?: object): {
  * @returns {boolean} Whether the note carries it.
  */
 export function hasTag(fm: object | null | undefined, tag: string): boolean;
+/**
+ * Whether a note carries any `tags:` at all, however authored.
+ *
+ * The one question the site build asks of tags in aggregate — whether the
+ * tree publishes taxonomy pages — rather than about a particular tag. Reads
+ * `tags` and `tag` exactly as {@link hasTag} does, and treats an empty list
+ * or a blank string as carrying none.
+ *
+ * @param {object|null|undefined} fm - Parsed frontmatter.
+ * @returns {boolean} Whether the note carries at least one tag.
+ */
+export function hasAnyTag(fm: object | null | undefined): boolean;
 /**
  * Whether a note is tagged as an unfinished **draft**.
  *

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

@@ -396,7 +396,10 @@ export function resolveSitePass(name: string | undefined, options: object): {
  *   `sql` directive with none prepared is a table error: nothing here runs a
  *   query.
  * @returns {{gates: object, stats: object|null, tableErrors: object[],
- *   wikiErrors: object[], imageErrors: object[], manifests: object|null}}
+ *   wikiErrors: object[], imageErrors: object[], manifests: object|null,
+ *   hasTags: boolean}} `hasTags` is whether any note the walk read carries
+ *   `tags:` — what {@link module:engine/site-config.hugoConfig} reads to
+ *   decide whether the site emits taxonomy pages.
  */
 export function buildSite({ config, sqlTables }?: {
     config?: object | undefined;
@@ -408,6 +411,7 @@ export function buildSite({ config, sqlTables }?: {
     wikiErrors: object[];
     imageErrors: object[];
     manifests: object | null;
+    hasTags: boolean;
 };
 export { formatUnaddressableFinding };
 import { formatUnaddressableFinding } from "./metadata-index.mjs";

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

@@ -92,15 +92,19 @@ export function resolveThemesDir(rootDir: string): string;
  * @param {string} [options.description] - `package.json`'s `description`.
  * @param {readonly NavigationEntry[]} options.navigation - The navigation.
  * @param {string} options.themesDir - From {@link resolveThemesDir}.
+ * @param {boolean} [options.hasTags] - Whether any note the site build walked
+ *   carries `tags:`, from {@link module:engine/site-build.buildSite}'s
+ *   `hasTags`. Defaults to `false` — no tagged note, no taxonomy pages.
  * @returns {Record<string, any>} The configuration Hugo reads.
  * @throws {TypeError} When `homepage` fails `checkHomepage`, or the
  *   configuration declares no `packageBuild.manifest.title`.
  */
-export function hugoConfig({ config, description, navigation, themesDir }: {
+export function hugoConfig({ config, description, navigation, themesDir, hasTags }: {
     config: object;
     description?: string | undefined;
     navigation: readonly NavigationEntry[];
     themesDir: string;
+    hasTags?: boolean | undefined;
 }): Record<string, any>;
 /**
  * The configuration as the TOML Hugo reads.
@@ -118,10 +122,17 @@ export function hugoToml(generated: Record<string, unknown>): string;
  * intact.
  *
  * @param {object} config - The resolved build configuration.
+ * @param {object} [options] - Options.
+ * @param {boolean} [options.hasTags] - Whether any note the site build walked
+ *   carries `tags:`. Defaults to `false`, so a caller generating the
+ *   configuration before the walk (to fail fast on a missing source) gets the
+ *   untagged shape; pass the site build's own `hasTags` once it is known.
  * @returns {Record<string, any>} The configuration Hugo reads.
  * @throws {Error} When any source is missing or wrong.
  */
-export function generateHugoConfig(config: object): Record<string, any>;
+export function generateHugoConfig(config: object, { hasTags }?: {
+    hasTags?: boolean | undefined;
+}): Record<string, any>;
 /**
  * Write `build/hugo/hugo.toml`.
  *
@@ -162,11 +173,13 @@ export const BRAND: Readonly<{
     discordURL: "https://discord.gg/EwMfkNd3az";
 }>;
 /**
- * The kinds no site renders.
+ * The kinds a site with no tagged notes renders.
  *
  * A section exists only where `site.sections` declares one, so a tree holding
- * only the homepage emits nothing beyond it; taxonomies and feeds would be
- * empty shells on every site.
+ * only the homepage emits nothing beyond it; a taxonomy nobody's notes fill
+ * and a feed would be empty shells. A site whose notes carry `tags:` emits
+ * `taxonomy` and `term` after all — see {@link hugoConfig} — but `RSS` is
+ * disabled either way: nothing here publishes a feed.
  */
 export const DISABLE_KINDS: readonly string[];
 /**

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

@@ -7,13 +7,18 @@
  * @param {Map<string, {package: string, type?: string}>} [options.foreignIndex]
  *   The merged index from `loadForeignIndexes`. Omit when the build publishes
  *   no cross-package links.
+ * @param {Set<string>} [options.noIndexPackages] - Packages declared
+ *   `contentIndex: false` — a Foundry dependency only, with no fetched index.
+ *   A link naming one fails naming the key, rather than reading as prose or an
+ *   ordinary dead address.
  * @returns {SiteIndex} The index, and what could not be addressed unambiguously.
  */
-export function buildSiteIndex(entries: readonly SiteEntry[], { foreignIndex }?: {
+export function buildSiteIndex(entries: readonly SiteEntry[], { foreignIndex, noIndexPackages }?: {
     foreignIndex?: Map<string, {
         package: string;
         type?: string;
     }> | undefined;
+    noIndexPackages?: Set<string> | undefined;
 }): SiteIndex;
 /**
  * The per-page context a wikilink resolver takes.

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

@@ -44,9 +44,10 @@ export function frontmatterWikilinks(fm: unknown): Array<{
  *
  * **Every target that resolves nowhere fails the build**, and is
  * classified into the vocabulary all three resolvers share — `unlabelled`,
- * `not-an-address`, `unknown-type`, `ambiguous`, `unresolved`. Failures are
- * collected in `ctx.errors`, each carrying the authored `link` and its
- * `occurrence` so a caller can report the line and column it sits on.
+ * `not-an-address`, `unknown-type`, `ambiguous`, `unresolved`,
+ * `no-content-index`. Failures are collected in `ctx.errors`, each carrying
+ * the authored `link` and its `occurrence` so a caller can report the line and
+ * column it sits on.
  *
  * There is deliberately no exception letting a hyphen-form address through while
  * any linkable package had no vendored manifest, since a real cross-package
@@ -77,9 +78,12 @@ export function frontmatterWikilinks(fm: unknown): Array<{
  *
  * @param {string} body - The markdown body.
  * @param {object} ctx - `{ index, assets, collide, sections, contentTypes,
- *   packages, foreign, type, errors, src, file }`.
+ *   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; `foreign`
+ *   package segment of a canonical address reads as an unknown type;
+ *   `noIndexPackages` is every package declared `contentIndex: false`, so a
+ *   qualified address naming one fails with `no-content-index` rather than
+ *   `not-an-address`; `foreign`
  *   is the cross-package manifest index; `assets` is the address space an embed
  *   resolves against. `src` is the page's display
  *   path and `file` the source file a diagnostic should name — absent, `src`

package/types/engine/wikilink-syntax.d.mts

@@ -223,6 +223,9 @@ export const WIKILINK: RegExp;
  * - `unresolved` — parses as an address, and nothing publishes it.
  * - `ambiguous` — more than one package publishes the short address.
  * - `unknown-anchor` — the address resolved, the `#section` it names did not.
+ * - `no-content-index` — the address names a package declared
+ *   `contentIndex: false`, a Foundry dependency only, so no index was fetched
+ *   for it to resolve against.
  *
  * @type {ReadonlySet<string>}
  */