@heroiclands/package-build 11.1.0 → 14.0.0

package/content-config.mjs

@@ -68,7 +68,7 @@ import path from "node:path";
 
 // Leaves with no local imports of their own, so naming them here cannot close
 // a cycle around a consumer's config file (see `engine/pack-config.mjs`).
-import { isAddressSegment } from "./engine/address-charset.mjs";
+import { ADDRESS_SEGMENT_PATTERN, isAddressSegment } from "./engine/address-charset.mjs";
 import { MAP_TYPES, PACK_BY_TYPE } from "./engine/ids.mjs";
 
 /**
@@ -116,28 +116,38 @@ export const PACK_DOCUMENT_TYPES = /** @type {const} */ ([
 ]);
 
 /**
- * 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 = Object.freeze(["readme", "collection"]);
+export const RETIRED_ADDRESS_KEYS = Object.freeze({
+    landing:
+        "is a retired option — delete it. It named which note addressed a " +
+        "whole section rather than a page within one, and there are no " +
+        "sections to address: a section is a Hugo content directory the note " +
+        "format does not carry, so no note lands one and every page is " +
+        "addressed `<type>-<shortcode>`. Nothing replaces it",
+});
 
 /**
  * A repository's address scheme, with the defaults an unconfigured one gets.
@@ -148,10 +158,13 @@ export const LANDING_RULES = Object.freeze(["readme", "collection"]);
  * 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 = Object.freeze({
     prefix: "",
-    landing: "readme",
 });
 
 /**
@@ -210,34 +223,6 @@ export function publishesContentPages(config) {
     return config.publish.site === "content";
 }
 
-/**
- * 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) {
-    const site = config?.site ?? {};
-    return Object.freeze([
-        ...new Set([
-            ...Object.keys(site.sections ?? {}),
-            ...Object.keys(site.readmeSections ?? {}),
-        ]),
-    ]);
-}
-
 /**
  * @typedef {"systems" | "modules"} PackageKind
  */
@@ -480,8 +465,7 @@ export function declaredSections(config) {
 
 /**
  * @typedef {object} AddressSchemeInput
- * @property {string} [prefix]   Where the content tree mounts inside the package.
- * @property {string} [landing]  Which note addresses a whole section.
+ * @property {string} [prefix]  Where the content tree mounts inside the package.
  */
 
 /**
@@ -665,7 +649,7 @@ const SITE_KEYS = [
     "backfillSections",
 ];
 const SITE_TREE_KEYS = ["from", "section"];
-const SECTION_META_KEYS = ["title", "banner", "description"];
+const SECTION_META_KEYS = ["title", "banner", "description", "listType", "listSubType"];
 const DOC_PAGE_KEYS = ["title", "out", "preamble"];
 const RELATIONSHIP_KINDS = ["systems", "requires", "recommends", "conflicts"];
 const RELATIONSHIP_KEYS = ["id", "type", "manifest", "compatibility", "itemCatalog"];
@@ -702,7 +686,7 @@ const STATS_KEYS = ["lastModifiedBy"];
 export const DERIVED_SYSTEM_VERSION = Symbol.for("package-build.derivedSystemVersion");
 const PUBLISH_KEYS = ["site", "manifests", "address"];
 const MANIFEST_KEYS = ["publish", "consume"];
-const ADDRESS_KEYS = ["prefix", "landing"];
+const ADDRESS_KEYS = ["prefix"];
 
 /** @param {unknown} value */
 function isPlainObject(value) {
@@ -1120,10 +1104,11 @@ function normalizeDocs(value) {
  * One section's landing metadata — what a section says about itself on the
  * `_index.md` this build generates for it.
  *
- * A generated landing is the *only* place a section can speak: a content
- * package has no authored `_index.md` for `weapongear` or `affliction`, so the
- * file the theme reads is the one the site build writes. This is therefore the
- * whole vocabulary, and it is deliberately a **closed** one.
+ * A generated landing is the *only* place a section can speak, and since #204 it
+ * is the only place a section **exists**: a content page is addressed
+ * `(type, shortcode)` and written flat under the mount, so no page creates a
+ * directory and nothing else makes `<prefix><section>/` answer. This is
+ * therefore the whole vocabulary, and it is deliberately a **closed** one.
  *
  * The alternative — passing whatever a section declared straight through, as
  * `site.landing` does — was weighed and refused. `landing` is written once, for
@@ -1140,9 +1125,36 @@ function normalizeDocs(value) {
  * add to its title. Each is left off entirely rather than written as
  * `undefined`, which is not a value YAML can carry.
  *
+ * **`listType` / `listSubType` say what the section lists**
+ * (heroiclands-hugo-theme#50). Since #204 a section's directory holds nothing
+ * but the `_index.md` written here, so a layout reading Hugo's `.Pages` finds
+ * no members and renders an empty landing. The membership survives in this map
+ * and nowhere a theme can reach it, so the landing states it and a layout
+ * substitutes the equivalent `site.RegularPages` query — the same one `sohl`'s
+ * catalog layouts already run, which is why `sohl`'s landings never broke.
+ *
+ * They are two keys of their own rather than `type` / `subType` because `type`
+ * on an `_index.md` is **Hugo's own layout selector**: verified against Hugo
+ * 0.165, a section landing carrying `type: doc` renders through
+ * `layouts/doc/list.html` rather than the default list template, so spelling
+ * the content type there would silently change which template serves the
+ * landing. (This build already uses that behaviour deliberately, for the
+ * mount's own landing.)
+ *
+ * Both are checked as **address segments**, which is the trap this came from:
+ * a section is named for the URL a consumer chose and a subType is an address
+ * segment, and the two need not agree — `/sohl/kb/user-guide/` is the section,
+ * `userguide` the subType (#207). Copying the section's name into the
+ * declaration would select no page at all, and an empty landing reported by
+ * nobody is the failure being fixed. A `listSubType` with no `listType` is
+ * refused for the same reason: a subType is only distinguishing *within* a
+ * type — `rules`, `userguide` and `reference` are all `doc` — so alone it names
+ * no query.
+ *
  * @param {unknown} value - The declared entry.
  * @param {string} where - Dotted path, for the error.
- * @returns {Readonly<{title: string, banner?: string, description?: string}>}
+ * @returns {Readonly<{title: string, banner?: string, description?: string,
+ *   listType?: string, listSubType?: string}>}
  */
 function normalizeSectionMeta(value, where) {
     if (!isPlainObject(value)) fail(where, "must be a mapping");
@@ -1155,6 +1167,32 @@ function normalizeSectionMeta(value, where) {
     if (input.description !== undefined) {
         out.description = requireNonEmptyString(input.description, `${where}.description`);
     }
+    for (const key of ["listType", "listSubType"]) {
+        if (input[key] === undefined) continue;
+        const segment = requireNonEmptyString(input[key], `${where}.${key}`);
+        if (!isAddressSegment(segment)) {
+            fail(
+                `${where}.${key}`,
+                `is \`${segment}\`, which is not alphanumeric. It names a ` +
+                    "content type or subType, and those are address segments " +
+                    `(${ADDRESS_SEGMENT_PATTERN.source}) — not the section's ` +
+                    "own name, which is a URL this site chose and need not " +
+                    "match (`user-guide` is the section, `userguide` the " +
+                    "subType). A value no page carries selects nothing and " +
+                    "leaves the landing empty",
+            );
+        }
+        out[key] = segment;
+    }
+    if (out.listSubType !== undefined && out.listType === undefined) {
+        fail(
+            `${where}.listSubType`,
+            "is declared without a `listType`. A subType tells pages apart " +
+                "only within a type — `rules`, `userguide` and `reference` " +
+                "are all `doc` — so on its own it names no query for a layout " +
+                "to run",
+        );
+    }
     return Object.freeze(out);
 }
 
@@ -1737,6 +1775,15 @@ function normalizePublish(value) {
         fail("publish.address", "must be an object");
     }
     const address = /** @type {Record<string, unknown>} */ (addressInput ?? {});
+    // A retired key is refused by name, ahead of the vocabulary check: reported
+    // as merely unrecognized it would read as a misspelling of the one key that
+    // survives, and the author would correct the spelling rather than learn
+    // that the mechanism is gone (#215).
+    for (const key of Object.keys(address)) {
+        if (Object.hasOwn(RETIRED_ADDRESS_KEYS, key)) {
+            fail(`publish.address.${key}`, RETIRED_ADDRESS_KEYS[key]);
+        }
+    }
     rejectUnknownKeys(address, ADDRESS_KEYS, "publish.address.");
 
     const prefix =
@@ -1755,17 +1802,9 @@ function normalizePublish(value) {
         fail("publish.address.prefix", "must not begin with a slash");
     }
 
-    const landing =
-        address.landing === undefined ?
-            DEFAULT_ADDRESS_SCHEME.landing
-        :   optionalString(address.landing, "publish.address.landing");
-    if (!LANDING_RULES.includes(landing)) {
-        fail("publish.address.landing", `must be one of ${LANDING_RULES.join(", ")}`);
-    }
-
     return Object.freeze({
         site: normalizeSiteMode(publish.site),
-        address: Object.freeze({ prefix, landing }),
+        address: Object.freeze({ prefix }),
         manifests: Object.freeze({
             publish: optionalBoolean(manifests.publish, "publish.manifests.publish", false),
             consume: optionalBoolean(manifests.consume, "publish.manifests.consume", false),

package/docs/content-format.md

@@ -233,10 +233,32 @@ field to supply it, so a bare shortcode is resolved across types and must match
 exactly one; an ambiguity is an error naming the candidates.
 
 **Parsing is positional counting from the right, and nothing else.** Every
-segment is alphanumeric — shortcodes are `^[A-Za-z0-9]+$`, types are bare words,
-systems come from a closed registry, and `contentPackage` is alphanumeric — so
-the hyphen is purely a separator. There is no longest-match against a roster and
-no vocabulary check before splitting.
+segment is alphanumeric — shortcodes, **types** and **subTypes** are all
+`^[A-Za-z0-9]+$`, systems come from a closed registry, and `contentPackage` is
+alphanumeric — so the hyphen is purely a separator. There is no longest-match
+against a roster and no vocabulary check before splitting.
+
+**`type` and `subType` are held to that charset, not merely expected to meet
+it** (#206). A type is the first segment of every address, so a hyphen in one is
+read back as a segment boundary that was never meant as one. A `subType` reaches
+no address since #204 retired sections, but it is held to the same rule all the
+same: it is a vocabulary term the whole toolchain keys on, one closed set away
+from being an address again, and a charset that holds for two of the three
+segments and half of a fourth is a rule nobody can state. Both are checked
+against the same constant a shortcode is checked against, and a note carrying a
+hyphenated value is reported where it wrote it:
+
+```text
+Trauma/Blood_Loss.md:3:1: error: `subType` "blood-loss" is not a well-formed subType — a subType is letters and digits only (^[A-Za-z0-9]+$), the same charset a type, a shortcode and a contentPackage are held to. It is a vocabulary term the whole toolchain keys on, and one closed set away from being an address segment again, so a charset that held for every term but this one would be a rule nobody could state in a sentence
+```
+
+One declared value broke the rule and has been renamed: a `doc`'s `user-guide`
+is now **`userguide`**. The old spelling was accepted for one transitional
+release, as a warning naming the replacement, so the 43 `sohl` notes authoring
+it were not invalidated by the release that renamed them. Every consumer tree
+has swept, so the acceptance is gone (#210) and `user-guide` is refused by the
+charset check — it contains a hyphen, which is the reason that always applied.
+No retirement-specific code outlived the sweep.
 
 That is a guarantee rather than an observation, and it holds: of **4,456 distinct
 shortcodes** across the four content trees, not one contains a character outside
@@ -267,7 +289,7 @@ was measured before it was retired, and the namespace was empty in practice:
 across 8,305 wikilinks in three content trees, **not one** bare link resolved to
 a note. What the index behind it did do was fold every note's `name.full` into
 itself, so two notes of one type could not share a display name — a rules page
-and a user-guide page both called "Gear" were a build failure whose every
+and a user guide page both called "Gear" were a build failure whose every
 available fix moved a published URL (#179).
 
 The top-level `aliases:` that fed it is **retired** and refused. The nested
@@ -1356,29 +1378,30 @@ subType:
 subType:
 
 - rules: The rules of the game, independent of medium — valid at a table with paper and dice.
-- user-guide: How to operate the Foundry implementation to play by the rules.
+- userguide: How to operate the Foundry implementation to play by the rules.
 - reference: Out-of-world lookup material about the setting or system — correspondences, conversions, glossaries.
-- collection: A note whose content is **derived from the tree** — a roster, a table of
-  settlements, an index of languages, almost always a query. It differs from `reference` in
-  where its content comes from, not in who reads it: a reference **states** facts of its own,
-  and a collection **derives** them. The author's test is whether the page would still say
-  anything if every other note vanished. A collection can therefore collect nothing and still
-  render — an empty table looks exactly like a full one until you read it — which is the
-  failure this value exists to make nameable.
-
-| `data` property | Values   | Description                                                                                               |
-| --------------- | -------- | --------------------------------------------------------------------------------------------------------- |
-| `section`       | `string` | For a `collection` only: the URL segment of the section it heads. Omit it and the note's own slug is used |
-
-**`section` is the segment, not a label.** A collection is a section's landing
-page, so what it names is where that section lives — and two collections may not
-claim the same one. A collection that lists a _subset_ of a section therefore
-names none: five of `sohl-thalorna`'s list places and three list affiliations, and
-each falls back to its own slug rather than fighting over `/place/`.
-
-It is authored rather than derived because the note's own title is presentation:
-a collection called "Creatures" heads the `being` section, and slugging the title
-would put it somewhere else.
+
+A `doc` declares no properties of its own.
+
+**A page that introduces a type is an ordinary note, named by convention.**
+Write `type: doc`, `subType: reference`, `shortcode: <type>` — so the
+affiliations introduction is `doc-affiliation`, addressed and linked like
+anything else, and typically carrying a generated table of what it introduces.
+It has no build path of its own; the package's own front page already works this
+way (`homepage-root`).
+
+There is no landing page and no section. A `README.md` used to _be_ its
+section's landing, and a `subType: collection` note with a top-level `section:`
+key was a second way to say the same thing. All of it is retired — the second
+rule in #202, the first in #204 — because a section appears in **no address**: a
+page publishes at `/<package>/<type>-<shortcode>/`, which names no directory. A
+section is what Hugo calls a content directory, and the note format does not
+carry one.
+
+So a `doc`'s `subType` is a **genre** and nothing else, closed to the three
+values above. It briefly had to accept a content type as well, because a
+landing's `subType` named the section it addressed; with no landings, one field
+has one reading again.
 
 ### type: macro
 

package/engine/base-compiler.mjs

@@ -77,7 +77,11 @@ import {
 } from "./helpers.mjs";
 import { emitDiagnostic } from "./diagnostics.mjs";
 import { assertNoDeclaredPackage } from "./note-package.mjs";
-import { assertNoAliasesField, assertNoDraftField } from "./retired-fields.mjs";
+import {
+    assertNoAliasesField,
+    assertNoDraftField,
+    assertNoSectionField,
+} from "./retired-fields.mjs";
 import { assertTypeNotRetired, packForType } from "./ids.mjs";
 import { carriesSystemBlock } from "./system-block.mjs";
 import { checkAuthoredSystemData, checkEmittedSystemData } from "./schema-check.mjs";
@@ -784,6 +788,7 @@ export class BasePackCompiler {
                 assertNoDeclaredPackage(fm, { absPath });
                 assertNoDraftField(fm, { absPath });
                 assertNoAliasesField(fm, { absPath });
+                assertNoSectionField(fm, { absPath });
             } catch (err) {
                 stats.declined++;
                 this.errorCount++;

package/engine/content-address.mjs

@@ -32,30 +32,16 @@
 // The scheme vocabulary is part of the configuration contract — a
 // repository names its scheme in `package-build.config.yaml` — so it is
 // declared beside the rest of that vocabulary rather than here, and this
-// module reads it. `config.mjs` is the leaf entry point and imports nothing
-// but `node:path` and `engine/ids.mjs`, so the direction cannot close a
-// cycle (see `engine/pack-config.mjs`).
-import { DEFAULT_ADDRESS_SCHEME, LANDING_RULES } from "../content-config.mjs";
+// module re-exports it beside the addresses it derives. `config.mjs` is the
+// leaf entry point and imports nothing but `node:path` and `engine/ids.mjs`,
+// so the direction cannot close a cycle (see `engine/pack-config.mjs`).
+import { DEFAULT_ADDRESS_SCHEME } from "../content-config.mjs";
 
-export { DEFAULT_ADDRESS_SCHEME, LANDING_RULES };
+export { DEFAULT_ADDRESS_SCHEME };
 
 /** The knowledgebase's mount within this package's site (#1470). */
 export const KB_PREFIX = "kb/";
 
-/**
- * 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) {
-    return fm.type === "doc" ? fm.subType : fm.type;
-}
-
 /**
  * The single path segment a note is addressed by: `type-shortcode`.
  *
@@ -95,40 +81,17 @@ export function addressSlug(fm) {
 /**
  * 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, isReadme) {
-    return isReadme ? `${sectionOf(fm)}/` : `${addressSlug(fm)}/`;
-}
-
-/**
- * Whether a note is a landing page under a scheme, and what it lands at.
- *
- * @param {object} fm - Parsed frontmatter.
- * @param {boolean} isReadme - Whether the file is a `README.md`.
- * @param {string} landing - The landing rule, one of {@link LANDING_RULES}.
- * @returns {{landing: true, segment: string}|{landing: false}|{landing: true, segment: undefined}}
- *   `segment` is the single path segment the note addresses. A `collection`
- *   note that declares no `section` is a landing page with no segment — an
- *   error rather than a page, since it names nowhere to land.
- */
-function landingOf(fm, isReadme, landing) {
-    if (landing === "readme") {
-        return isReadme ? { landing: true, segment: sectionOf(fm) } : { landing: false };
-    }
-    // `collection`. The section is authored rather than derived: it is the
-    // identity of the section being introduced, and the note's own title
-    // ("Creatures") is presentation, which would slug to something else.
-    if (fm.type === "doc" && fm.subType === "collection") {
-        return { landing: true, segment: fm.section || fm.slug };
-    }
-    return { landing: false };
+export function contentAddress(fm) {
+    return `${addressSlug(fm)}/`;
 }
 
 /**
@@ -139,52 +102,32 @@ function landingOf(fm, isReadme, landing) {
  * 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, { isReadme = false, scheme } = {}) {
-    const { prefix, landing } = { ...DEFAULT_ADDRESS_SCHEME, ...scheme };
-    if (!LANDING_RULES.includes(landing)) {
-        throw new Error(
-            `unknown landing rule ${JSON.stringify(landing)} — expected one ` +
-                `of ${LANDING_RULES.join(", ")}`,
-        );
-    }
-    const land = landingOf(fm, isReadme, landing);
-    if (land.landing) {
-        if (typeof land.segment !== "string" || !land.segment) {
-            throw new Error(`landing note declares no section, so it lands nowhere`);
-        }
-        return `${prefix}${land.segment}/`;
-    }
-    const sec = sectionOf(fm);
-    if (typeof sec !== "string" || !sec) {
-        throw new Error(`type "${fm.type}" has no section`);
-    }
+export function packageAddress(fm) {
     return `${addressSlug(fm)}/`;
 }