@heroiclands/package-build 3.4.0 → 5.0.0

package/engine/site-build.mjs

@@ -62,7 +62,14 @@ import {
 } from "./foreign-manifests.mjs";
 import { deriveBeingInfo, isBeing } from "../sohl/being-info.mjs";
 import { loadPackConfig } from "./pack-config.mjs";
-import { notePackage, searchableFrontmatter } from "./note-package.mjs";
+import { searchableFrontmatter } from "./note-package.mjs";
+import {
+    HOMEPAGE_DESTINATION,
+    homepageFrontmatter,
+    homepageTitle,
+    isHomepage,
+} from "./homepage.mjs";
+import { publishesContentPages } from "../content-config.mjs";
 
 const require = createRequire(import.meta.url);
 
@@ -132,12 +139,15 @@ export function collectContentPages(contentBase, ctx) {
         const note = readNote(file);
         if (!note) continue;
         const { fm, body } = note;
-        // Derived rather than read: `package:` is optional, and a note that
-        // declares nothing belongs to the package this repository compiles
-        // (#56). Once the field is retired outright this collapses to
-        // `ctx.contentPackage` and the set membership becomes a formality.
-        const pkg = notePackage(fm, ctx.contentPackage);
+        // The configuration's, never a note's: `package:` is retired, so every
+        // note in the tree belongs to the package this repository compiles
+        // (#56).
+        const pkg = ctx.contentPackage;
         if (!ctx.packages.has(pkg) || !fm.type) continue;
+        // A homepage is addressed by the *package*, not by its own name, so it
+        // never takes a section and a slug (#51). {@link collectHomepages}
+        // gathers it instead.
+        if (isHomepage(fm)) continue;
 
         for (const hit of frontmatterWikilinks(fm)) {
             fmLinkFindings.push({ file, ...hit });
@@ -162,9 +172,9 @@ export function collectContentPages(contentBase, ctx) {
         pages.push({
             kind: "content",
             fm,
-            // The page's package, resolved once here so every consumer — the
+            // The page's package, recorded once here so every consumer — the
             // index's canonical keys, the table universe, the local-package set
-            // — reads one derived value instead of frontmatter (#56).
+            // — reads one configured value and never frontmatter (#56).
             pkg,
             body,
             name,
@@ -250,6 +260,62 @@ export function collectTreePages(tree, ctx) {
     return { pages, fmLinkFindings };
 }
 
+/**
+ * The package's homepage notes — the authored page at `/<contentPackage>/`.
+ *
+ * A separate walk from {@link collectContentPages} rather than a branch inside
+ * it, because in homepage-only mode it is the **whole** of the site build: the
+ * content tree is never read for pages at all, so the licensing constraint two
+ * packages ship under is a property of the code path rather than of a
+ * configuration that happens to be empty (#55).
+ *
+ * Returned as a list rather than as the one note there should be. Requiring
+ * exactly one is #52's, and it is a separate decision — this reports what it
+ * found so a count is visible either way.
+ *
+ * @param {string} contentBase - Absolute path to the content tree.
+ * @param {object} ctx - `{ skipDirectories }`.
+ * @returns {{pages: object[]}} The homepage notes, in walk order.
+ */
+export function collectHomepages(contentBase, ctx) {
+    const pages = [];
+    for (const file of walkSiteTree(contentBase, ctx.skipDirectories)) {
+        const note = readNote(file);
+        if (!note || !isHomepage(note.fm)) continue;
+        pages.push({ kind: "homepage", file, fm: note.fm, body: note.body });
+    }
+    return { pages };
+}
+
+/**
+ * Writes each homepage at the package's own root.
+ *
+ * Its own writer, deliberately small. A homepage is authored markdown published
+ * verbatim — no table expansion, no section landing, and (until #54) no link
+ * resolution — so routing it through {@link renderPages} would buy it a pipeline
+ * it has no input for, and would make homepage-only mode depend on the index,
+ * the foreign manifests and the table universe that mode exists to not build.
+ *
+ * @param {string} outRoot - The package's site root — the configured `site.out`,
+ *   one level above the content mount.
+ * @param {readonly object[]} pages - From {@link collectHomepages}.
+ * @param {object} config - The resolved configuration, for the package name and
+ *   the default title.
+ * @returns {number} How many pages were written.
+ */
+export function writeHomepages(outRoot, pages, config) {
+    for (const page of pages) {
+        const data = homepageFrontmatter(page.fm, {
+            contentPackage: config.contentPackage,
+            title: homepageTitle(page.fm, config),
+        });
+        const dest = path.join(outRoot, HOMEPAGE_DESTINATION);
+        fs.mkdirSync(path.dirname(dest), { recursive: true });
+        fs.writeFileSync(dest, matter.stringify(page.body, data));
+    }
+    return pages.length;
+}
+
 /**
  * The integrity gates a site build runs before it writes anything.
  *
@@ -319,6 +385,30 @@ export function siteGates(pages, findings, { manifestDir }) {
     return out;
 }
 
+/**
+ * The gate result of a build that ran none of them.
+ *
+ * Homepage-only publishes one authored page and resolves nothing, so every gate
+ * here is about a surface that mode does not have. The shape is returned all the
+ * same, because a caller reads the same fields whichever mode ran and a `null`
+ * would make each of them a special case.
+ *
+ * @returns {object} An all-clear gate result.
+ */
+export function emptyGates() {
+    return {
+        frontmatterLinks: [],
+        slugErrors: [],
+        collisions: [],
+        staleManifests: [],
+        unaddressable: [],
+        conflicts: [],
+        index: null,
+        foreign: null,
+        manifests: null,
+    };
+}
+
 /** Whether any gate produced a finding. */
 export function gatesFailed(gates) {
     return Boolean(
@@ -347,7 +437,8 @@ export function tableUniverse(pages) {
         const pkg = p.pkg;
         if (!byPackage.has(pkg)) byPackage.set(pkg, []);
         byPackage.get(pkg).push({
-            // Package present however the note spells it — see
+            // Package present for a `WHERE … package = "…"` clause,
+            // synthesised rather than authored — see
             // {@link searchableFrontmatter} (#56).
             fm: searchableFrontmatter(p.fm, pkg),
             path: p.relPath,
@@ -367,10 +458,10 @@ export function tableUniverse(pages) {
  * redirect stub at each name. They are dropped, and this build emits no
  * redirects of its own.
  *
- * A content page carries the package the build **derived**, whether or not the
- * note declared one (#65). `package:` became optional in 3.3.0, so a swept tree
- * declares none — and the note's frontmatter alone would then publish a page
- * that does not say which package it belongs to. The emitted page is what a
+ * A content page carries the package the build **derived** (#65). No note
+ * declares one — `package:` is retired (#56) — so the note's frontmatter alone
+ * would publish a page that does not say which package it belongs to. The
+ * emitted page is what a
  * theme reads: `breadcrumbs.html` builds its middle crumb from
  * `.Params.package`, so without it that crumb degrades from a linked, labelled
  * section to a bare type slug. Writing the derived value keeps a page
@@ -387,10 +478,8 @@ export function pageFrontmatter(page, { readmeSections = {}, decorate }) {
     if (page.kind === "content") {
         data = {
             ...fm,
-            // Spread after the note's own frontmatter, so a note that declares
-            // the field keeps its authored position and value and an unswept
-            // tree emits byte-identically. Guarded because `package: undefined`
-            // is not a value YAML can carry.
+            // Spread after the note's own frontmatter. Guarded because
+            // `package: undefined` is not a value YAML can carry.
             ...(page.pkg ? { package: page.pkg } : {}),
             slug,
             title: fm.title ?? name,
@@ -708,6 +797,10 @@ export function buildSite({ config, outRoot } = {}) {
     const resolved = config ?? loadPackConfig();
     const site = resolved.site;
     const scheme = resolved.publish.address;
+    // Homepage-only or homepage-plus-content (#55). The floor is the homepage,
+    // so this decides whether the *content* surfaces are published, never
+    // whether anything is.
+    const publishesContent = publishesContentPages(resolved);
 
     // Where the package is served, and where its content mounts inside it. The
     // two are separate facts: `base` is the package's own address on the site
@@ -724,9 +817,16 @@ export function buildSite({ config, outRoot } = {}) {
     // directory it was launched from (#1508).
     const outBase = resolveOutputRoot(resolved.rootDir, site.out);
     const out =
-        outRoot ?
-            path.resolve(outRoot)
-        :   path.join(outBase, scheme.prefix.replace(/\/$/, ""));
+        outRoot ? path.resolve(outRoot)
+        : publishesContent ?
+            path.join(outBase, scheme.prefix.replace(/\/$/, ""))
+            // Homepage-only has no content mount, so the package's root *is*
+            // the output root and `--out` redirects the whole of it.
+        :   outBase;
+    // The homepage publishes at `/<contentPackage>/`, which is the package's
+    // own root — one level above the content mount, and the same directory in
+    // homepage-only mode.
+    const homeRoot = publishesContent ? outBase : out;
 
     const packages = new Set(
         site.packages.length ? site.packages : [resolved.contentPackage],
@@ -734,7 +834,8 @@ export function buildSite({ config, outRoot } = {}) {
 
     const ctx = {
         packages,
-        // What a note that declares no `package:` belongs to (#56).
+        // The package every note in the tree belongs to. `package:` is
+        // retired, so this is the only source of it (#56).
         contentPackage: resolved.contentPackage,
         skipDirectories: resolved.skipDirectories,
         mount,
@@ -745,6 +846,25 @@ export function buildSite({ config, outRoot } = {}) {
     // note was deleted or renamed would otherwise linger and keep publishing.
     fs.rmSync(outBase, { recursive: true, force: true });
 
+    const homepages = collectHomepages(resolved.paths.content, ctx).pages;
+
+    // Homepage-only stops here, and stopping is the point: nothing below reads
+    // the content tree for pages, so `sohl-kethira-basic` and `harn-adventures`
+    // cannot publish one whatever else their `site:` block declares (#55).
+    if (!publishesContent) {
+        return {
+            gates: emptyGates(),
+            manifests: null,
+            tableErrors: [],
+            wikiErrors: [],
+            stats: {
+                homepages: writeHomepages(homeRoot, homepages, resolved),
+                landings: 0,
+                out: homeRoot,
+            },
+        };
+    }
+
     const content = collectContentPages(resolved.paths.content, ctx);
     const pages = [...content.pages];
     const fmLinkFindings = [...content.fmLinkFindings];
@@ -805,12 +925,21 @@ export function buildSite({ config, outRoot } = {}) {
         sectionTitle: site.backfillSections ? pluralTitle : null,
     });
 
+    // Last, and outside the mount: the package's front page is not part of the
+    // content tree it introduces.
+    const homepagesWritten = writeHomepages(homeRoot, homepages, resolved);
+
     return {
         gates,
         manifests: gates.manifests,
         tableErrors: rendered.tableErrors,
         wikiErrors: rendered.wikiErrors,
-        stats: { ...rendered.byKind, landings, out },
+        stats: {
+            ...rendered.byKind,
+            homepages: homepagesWritten,
+            landings,
+            out,
+        },
     };
 }
 

package/engine/site-index.mjs

@@ -53,7 +53,7 @@ import path from "node:path";
 
 import { canonicalKey, readCanonicalKey } from "./kb-manifest.mjs";
 import { hasDocEntry } from "./item-docs.mjs";
-import { notePackage } from "./note-package.mjs";
+import { contentPackage } from "./content-package.mjs";
 
 /**
  * One page the site will publish, as the index needs to see it.
@@ -239,11 +239,11 @@ export function buildSiteIndex(entries, { foreignIndex = new Map() } = {}) {
             // stays because a bare `[[skill-lang]]` defaults to the citing
             // note's own package and must keep resolving unchanged; the
             // canonical form is what cross-package links use (#1499).
-            // The page's package is derived — the site collection resolves it
-            // and records it as `pkg` — rather than read out of frontmatter,
-            // where `package:` is optional and on its way out (#56).
+            // The page's package is the configured one — the site collection
+            // resolves it and records it as `pkg`. Never read out of
+            // frontmatter: `package:` is retired (#56).
             index.set(
-                canonicalKey(e.pkg ?? notePackage(e.fm), type, shortcode),
+                canonicalKey(e.pkg ?? contentPackage(), type, shortcode),
                 value,
             );
             // In Foundry an item and its documentation are two documents, so

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@heroiclands/package-build",
-    "version": "3.4.0",
+    "version": "5.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/sohl/actors.mjs

@@ -34,9 +34,8 @@
  * driven by `packages/content-build/engine/generate.mjs` (via `npm run build:compiledb`). Must run
  * after the items pass, since it reads the items pack's generated JSON tree.
  *
- * The walk itself — filtering by package and type, skipping drafts,
- * expanding tables, converting wikilinks, writing the JSON and counting
- * errors — belongs to {@link sohl.utils.packs.BasePackCompiler}; this module
+ * The walk itself — filtering by type, expanding tables, converting
+ * wikilinks, writing the JSON and counting errors — belongs to {@link sohl.utils.packs.BasePackCompiler}; this module
  * states only what makes this pass its own (#1509).
  */
 

package/sohl/items.mjs

@@ -29,9 +29,8 @@
  * Not a standalone script — exports the `Items` compiler class, imported and
  * driven by `packages/content-build/engine/generate.mjs` (via `npm run build:compiledb`).
  *
- * The walk itself — filtering by package and type, skipping drafts,
- * expanding tables, converting wikilinks, writing the JSON and counting
- * errors — belongs to {@link sohl.utils.packs.BasePackCompiler}; this module
+ * The walk itself — filtering by type, expanding tables, converting
+ * wikilinks, writing the JSON and counting errors — belongs to {@link sohl.utils.packs.BasePackCompiler}; this module
  * states only what makes this pass its own (#1509).
  */
 

package/sohl/note-schemas.mjs

@@ -38,6 +38,7 @@
  */
 
 import { AS_AUTHORED, NUMBER, STRING } from "../engine/field-spec.mjs";
+import { ENGINE_NOTE_SCHEMAS } from "../engine/note-schemas.mjs";
 import { ITEM_FIELDS } from "./item-fields.mjs";
 
 /** A map-valued property, whose entries the compiler walks by key. */
@@ -302,9 +303,16 @@ const PRESENTATION_FIELDS = Object.freeze({
  * Every content type this package compiles, and what a note of that type may
  * write.
  *
+ * The engine's own types are merged in first, so a SoHL tree is checked against
+ * one vocabulary rather than two. They are declared there rather than here
+ * because they are note-format knowledge — a `homepage` carries no `system`
+ * block and would mean the same thing for a game system that is not SoHL — and
+ * because a package declaring no `itemBuilders` never reaches this file (#51).
+ *
  * @type {Readonly<Record<string, readonly import("../engine/field-spec.mjs").FieldSpec[]>>}
  */
 export const NOTE_SCHEMAS = Object.freeze({
+    ...ENGINE_NOTE_SCHEMAS,
     ...Object.fromEntries(
         Object.entries(ITEM_FIELDS).map(([type, fields]) => [
             type,

package/types/content-config.d.mts

@@ -1,3 +1,19 @@
+/**
+ * Whether this package publishes the pages its content tree compiles to.
+ *
+ * The one question every reader of the mode actually asks — the site build, to
+ * decide whether to walk the tree at all, and the link-manifest emitter, to
+ * decide whether an entry carries a web `path`. Written once here so the two
+ * cannot come to disagree about what a mode means.
+ *
+ * @param {{publish: {site: SiteMode}}} config - A resolved configuration.
+ * @returns {boolean} Whether content pages are published.
+ */
+export function publishesContentPages(config: {
+    publish: {
+        site: SiteMode;
+    };
+}): boolean;
 /**
  * Validate and normalize a content configuration.
  *
@@ -76,6 +92,77 @@ export const DEFAULT_ADDRESS_SCHEME: Readonly<{
     prefix: "";
     landing: "readme";
 }>;
+/**
+ * How much of a package reaches the web.
+ *
+ * Every HeroicLands package publishes something: a top-level, human-authored
+ * homepage at `https://www.heroiclands.org/<contentPackage>/` saying what the
+ * module is, which system it needs and how to install it (#50). So there is no
+ * value here meaning *no web presence at all* — homepage-only is the **floor**,
+ * and the default.
+ *
+ * - `homepage` — the authored homepage, and **no other page**. The content tree
+ *   is not walked for pages, `site.sections` / `site.trees` / `site.landing`
+ *   emit nothing, and link-manifest entries carry no web `path`.
+ * - `content` — the homepage *plus* every page the content tree publishes: the
+ *   knowledgebase, the extra trees, the section landings.
+ *
+ * **Homepage-only is a first-class mode, not an accommodation.**
+ * `sohl-kethira-basic` (unofficial Hârn fan material under Keléstia Productions'
+ * Fan Material Guidelines) and `harn-adventures` (HârnFanon under Lythia's
+ * terms) must each publish a homepage and nothing beneath it — two packages
+ * under two different fan-content licences. The boundary is **published
+ * content**: journal text, artwork, item descriptions, compiled notes. A
+ * human-authored page announcing the module discloses none of it. Because the
+ * failure mode is silent — a `site:` block added later ships licensed content
+ * with nobody noticing — the mode fences the content surfaces off rather than
+ * trusting a configuration to stay empty.
+ *
+ * This was a boolean until 5.0.0, and `false` read as "no web presence", which
+ * no longer describes any package. Both spellings are refused rather than
+ * mapped: a value silently reinterpreted reads to its author as though it still
+ * means what it said.
+ *
+ * @typedef {"homepage" | "content"} SiteMode
+ */
+/**
+ * The publishing modes {@link PublishSwitches.site} may name, floor first.
+ *
+ * @satisfies {readonly SiteMode[]}
+ */
+export const SITE_MODES: readonly ["homepage", "content"];
+/**
+ * How much of a package reaches the web.
+ *
+ * Every HeroicLands package publishes something: a top-level, human-authored
+ * homepage at `https://www.heroiclands.org/<contentPackage>/` saying what the
+ * module is, which system it needs and how to install it (#50). So there is no
+ * value here meaning *no web presence at all* — homepage-only is the **floor**,
+ * and the default.
+ *
+ * - `homepage` — the authored homepage, and **no other page**. The content tree
+ *   is not walked for pages, `site.sections` / `site.trees` / `site.landing`
+ *   emit nothing, and link-manifest entries carry no web `path`.
+ * - `content` — the homepage *plus* every page the content tree publishes: the
+ *   knowledgebase, the extra trees, the section landings.
+ *
+ * **Homepage-only is a first-class mode, not an accommodation.**
+ * `sohl-kethira-basic` (unofficial Hârn fan material under Keléstia Productions'
+ * Fan Material Guidelines) and `harn-adventures` (HârnFanon under Lythia's
+ * terms) must each publish a homepage and nothing beneath it — two packages
+ * under two different fan-content licences. The boundary is **published
+ * content**: journal text, artwork, item descriptions, compiled notes. A
+ * human-authored page announcing the module discloses none of it. Because the
+ * failure mode is silent — a `site:` block added later ships licensed content
+ * with nobody noticing — the mode fences the content surfaces off rather than
+ * trusting a configuration to stay empty.
+ *
+ * This was a boolean until 5.0.0, and `false` read as "no web presence", which
+ * no longer describes any package. Both spellings are refused rather than
+ * mapped: a value silently reinterpreted reads to its author as though it still
+ * means what it said.
+ */
+export type SiteMode = "homepage" | "content";
 export type PackageKind = "systems" | "modules";
 export type PackDocumentType = "Actor" | "Adventure" | "Item" | "JournalEntry" | "Macro" | "Scene";
 /**
@@ -272,9 +359,10 @@ export type ManifestSwitches = {
 };
 export type PublishSwitches = {
     /**
-     * Render this package's knowledgebase/site pages.
+     * How much of this package reaches the web.
+     * See {@link SITE_MODES}.
      */
-    site: boolean;
+    site: SiteMode;
     manifests: ManifestSwitches;
 };
 export type ManifestSwitchesInput = {
@@ -394,8 +482,19 @@ export type DocsSpec = {
     itemFields?: DocPageSpec | undefined;
 };
 export type PublishSwitchesInput = {
-    site?: boolean | undefined;
+    site?: SiteMode | undefined;
     manifests?: ManifestSwitchesInput | undefined;
+    address?: AddressSchemeInput | undefined;
+};
+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.
@@ -502,7 +601,9 @@ export type ContentBuildConfigInput = {
      */
     relationships?: Relationships | undefined;
     /**
-     * Publishing switches. Each defaults to off.
+     * Publishing switches. The manifest
+     * switches default to off; `site`
+     * defaults to `homepage`, the floor.
      */
     publish?: PublishSwitchesInput | undefined;
 };

package/types/engine/base-compiler.d.mts

@@ -2,18 +2,17 @@
  * The tallies one pass accumulates while walking the tree.
  *
  * `declined` and `skippedOther` are deliberately separate numbers. A declined
- * note is one this build **refused** — it names a package this repository does
- * not compile — and it is an error; a skipped one legitimately belongs to
- * another pass, and there are thousands of those. Folding the first into the
- * second is what let a whole tree be filtered out in silence (#56).
+ * note is one this build **refused** — it declares a retired frontmatter field
+ * — and it is an error; a skipped one legitimately belongs to another pass, and
+ * there are thousands of those. Folding the first into the second is what let a
+ * whole tree be filtered out in silence (#56).
  *
  * @typedef {object} PassStats
  * @property {number} compiled - Notes that became a document.
- * @property {number} skippedDraft - Notes marked `draft: true`.
  * @property {number} skippedNoId - Notes with no `id`, where that is tolerated.
  * @property {number} skippedOther - Notes this pass does not claim.
- * @property {number} declined - Notes refused because they declare another
- *   package. Counted as errors, never as skips.
+ * @property {number} declined - Notes refused because they declare a retired
+ *   frontmatter field. Counted as errors, never as skips.
  */
 /**
  * The shared walk → filter → expand → convert → build → write → count loop.
@@ -310,20 +309,16 @@ export class BasePackCompiler {
  * The tallies one pass accumulates while walking the tree.
  *
  * `declined` and `skippedOther` are deliberately separate numbers. A declined
- * note is one this build **refused** — it names a package this repository does
- * not compile — and it is an error; a skipped one legitimately belongs to
- * another pass, and there are thousands of those. Folding the first into the
- * second is what let a whole tree be filtered out in silence (#56).
+ * note is one this build **refused** — it declares a retired frontmatter field
+ * — and it is an error; a skipped one legitimately belongs to another pass, and
+ * there are thousands of those. Folding the first into the second is what let a
+ * whole tree be filtered out in silence (#56).
  */
 export type PassStats = {
     /**
      * - Notes that became a document.
      */
     compiled: number;
-    /**
-     * - Notes marked `draft: true`.
-     */
-    skippedDraft: number;
     /**
      * - Notes with no `id`, where that is tolerated.
      */
@@ -333,8 +328,8 @@ export type PassStats = {
      */
     skippedOther: number;
     /**
-     * - Notes refused because they declare another
-     * package. Counted as errors, never as skips.
+     * - Notes refused because they declare a retired
+     * frontmatter field. Counted as errors, never as skips.
      */
     declined: number;
 };

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

@@ -12,8 +12,9 @@
  * `package:` frontmatter and the compilers kept the ones that matched. Every
  * content tree is single-package — each is single-sourced in the repository that
  * ships it — so the field restated this constant once per note while a value
- * that matched nothing filtered the whole tree out in silence. The field is
- * being retired; the value stays, here, where it is declared once.
+ * that matched nothing filtered the whole tree out in silence. That field is
+ * retired and declaring it now fails the build; this value stays, here, where
+ * it is declared once.
  *
  * Stable across compilation targets. If this content were ever compiled for a
  * second game system, it would still be published as `sohl` — only the Foundry

package/types/engine/helpers.d.mts

@@ -274,17 +274,15 @@ export function collectContentDocs(contentBase: string): Array<{
  * Expand the fenced `dataview` tables in one note's markdown, before wikilinks
  * are resolved — so a generated cell may itself be a wikilink.
  *
- * A table searches only notes of the source note's own package, so a SoHL page
- * never tabulates setting-package content (and vice versa). Each candidate's
- * package is **derived** rather than read out of its frontmatter: `package:` is
- * optional, and comparing a declared value with an absent one would drop every
- * unswept — or every swept — note from the table (#56).
+ * A table searches the whole tree, which is one package's notes and nothing
+ * else — so there is no longer a package to scope on. It used to filter, back
+ * when a tree could hold several packages' notes and `package:` said which was
+ * which; that field is retired and the filter with it (#56).
  *
  * @param {string} body - The note's markdown body.
  * @param {object} ctx
  * @param {Array<object>} ctx.docs - From {@link collectContentDocs}.
  * @param {string} ctx.name - The note, for the error message.
- * @param {string} [ctx.pkg] - The source note's package.
  * @param {object} [ctx.fm] - The source note's frontmatter, which is what a
  *   query's `this` reads. Its entry in `docs` supplies the path as well.
  * @param {number} [ctx.bodyLine] - 1-based file line of the body's first line,
@@ -297,10 +295,9 @@ export function collectContentDocs(contentBase: string): Array<{
  *   compile rather than shipping a table-shaped hole. The error carries
  *   `position`, the directive's own line.
  */
-export function expandNoteTables(body: string, { docs, name, pkg, fm, bodyLine }: {
+export function expandNoteTables(body: string, { docs, name, fm, bodyLine }: {
     docs: Array<object>;
     name: string;
-    pkg?: string | undefined;
     fm?: object | undefined;
     bodyLine?: number | undefined;
 }): {