@heroiclands/package-build 11.1.0 → 14.0.0

package/engine/site-build.mjs

@@ -50,7 +50,7 @@ import { createRequire } from "node:module";
 import matter from "gray-matter";
 
 import { slugify } from "./content-slug.mjs";
-import { addressSlug, sectionOf } from "./content-address.mjs";
+import { addressSlug } from "./content-address.mjs";
 import { protectCode } from "./code-fences.mjs";
 import { expandContentTables } from "./content-tables.mjs";
 import { buildSiteIndex, wikiContext } from "./site-index.mjs";
@@ -132,11 +132,10 @@ function readNote(file) {
  * @returns {{pages: object[], addressFindings: object[], fmLinkFindings: object[]}}
  */
 export function collectContentPages(contentBase, ctx) {
-    // Where an addressed page publishes. The section below is guarded so a note
-    // is never "written to `undefined/`"; the same reasoning applies here, and a
-    // missing `base` would put *every* page there rather than one. It is the
-    // caller's contract rather than a note's defect, so it throws instead of
-    // being collected as a finding (#195).
+    // Where an addressed page publishes. A missing `base` would put *every*
+    // page at `undefined/` rather than one, and it is the caller's contract
+    // rather than a note's defect, so it throws instead of being collected as a
+    // finding (#195).
     if (typeof ctx.base !== "string" || !ctx.base) {
         throw new TypeError(
             "collectContentPages: `ctx.base` must be a non-empty string — it is the package address every page's URL is built on",
@@ -178,20 +177,6 @@ export function collectContentPages(contentBase, ctx) {
         }
 
         const base = path.basename(file);
-        const isReadme = base.toLowerCase() === "readme.md";
-        const sec = sectionOf(fm);
-        // A page's URL no longer contains its section, but the section is still
-        // what decides the directory the file is written to — and Hugo derives
-        // a page's section from that directory, not from its URL. So a note
-        // with none is still a note with nowhere to be published, and is
-        // reported rather than written to `undefined/`.
-        if (typeof sec !== "string" || !sec) {
-            addressFindings.push({
-                file,
-                reason: `type "${fm.type}" has no section, so there is nowhere to file the page`,
-            });
-            continue;
-        }
         const rel = path.relative(contentBase, file);
         pages.push({
             kind: "content",
@@ -218,15 +203,12 @@ export function collectContentPages(contentBase, ctx) {
             // The immediate source subfolder, the only surviving record of the
             // authoring folder, for grouped landings.
             folder: path.basename(path.dirname(file)),
-            sec,
-            // A landing page **is** its section, so it is addressed by the
-            // mount the section lives at; every other page is addressed by
-            // `(type, shortcode)` at the package root, which takes no mount
-            // (#181). The file is still written into `<sec>/` either way — see
-            // {@link pageDestination} — and the front matter carries this `url`
-            // so Hugo publishes it at its address rather than at its path.
-            url: isReadme ? `${ctx.mount}${sec}/` : `${ctx.base}${slug}/`,
-            isReadme,
+            // Every page is addressed by `(type, shortcode)` at the package
+            // root, which takes no content mount (#181). The file is written
+            // flat under the mount — see {@link pageDestination} — and the
+            // front matter carries this `url` so Hugo publishes it at its
+            // address rather than at its path.
+            url: `${ctx.base}${slug}/`,
         });
     }
     return { pages, addressFindings, fmLinkFindings };
@@ -557,12 +539,10 @@ export function sectionFrontmatter(meta) {
  * redirects of its own.
  *
  * A content page states its own **`url`**, which is its address rather than its
- * path (#181). Hugo would otherwise publish it where the file sits — under the
- * mount, inside its section directory — and the file sits there for a reason:
- * Hugo derives a page's section from its directory, which is what gives the
- * section its landing page, `.CurrentSection` and its per-section layout
- * lookup. So the directory stays and the address is stated, and the two are
- * free to differ.
+ * path (#181). It is written flat under the content mount (#204), so Hugo would
+ * otherwise publish it at `<mount><type>-<shortcode>/` rather than at the
+ * package-wide address the link manifest records — the same address, one
+ * segment too deep. So the address is stated and the mount does not reach it.
  *
  * A content page carries the package the build **derived** (#65). No note
  * declares one — `package:` is retired (#56) — so the note's frontmatter alone
@@ -574,8 +554,12 @@ export function sectionFrontmatter(meta) {
  * 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 - `{ sections, readmeSections, decorate }`.
+ * @param {object} options - `{ readmeSections, decorate }`.
  * @returns {object} The frontmatter to write.
  */
 export function pageFrontmatter(page, { readmeSections = {}, decorate }) {
@@ -598,14 +582,6 @@ export function pageFrontmatter(page, { readmeSections = {}, decorate }) {
             kbfolder: page.folder,
         };
         if (decorate) decorate(data, page);
-        if (isReadme) {
-            const meta = readmeSections[sec];
-            // What the section says about itself wins over what its README
-            // happens to carry — the landing has to match the card linking to
-            // it. Assigned rather than transcribed key by key, so a section's
-            // vocabulary is decided in one place (#91).
-            if (meta) Object.assign(data, sectionFrontmatter(meta));
-        }
     } else {
         // A tree's own landing describes the *mount*, and nothing beneath it. A
         // nested README is a sub-section's landing, and reading the section's
@@ -623,23 +599,25 @@ export function pageFrontmatter(page, { readmeSections = {}, decorate }) {
 /**
  * Where a page is written, relative to the output root.
  *
- * **Into its section directory, which is not where it publishes** (#181). A
- * content page's URL is its address — `/<package>/<type>-<shortcode>/` — and it
- * is stated in the front matter; the file still goes to `<section>/`, because
- * Hugo reads a page's section from its path and nothing else. Flattening the
- * tree to match the URL would take the section landings, `.CurrentSection` and
- * every per-section layout with it.
+ * **Flat, under the mount, named by its address** (#204). A content page's URL
+ * is its address — `/<package>/<type>-<shortcode>/` — and the file is now named
+ * the same way, so the two agree. It used to be filed into `<section>/` so that
+ * Hugo would read a section off its path; a section appears in no address, and
+ * a directory chosen only to satisfy a rendering engine's idea of what a
+ * section is has no business in the note format.
+ *
+ * The name is the *whole* address rather than a section-relative half of it, so
+ * two types cannot fight over one file: a `doc` note's `subType` may be spelled
+ * the same as another note's `type`, and `doc-gear.md` and `weapongear-gear.md`
+ * are distinct whatever the sections used to be.
  *
- * The filename is the address rather than the section-relative half of it, so
- * two sections cannot fight over one file: a `doc` note routes by its `subType`,
- * which may be spelled the same as another note's `type`.
+ * **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`.
  */
 export function pageDestination(page) {
-    if (page.kind === "content") {
-        return page.isReadme ?
-                path.join(page.sec, "_index.md")
-            :   path.join(page.sec, `${page.slug}.md`);
-    }
+    if (page.kind === "content") return `${page.slug}.md`;
     const rel =
         page.isReadme ? path.posix.join(path.posix.dirname(page.rel), "_index.md") : page.rel;
     return path.join(page.sec, rel);
@@ -681,7 +659,11 @@ export function renderPages(pages, options) {
     const byKind = {};
 
     for (const page of pages) {
-        const src = page.rel ?? `${page.sec}/${page.base}`;
+        // The page's path in the tree an author edits: below the content root
+        // for a content note, below the tree's own root for a `trees` page. It
+        // used to be composed as `<section>/<basename>` for a content note,
+        // which named a directory that was never the note's (#204).
+        const src = page.relPath ?? page.rel ?? page.base;
         const ctx = wikiContext(index, {
             src,
             file: page.file,
@@ -724,26 +706,43 @@ export function renderPages(pages, options) {
 }
 
 /**
- * Writes the section landings a published tree needs but no note supplies.
+ * Writes the Hugo sections a published tree declares.
+ *
+ * **This is where a section lives now, and the only place** (#204). A content
+ * note carries none: it is addressed by `(type, shortcode)` and emitted flat
+ * under the mount, so nothing a page does creates a directory. A site that wants
+ * `/<package>/<prefix><section>/` to answer — with a title, a hero, and whatever
+ * listing its layout builds — says so here, in configuration, and this writes
+ * the `_index.md` that makes Hugo agree it is a section.
  *
- * Two separate jobs, and both exist because of how Hugo decides what a section
- * is:
+ * Three jobs, all of them Hugo's directory semantics rather than the note
+ * format's:
  *
+ * - **The mount's own landing**, so `/<package>/<prefix>` is a page rather than
+ *   a directory listing. It carries a `type` of its own: Hugo's template lookup
+ *   walks up a page's path, so an untyped landing template at the mount would
+ *   also serve every section below it that has none.
  * - **Declared sections** get a titled `_index.md` with their hero, so a landing
  *   matches the card that links to it instead of showing Hugo's auto-humanised
- *   directory name. The body is empty, which lets the theme list the section's
- *   children — or say it is empty, for a section whose content has not shipped.
- * - **Every other section directly under the mount** gets a bare `_index.md`,
+ *   directory name. The body is empty, which lets the theme decide what to list.
+ * - **Every other directory directly under the mount** gets a bare `_index.md`,
  *   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. Mounting a tree one level down demotes every
- *   section it holds, and the ones with no landing of their own quietly stop
- *   existing while every page inside them keeps working.
+ *   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.
+ *
+ * **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
+ * filed into it; one that queries `site.RegularPages` by `Params.type` — which
+ * is how `sohl`'s eleven catalog layouts already work — is unaffected. That is a
+ * consumer's layout to choose, and it is stated here because the choice is no
+ * longer free.
  *
  * Scoped to one level on purpose. A directory further down was not a section
- * before the move either, and giving it one here would silently re-scope the
- * prev/next navigation of every page inside it.
+ * before either, and giving it one here would silently re-scope the prev/next
+ * navigation of every page inside it.
  *
  * @param {string} outRoot - The mount directory.
  * @param {object} options - `{ sections, landing, sectionTitle }`.
@@ -752,11 +751,6 @@ export function renderPages(pages, options) {
 export function writeSectionLandings(outRoot, { sections = {}, landing, sectionTitle }) {
     let written = 0;
 
-    // The mount's own landing carries a `type` of its own. Hugo's template
-    // lookup walks up a page's path, so a landing template at the mount would
-    // also serve every section below it that has no template of its own —
-    // each would render the mount's front page. Typing the landing moves its
-    // template out of the path where it could be inherited.
     if (landing) {
         fs.mkdirSync(outRoot, { recursive: true });
         fs.writeFileSync(path.join(outRoot, "_index.md"), matter.stringify("", landing));
@@ -1024,9 +1018,7 @@ export function buildSite({ config, outRoot } = {}) {
         name: page.fm.name?.full ?? homepageTitle(page.fm, resolved),
         slug: addressSlug(page.fm),
         base: path.basename(page.file),
-        sec: sectionOf(page.fm),
         url: `${base}${addressSlug(page.fm)}/`,
-        isReadme: false,
     }));
 
     const trees = site.trees.map((t) => ({

package/engine/site-index.mjs

@@ -65,10 +65,15 @@ import { isDraftNote } from "./note-vocabulary.mjs";
  * @property {object} fm     The note's frontmatter.
  * @property {string} name   Display name.
  * @property {string} slug   URL segment.
- * @property {string} sec    Section the page is filed under.
+ * @property {string} [sec]  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
+ *                           (#204).
  * @property {string} base   Source file's basename, e.g. `Climbing.md`.
  * @property {string} url    The page's published address.
- * @property {boolean} isReadme  Whether the page is its section's landing.
+ * @property {boolean} [isReadme]  Whether a tree page is its directory's
+ *                           landing.
  */
 
 /**
@@ -169,13 +174,20 @@ export function buildSiteIndex(entries, { foreignIndex = new Map() } = {}) {
     const ownPackage = contentPackage();
     const packages = new Set(ownPackage ? [ownPackage] : []);
 
-    // `section/slug` is unique by construction. A page's name, filename and
-    // bare slug were indexed here too, as collision-aware fallbacks the bare
-    // `[[Name]]` form looked up; that form is retired and nothing consults
-    // them, so they are gone and with them the rule that two pages of a type
-    // may not share a name (#179, #180).
+    // `section/slug` is unique by construction, and is now a **tree** page's
+    // address: a `trees` entry keeps its source layout below a named section,
+    // so `dev-docs/testing` is how one is cited. A content page carries no
+    // section at all (#204) and is addressed by `(type, shortcode)` below —
+    // indexing it here as well would have written `weapongear/weapongear-dagger`,
+    // a key no author could reasonably write.
+    //
+    // A page's name, filename and bare slug were indexed here too, as
+    // collision-aware fallbacks the bare `[[Name]]` form looked up; that form is
+    // retired and nothing consults them, so they are gone and with them the rule
+    // that two pages of a type may not share a name (#179, #180).
     for (const e of entries) {
-        sections.add(String(e.sec).toLowerCase());
+        if (typeof e.sec !== "string" || !e.sec) continue;
+        sections.add(e.sec.toLowerCase());
         // `draft` rides on every key a page is addressable by, because a link
         // into a draft note renders marked whichever of them the author wrote
         // (#183). It decides nothing about resolution: the page is indexed and

package/engine/web-wikilinks.mjs

@@ -28,7 +28,7 @@
  * pack build together.
  *
  * The KB *section* is not always the type: prose pages (`type: doc`) route by
- * their `category`, so `doc/quickstart` lands on `/user-guide/sohl-quickstart/`.
+ * their `category`, so `doc/quickstart` lands on `/userguide/sohl-quickstart/`.
  * The caller supplies that mapping already resolved, in the index it builds.
  *
  * Lives here rather than in a consumer so every package resolves a link the

package/engine/wikilinks.mjs

@@ -36,7 +36,7 @@
  * Nothing narrower than `(type, shortcode)` is consulted — a note's directory
  * and its `category` play no part in resolution — and nothing wider: a note's
  * *name* is not an address, so two notes of a type may share a display name
- * ("Gear" as a rules page and as a user-guide page) with nothing to disambiguate
+ * ("Gear" as a rules page and as a user guide page) with nothing to disambiguate
  * (#179, #180).
  *
  * At compile time each becomes a Foundry UUID enricher, routed to the pack that

package/package.json

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

@@ -14,30 +14,6 @@ export function publishesContentPages(config: {
         site: SiteMode;
     };
 }): boolean;
-/**
- * Every URL section this repository names, in declaration order (#197).
- *
- * A section is *declared* by describing it: `site.sections` for one whose
- * landing this build generates, `site.readmeSections` for one whose landing is
- * a `README`. Between them they are the open set of addresses a repository
- * says it publishes under — which is what a `README` landing's `subType` names,
- * since `sectionOf` reads that field as the section rather than as a genre.
- *
- * Read from the same two maps the site build renders each landing from, so the
- * set a note is checked against and the set a landing is written from cannot
- * come to disagree. A repository that describes no section declares none, and
- * the answer is empty rather than a guess assembled from the tree.
- *
- * @param {{site: {sections: object, readmeSections: object}}} config - A
- *   resolved configuration.
- * @returns {readonly string[]} The section names, deduplicated.
- */
-export function declaredSections(config: {
-    site: {
-        sections: object;
-        readmeSections: object;
-    };
-}): readonly string[];
 /**
  * Validate and normalize a content configuration.
  *
@@ -80,28 +56,31 @@ export namespace DEFAULT_PATHS {
  */
 export const PACK_DOCUMENT_TYPES: readonly ["Actor", "Adventure", "Item", "JournalEntry", "Macro", "Scene"];
 /**
- * The landing-page rules a repository may route by.
- *
- * A *landing page* is a note that addresses a whole section rather than a page
- * within one, so it has no slug of its own. Which note that is differs between
- * repositories, and both live rules are represented here because switching
- * either one on for the other repository moves addresses that are already
- * published:
- *
- * - `readme` — a `README.md` **is** its section's landing page. This is `sohl`'s
- *   rule, and a `doc` note routes by its `category` like any other, so `sohl`'s
- *   eleven `category: collection` notes publish under a literal `collection/`
- *   section (`kb/collection/skills/`).
- * - `collection` — a `doc` note whose `category` is `collection` addresses the
- *   section it introduces, named by its authored `section`. This is `thalorna`'s
- *   rule, under which the same note publishes at `creature/`.
- *
- * The two are not disjoint and cannot simply both apply: each tree holds notes
- * the other rule would move.
- *
- * @type {readonly string[]}
+ * Address-scheme keys a configuration may no longer declare.
+ *
+ * A retired key has exactly two possible fates, and only one of them is honest
+ * — the same reasoning `engine/retired-fields.mjs` applies to a retired
+ * frontmatter field. Left honoured, it keeps doing whatever it did, which is
+ * why it was retired. Left *ignored*, it reads to its author as though it still
+ * works: the configuration says one thing and the build does another, and
+ * nothing says so. This module has no third option, because it has no warning
+ * channel — every finding goes through `fail()`, which throws. So a retired
+ * key is **refused**, at the line it was written on, with a message that says
+ * the mechanism is gone rather than naming a value to correct.
+ *
+ * **What `landing` did (#204).** It named which note addressed a whole section
+ * rather than a page within one — a *landing page*, which therefore had no slug
+ * of its own. #203 retired the second of its two rules and #204 retired the
+ * concept both rules chose between: a section is a Hugo content directory that
+ * the note format does not carry, a page's address names no directory, and so
+ * no note lands anything. The key outlived its mechanism by one release only
+ * because both publishing consumers still declared the then-true
+ * `landing: readme`, and neither breaking them over a correct statement nor
+ * accepting the key in silence was acceptable. Neither declares it now.
+ *
+ * @type {Readonly<Record<string, string>>}
  */
-export const LANDING_RULES: readonly string[];
+export const RETIRED_ADDRESS_KEYS: Readonly<Record<string, string>>;
 /**
  * A repository's address scheme, with the defaults an unconfigured one gets.
  *
@@ -111,10 +90,13 @@ export const LANDING_RULES: readonly string[];
  * own mount point: where the package itself is served is the consuming build's
  * knowledge, held in `PACKAGE_BASE` (`engine/kb-manifest.mjs`) and prefixed at
  * resolve time, so it is never recorded here (#1465).
+ *
+ * It is the whole scheme: `landing`, the key that named which note addressed a
+ * whole section, is retired with the sections themselves — see
+ * {@link RETIRED_ADDRESS_KEYS}.
  */
 export const DEFAULT_ADDRESS_SCHEME: Readonly<{
     prefix: "";
-    landing: "readme";
 }>;
 /**
  * How much of a package reaches the web.
@@ -529,10 +511,6 @@ export type AddressSchemeInput = {
      * Where the content tree mounts inside the package.
      */
     prefix?: string | undefined;
-    /**
-     * Which note addresses a whole section.
-     */
-    landing?: string | undefined;
 };
 /**
  * One entry of a consumer's `itemBuilders` registry.

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

@@ -1,14 +1,3 @@
-/**
- * The URL section a note routes to.
- *
- * A `doc` is narrative content whose only identity is its subtype label, so it
- * routes by `subType`; every other type names its own section.
- *
- * @param {object} fm - Parsed frontmatter.
- * @returns {string|undefined} The section, or `undefined` when the note has
- *   none — a `doc` with no subtype has no address and is not published.
- */
-export function sectionOf(fm: object): string | undefined;
 /**
  * The single path segment a note is addressed by: `type-shortcode`.
  *
@@ -34,15 +23,16 @@ export function addressSlug(fm: object): string;
 /**
  * A note's address below the knowledgebase mount, e.g. `affliction-aconite/`.
  *
- * A `README.md` **is** its section's landing page rather than a page within it,
- * so it addresses the section itself and has no address of its own.
+ * Every note, without exception. A `README.md` used to be its section's landing
+ * page and to address the section instead of itself; a section is a Hugo
+ * directory concept the note format no longer carries (#204), so a file's name
+ * decides nothing about where it publishes.
  *
  * @param {object} fm - Parsed frontmatter.
- * @param {boolean} isReadme - Whether the file is a `README.md`.
  * @returns {string} The mount-relative address, with a trailing slash.
  * @throws {Error} When the note has no address.
  */
-export function contentAddress(fm: object, isReadme: boolean): string;
+export function contentAddress(fm: object): string;
 /**
  * A note's address relative to its **package**, e.g. `affliction-aconite/`.
  *
@@ -51,43 +41,34 @@ export function contentAddress(fm: object, isReadme: boolean): string;
  * address the site does not publish resolves at build time and 404s for the
  * reader, which is the failure this module exists to prevent.
  *
+ * **It is a pure function of the frontmatter.** Nothing about the file the note
+ * was read from reaches it: the `README.md` convention that made one note
+ * address a whole section is retired with the section itself (#204), so there
+ * is one rule and no branch.
+ *
  * **The prefix does not apply to a page's own address.** `prefix` says where the
- * content tree *mounts inside the package* — where its section directories and
- * their landing pages live — and a landing page is addressed by that mount
- * (`kb/rules/`). An ordinary page is addressed by `(type, shortcode)`, which is
- * a package-wide identity and takes no mount: `sohl` publishes
- * `/sohl/affliction-aconite/` while its section landings stay at
- * `/sohl/kb/affliction/`. The `type-` half is what keeps that flat namespace
- * clear of the package's fixed mounts — `/<package>/` for the landing,
+ * content tree *mounts inside the package* — the Hugo directory its pages are
+ * written under — and an address is `(type, shortcode)`, a package-wide identity
+ * that takes no mount: `sohl` publishes `/sohl/affliction-aconite/` from a file
+ * written under `kb/`. The `type-` half is what keeps that flat namespace clear
+ * of the package's fixed mounts — `/<package>/` for the landing,
  * `/<package>/api/` for generated API docs, neither of which contains a hyphen
  * or names a type.
  *
- * **The section still decides where the *file* is written**, which is why a
- * note without one still has no address: Hugo derives a section from a page's
- * directory rather than from its URL, so a page with nowhere to be filed is a
- * page with no section landing, no `.CurrentSection` and no per-section layout.
+ * **It takes no address scheme.** It took one until #215, to validate the
+ * `landing` rule it then discarded; with that key retired, `prefix` was the
+ * only thing left in the scheme and the paragraph above is the reason it never
+ * applied. A parameter read by nothing is the defect this deletion is about.
  *
  * @param {object} fm - Parsed frontmatter.
- * @param {object} [options] - Options.
- * @param {boolean} [options.isReadme] - Whether the file is a `README.md`.
- * @param {{prefix?: string, landing?: string}} [options.scheme] - The
- *   repository's address scheme; defaults to {@link DEFAULT_ADDRESS_SCHEME}.
  * @returns {string} The package-relative address, with a trailing slash and no
  *   leading one.
- * @throws {Error} When the note has no address — no section, a landing page
- *   naming no section, or no shortcode to be addressed by. Each is a note that
- *   is not published, and inventing an address for one would put a dead entry
- *   in the manifest.
+ * @throws {Error} When the note has no type or no shortcode to be addressed by.
+ *   Such a note is not published, and inventing an address for one would put a
+ *   dead entry in the manifest.
  */
-export function packageAddress(fm: object, { isReadme, scheme }?: {
-    isReadme?: boolean | undefined;
-    scheme?: {
-        prefix?: string;
-        landing?: string;
-    } | undefined;
-}): string;
+export function packageAddress(fm: object): string;
+export { DEFAULT_ADDRESS_SCHEME };
 /** The knowledgebase's mount within this package's site (#1470). */
 export const KB_PREFIX: "kb/";
 import { DEFAULT_ADDRESS_SCHEME } from "../content-config.mjs";
-import { LANDING_RULES } from "../content-config.mjs";
-export { DEFAULT_ADDRESS_SCHEME, LANDING_RULES };

package/types/engine/frontmatter-lint.d.mts

@@ -29,22 +29,9 @@ export function matchesKind(value: unknown, kind: string): boolean;
  * @param {Readonly<Record<string, {known?: readonly string[], fieldVocabulary?: boolean}>>} [opts.systems]
  *   The system blocks to check, and what each accepts. See
  *   {@link DEFAULT_SYSTEM_BLOCKS}.
- * @param {string} [opts.landing] - The repository's landing rule, from
- *   `publish.address.landing`. It decides which note addresses a whole section,
- *   and so whether a `subType` is a genre or an address (#197).
- * @param {readonly string[]} [opts.types] - The content types the format
- *   declares — the sections that exist by construction (#200). Read from
- *   `docs/content-format.md` rather than from `schemas`, because the two answer
- *   different questions: whether an address is real, and whether this build can
- *   check a note's fields. A type the specification declares and no schema
- *   covers is a real section, and its notes are reported on their own account.
- * @param {readonly string[]} [opts.sections] - The sections the repository
- *   configures, from `declaredSections`. Supplied by the caller for the same
- *   reason `vocabulary` is: this module checks a note against what it is
- *   handed.
  * @returns {object[]} Findings, each with a locator where one is obtainable.
  */
-export function lintNote(note: object, { schemas, index, vocabulary, systems, landing, types, sections, }: {
+export function lintNote(note: object, { schemas, index, vocabulary, systems }: {
     schemas: Record<string, readonly object[]>;
     index?: object | undefined;
     vocabulary?: Record<string, object> | undefined;
@@ -52,9 +39,6 @@ export function lintNote(note: object, { schemas, index, vocabulary, systems, la
         known?: readonly string[];
         fieldVocabulary?: boolean;
     }>> | undefined;
-    landing?: string | undefined;
-    types?: readonly string[] | undefined;
-    sections?: readonly string[] | undefined;
 }): object[];
 /**
  * Check every note in a built index against its type's schema.
@@ -67,16 +51,10 @@ export function lintNote(note: object, { schemas, index, vocabulary, systems, la
  * @param {boolean} [opts.references=true] - Whether to check references.
  * @param {Readonly<Record<string, {known?: readonly string[], fieldVocabulary?: boolean}>>} [opts.systems]
  *   The system blocks to check. See {@link DEFAULT_SYSTEM_BLOCKS}.
- * @param {string} [opts.landing] - The repository's landing rule; see
- *   {@link lintNote}.
- * @param {readonly string[]} [opts.types] - The content types the format
- *   declares; see {@link lintNote}.
- * @param {readonly string[]} [opts.sections] - The sections the repository
- *   configures; see {@link lintNote}.
  * @returns {{findings: object[], notes: number}} The findings, and how many
  *   notes were inspected.
  */
-export function lintFrontmatter(index: object, { schemas, vocabulary, references, systems, landing, types, sections }: {
+export function lintFrontmatter(index: object, { schemas, vocabulary, references, systems }: {
     schemas: Record<string, readonly object[]>;
     vocabulary?: Record<string, object> | undefined;
     references?: boolean | undefined;
@@ -84,9 +62,6 @@ export function lintFrontmatter(index: object, { schemas, vocabulary, references
         known?: readonly string[];
         fieldVocabulary?: boolean;
     }>> | undefined;
-    landing?: string | undefined;
-    types?: readonly string[] | undefined;
-    sections?: readonly string[] | undefined;
 }): {
     findings: object[];
     notes: number;

package/types/engine/manifest-emit.d.mts

@@ -51,8 +51,7 @@ export function entriesForNote(fm: object, name: string, address: string, body:
  * exist.
  *
  * @param {string} contentBase - Absolute path to the content tree.
- * @param {object} ctx - `{ contentPackage, foundryPackageId, packRouter,
- *   scheme }`.
+ * @param {object} ctx - `{ contentPackage, foundryPackageId, packRouter }`.
  * @returns {{entries: Array<object>, notes: number,
  *   skipped: Array<{file: string, reason: string}>}}
  */
@@ -65,7 +64,7 @@ export function collectManifestEntries(contentBase: string, ctx: object): {
     }>;
 };
 /**
- * The identities and scheme an emission runs against, from configuration.
+ * The identities an emission runs against, from configuration.
  *
  * Resolved in one place and passed down, rather than read at each use, so the
  * pass itself is a pure function of its context and a test can drive it without
@@ -73,17 +72,12 @@ export function collectManifestEntries(contentBase: string, ctx: object): {
  *
  * @param {object} [config] - A resolved configuration; loaded when omitted.
  * @returns {{contentPackage: string, foundryPackageId: string, packRouter: object,
- *   scheme: {prefix: string, landing: string}, web: boolean,
- *   skipDirectories: readonly string[]}}
+ *   web: boolean, skipDirectories: readonly string[]}}
  */
 export function manifestContext(config?: object): {
     contentPackage: string;
     foundryPackageId: string;
     packRouter: object;
-    scheme: {
-        prefix: string;
-        landing: string;
-    };
     web: boolean;
     skipDirectories: readonly string[];
 };